LibreOffice Module sw (master)  1
wrtw8sty.cxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
20 #include <algorithm>
21 #include <functional>
22 
23 #include <memory>
24 
25 #include <com/sun/star/i18n/ScriptType.hpp>
26 #include <rtl/tencinfo.h>
27 #include <hintids.hxx>
28 #include <editeng/boxitem.hxx>
29 #include <editeng/fontitem.hxx>
30 #include <svx/svdobj.hxx>
31 #include <svx/svdotext.hxx>
32 #include <svx/svdouno.hxx>
33 #include <svx/fmglob.hxx>
34 #include <editeng/frmdiritem.hxx>
35 #include <editeng/lrspitem.hxx>
36 #include <editeng/ulspitem.hxx>
37 #include <doc.hxx>
38 #include "wrtww8.hxx"
39 #include <docary.hxx>
40 #include <poolfmt.hxx>
41 #include <fmtpdsc.hxx>
42 #include <pagedesc.hxx>
43 #include <ndtxt.hxx>
44 #include <ftninfo.hxx>
45 #include <fmthdft.hxx>
46 #include <section.hxx>
47 #include <fmtcntnt.hxx>
48 #include <fmtftn.hxx>
49 #include <ndindex.hxx>
50 #include <txtftn.hxx>
51 #include <charfmt.hxx>
52 #include <docufld.hxx>
53 #include <dcontact.hxx>
54 #include <fmtcnct.hxx>
55 #include <ftnidx.hxx>
56 #include <fmtclds.hxx>
57 #include <lineinfo.hxx>
58 #include <fmtline.hxx>
59 #include <swtable.hxx>
60 #include <redline.hxx>
61 #include <msfilter.hxx>
62 #include <swmodule.hxx>
63 
64 #include "sprmids.hxx"
65 
66 #include "writerhelper.hxx"
67 #include "writerwordglue.hxx"
68 #include <wwstyles.hxx>
69 #include "ww8par.hxx"
70 #include "ww8attributeoutput.hxx"
71 #include "docxattributeoutput.hxx"
72 #include "rtfattributeoutput.hxx"
74 
75 #include <unordered_set>
76 
77 using namespace css;
78 using namespace sw::util;
79 using namespace nsHdFtFlags;
80 
83 {
84  std::unique_ptr<sal_uInt8[]> m_pData;
85  sal_uInt16 m_nLen;
87  WW8_PdAttrDesc() : m_nLen(0), m_nSepxFcPos(0xffffffff) /*default: none*/
88  { }
89 };
90 
91 struct WW8_SED
92 {
93  SVBT16 aBits1; // orientation change + internal, Default: 6
94  SVBT32 fcSepx; // FC file offset to beginning of SEPX for section.
95  // 0xFFFFFFFF for no Sprms
96  SVBT16 fnMpr; // used internally by Windows Word, Default: 0
97  SVBT32 fcMpr; // FC, points to offset in FC space for MacWord
98  // Default: 0xffffffff ( nothing )
99  // cbSED is 12 (decimal)), C (hex).
100 };
101 
102 // class WW8_WrPlc0 is only used for header and footer positioning
103 // ie there is no content support structure
105 {
106 private:
107  std::vector<sal_uLong> aPos; // PTRARR of CPs / FCs
109 
110  WW8_WrPlc0(WW8_WrPlc0 const&) = delete;
111  WW8_WrPlc0& operator=(WW8_WrPlc0 const&) = delete;
112 
113 public:
114  explicit WW8_WrPlc0( sal_uLong nOffset );
115  sal_uInt16 Count() const { return aPos.size(); }
116  void Append( sal_uLong nStartCpOrFc );
117  void Write( SvStream& rStrm );
118 };
119 
120 // Styles
121 
122 #define WW8_RESERVED_SLOTS 15
123 
124 // GetId( SwCharFormat ) for use in text -> zero is not allowed,
125 // use "Default Char Style" instead
126 sal_uInt16 MSWordExportBase::GetId( const SwCharFormat* pFormat ) const
127 {
128  sal_uInt16 nRet = m_pStyles->GetSlot( pFormat );
129  return ( nRet != 0x0fff ) ? nRet : 10; // Default Char Style
130 }
131 
132 // GetId( SwTextFormatColl ) for use in TextNodes -> zero is not allowed,
133 // "Standard" instead
134 sal_uInt16 MSWordExportBase::GetId( const SwTextFormatColl& rColl ) const
135 {
136  sal_uInt16 nRet = m_pStyles->GetSlot( &rColl );
137  return ( nRet != 0xfff ) ? nRet : 0; // Default TextFormatColl
138 }
139 
140 //typedef pFormatT
141 MSWordStyles::MSWordStyles( MSWordExportBase& rExport, bool bListStyles )
142  : m_rExport( rExport ),
143  m_bListStyles(bListStyles)
144 {
145  // if exist any Foot-/End-Notes then get from the EndNoteInfo struct
146  // the CharFormats. They will create it!
148  {
153  }
154  sal_uInt16 nAlloc = WW8_RESERVED_SLOTS + m_rExport.m_pDoc->GetCharFormats()->size() - 1 +
156  (bListStyles ? m_rExport.m_pDoc->GetNumRuleTable().size() - 1 : 0);
157 
158  // somewhat generous ( free for up to 15 )
159  m_pFormatA.reset( new SwFormat*[ nAlloc ] );
160  memset( m_pFormatA.get(), 0, nAlloc * sizeof( SwFormat* ) );
161  memset( m_aHeadingParagraphStyles, -1 , MAXLEVEL * sizeof( sal_uInt16));
162 
164  BuildStyleIds();
165 }
166 
168 {
169 }
170 
171 // Sty_SetWWSlot() dependencies for the styles -> zero is allowed
172 sal_uInt16 MSWordStyles::GetSlot( const SwFormat* pFormat ) const
173 {
174  sal_uInt16 n;
175  for ( n = 0; n < m_nUsedSlots; n++ )
176  if ( m_pFormatA[n] == pFormat )
177  return n;
178  return 0xfff; // 0xfff: WW: zero
179 }
180 
181 sal_uInt16 MSWordStyles::BuildGetSlot( const SwFormat& rFormat )
182 {
183  sal_uInt16 nRet = rFormat.GetPoolFormatId();
184  switch ( nRet )
185  {
187  nRet = 0;
188  break;
189 
199  nRet -= RES_POOLCOLL_HEADLINE1-1;
200  break;
201 
202  default:
203  nRet = m_nUsedSlots++;
204  break;
205  }
206  return nRet;
207 }
208 
209 
210 sal_uInt16 MSWordStyles::GetWWId( const SwFormat& rFormat )
211 {
212  sal_uInt16 nRet = ww::stiUser; // user style as default
213  sal_uInt16 nPoolId = rFormat.GetPoolFormatId();
214  if( nPoolId == RES_POOLCOLL_STANDARD )
215  nRet = 0;
216  else if( nPoolId >= RES_POOLCOLL_HEADLINE1 &&
217  nPoolId <= RES_POOLCOLL_HEADLINE9 )
218  nRet = static_cast< sal_uInt16 >(nPoolId + 1 - RES_POOLCOLL_HEADLINE1);
219  else if( nPoolId >= RES_POOLCOLL_TOX_IDX1 &&
220  nPoolId <= RES_POOLCOLL_TOX_IDX3 )
221  nRet = static_cast< sal_uInt16 >(nPoolId + 10 - RES_POOLCOLL_TOX_IDX1);
222  else if( nPoolId >= RES_POOLCOLL_TOX_CNTNT1 &&
223  nPoolId <= RES_POOLCOLL_TOX_CNTNT5 )
224  nRet = static_cast< sal_uInt16 >(nPoolId + 19 - RES_POOLCOLL_TOX_CNTNT1);
225  else if( nPoolId >= RES_POOLCOLL_TOX_CNTNT6 &&
226  nPoolId <= RES_POOLCOLL_TOX_CNTNT9 )
227  nRet = static_cast< sal_uInt16 >(nPoolId + 24 - RES_POOLCOLL_TOX_CNTNT6);
228  else
229  switch( nPoolId )
230  {
231  case RES_POOLCOLL_FOOTNOTE: nRet = 29; break;
232  case RES_POOLCOLL_MARGINAL: nRet = 30; break;
233  case RES_POOLCOLL_HEADER: nRet = 31; break;
234  case RES_POOLCOLL_FOOTER: nRet = 32; break;
235  case RES_POOLCOLL_TOX_IDXH: nRet = 33; break;
236  case RES_POOLCOLL_LABEL: nRet = 34; break;
237  case RES_POOLCOLL_LABEL_DRAWING: nRet = 35; break;
238  case RES_POOLCOLL_JAKETADRESS: nRet = 36; break;
239  case RES_POOLCOLL_SENDADRESS: nRet = 37; break;
240  case RES_POOLCOLL_ENDNOTE: nRet = 43; break;
241  case RES_POOLCOLL_TOX_AUTHORITIESH: nRet = 44; break;
242  case RES_POOLCOLL_TOX_CNTNTH: nRet = 46; break;
243  case RES_POOLCOLL_BUL_LEVEL1: nRet = 48; break;
244  case RES_POOLCOLL_LISTS_BEGIN: nRet = 47; break;
245  case RES_POOLCOLL_NUM_LEVEL1: nRet = 49; break;
246  case RES_POOLCOLL_BUL_LEVEL2: nRet = 54; break;
247  case RES_POOLCOLL_BUL_LEVEL3: nRet = 55; break;
248  case RES_POOLCOLL_BUL_LEVEL4: nRet = 56; break;
249  case RES_POOLCOLL_BUL_LEVEL5: nRet = 57; break;
250  case RES_POOLCOLL_NUM_LEVEL2: nRet = 58; break;
251  case RES_POOLCOLL_NUM_LEVEL3: nRet = 59; break;
252  case RES_POOLCOLL_NUM_LEVEL4: nRet = 60; break;
253  case RES_POOLCOLL_NUM_LEVEL5: nRet = 61; break;
254  case RES_POOLCOLL_DOC_TITEL: nRet = 62; break;
255  case RES_POOLCOLL_SIGNATURE: nRet = 64; break;
256  case RES_POOLCOLL_TEXT: nRet = 66; break;
257  case RES_POOLCOLL_TEXT_MOVE: nRet = 67; break;
258  case RES_POOLCOLL_BUL_NONUM1: nRet = 68; break;
259  case RES_POOLCOLL_BUL_NONUM2: nRet = 69; break;
260  case RES_POOLCOLL_BUL_NONUM3: nRet = 70; break;
261  case RES_POOLCOLL_BUL_NONUM4: nRet = 71; break;
262  case RES_POOLCOLL_BUL_NONUM5: nRet = 72; break;
263  case RES_POOLCOLL_DOC_SUBTITEL: nRet = 74; break;
264  case RES_POOLCOLL_GREETING: nRet = 75; break;
265  case RES_POOLCOLL_TEXT_IDENT: nRet = 77; break;
266 
267  case RES_POOLCHR_FOOTNOTE_ANCHOR: nRet = 38; break;
268  case RES_POOLCHR_ENDNOTE_ANCHOR: nRet = 42; break;
269  case RES_POOLCHR_INET_NORMAL: nRet = 85; break;
270  case RES_POOLCHR_INET_VISIT: nRet = 86; break;
271  case RES_POOLCHR_HTML_STRONG: nRet = 87; break;
272  case RES_POOLCHR_HTML_EMPHASIS: nRet = 88; break;
273  case RES_POOLCHR_LINENUM: nRet = 40; break;
274  case RES_POOLCHR_PAGENO: nRet = 41; break;
275  }
276  return nRet;
277 }
278 
280 {
281  m_nUsedSlots = WW8_RESERVED_SLOTS; // reserved slots for standard, headingX, and others
282 
283  const SwCharFormats& rArr = *m_rExport.m_pDoc->GetCharFormats(); // first CharFormat
284  // the default character style ( 0 ) will not be outputted !
285  for( size_t n = 1; n < rArr.size(); n++ )
286  {
287  SwCharFormat* pFormat = rArr[n];
288  m_pFormatA[ BuildGetSlot( *pFormat ) ] = pFormat;
289  }
290 
291  const SwTextFormatColls& rArr2 = *m_rExport.m_pDoc->GetTextFormatColls(); // then TextFormatColls
292  // the default character style ( 0 ) will not be outputted !
293  for( size_t n = 1; n < rArr2.size(); n++ )
294  {
295  SwTextFormatColl* pFormat = rArr2[n];
296  sal_uInt16 nId = BuildGetSlot( *pFormat ) ;
297  m_pFormatA[ nId ] = pFormat;
298  if ( pFormat->IsAssignedToListLevelOfOutlineStyle() )
299  {
300  int nLvl = pFormat->GetAssignedOutlineStyleLevel() ;
301  if (nLvl >= 0 && nLvl < MAXLEVEL)
302  m_aHeadingParagraphStyles[nLvl] = nId ;
303  }
304  }
305 
306  if (!m_bListStyles)
307  return;
308 
309  const SwNumRuleTable& rNumRuleTable = m_rExport.m_pDoc->GetNumRuleTable();
310  for (size_t i = 0; i < rNumRuleTable.size(); ++i)
311  {
312  const SwNumRule* pNumRule = rNumRuleTable[i];
313  if (pNumRule->IsAutoRule() || pNumRule->GetName().startsWith("WWNum"))
314  continue;
315  sal_uInt16 nSlot = BuildGetSlot(*pNumRule);
316  m_aNumRules[nSlot] = pNumRule;
317  }
318 }
319 
321 {
322  std::unordered_set<OString> aUsed;
323 
324  m_aStyleIds.emplace_back("Normal");
325  aUsed.insert("normal");
326 
327  for (sal_uInt16 n = 1; n < m_nUsedSlots; ++n)
328  {
329  OUString aName;
330  if(m_pFormatA[n])
331  aName = m_pFormatA[n]->GetName();
332  else if (m_aNumRules.find(n) != m_aNumRules.end())
333  aName = m_aNumRules[n]->GetName();
334  OStringBuffer aStyleIdBuf(aName.getLength());
335  for (int i = 0; i < aName.getLength(); ++i)
336  {
337  sal_Unicode nChar = aName[i];
338  if (('0' <= nChar && nChar <= '9') ||
339  ('a' <= nChar && nChar <= 'z') ||
340  ('A' <= nChar && nChar <= 'Z'))
341  {
342  // first letter should be uppercase
343  if (aStyleIdBuf.isEmpty() && 'a' <= nChar && nChar <= 'z')
344  aStyleIdBuf.append(char(nChar - ('a' - 'A')));
345  else
346  aStyleIdBuf.append(char(nChar));
347  }
348  }
349 
350  OString aStyleId(aStyleIdBuf.makeStringAndClear());
351  if (aStyleId.isEmpty())
352  aStyleId = "Style";
353 
354  OString aLower(aStyleId.toAsciiLowerCase());
355 
356  // check for uniqueness & construct something unique if we have to
357  if (aUsed.insert(aLower).second)
358  {
359  m_aStyleIds.push_back(aStyleId);
360  }
361  else
362  {
363  int nFree = 1;
364  while (!aUsed.insert(aLower + OString::number(nFree)).second)
365  ++nFree;
366 
367  m_aStyleIds.emplace_back(aStyleId + OString::number(nFree));
368  }
369  }
370 }
371 
372 OString const & MSWordStyles::GetStyleId(sal_uInt16 nId) const
373 {
374  return m_aStyleIds[nId];
375 }
376 
378 static void impl_SkipOdd(std::unique_ptr<ww::bytes> const& pO, std::size_t nTableStrmTell)
379 {
380  if ( ( nTableStrmTell + pO->size() ) & 1 ) // start on even
381  pO->push_back( sal_uInt8(0) ); // Address
382 }
383 
385 {
387 
388  short nLen = m_rWW8Export.pO->size() - 2; // length of the style
389  sal_uInt8* p = m_rWW8Export.pO->data() + nPOPosStdLen1;
390  ShortToSVBT16( nLen, p ); // add
391  p = m_rWW8Export.pO->data() + nPOPosStdLen2;
392  ShortToSVBT16( nLen, p ); // also
393 
395  m_rWW8Export.pO->clear();
396 }
397 
398 void WW8AttributeOutput::StartStyle( const OUString& rName, StyleType eType, sal_uInt16 nWwBase,
399  sal_uInt16 nWwNext, sal_uInt16 nWwId, sal_uInt16 /*nId*/, bool bAutoUpdate )
400 {
401  sal_uInt8 aWW8_STD[ sizeof( WW8_STD ) ];
402  sal_uInt8* pData = aWW8_STD;
403  memset( &aWW8_STD, 0, sizeof( WW8_STD ) );
404 
405  sal_uInt16 nBit16 = 0x1000; // fInvalHeight
406  nBit16 |= (ww::stiNil & nWwId);
407  Set_UInt16( pData, nBit16 );
408 
409  nBit16 = nWwBase << 4; // istdBase
410  nBit16 |= (eType == STYLE_TYPE_PARA ? 1 : 2); // sgc
411  Set_UInt16( pData, nBit16 );
412 
413  nBit16 = nWwNext << 4; // istdNext
414  nBit16 |= (eType == STYLE_TYPE_PARA ? 2 : 1); // cupx
415  Set_UInt16( pData, nBit16 );
416 
417  pData += sizeof( sal_uInt16 ); // bchUpe
418 
419  nBit16 = bAutoUpdate ? 1 : 0; // fAutoRedef : 1
420  Set_UInt16( pData, nBit16 );
421  // now new:
422  // from Ver8 there are two fields more:
423  // sal_uInt16 fHidden : 1; /* hidden from UI?
424  // sal_uInt16 : 14; /* unused bits
425 
426  sal_uInt16 nLen = static_cast< sal_uInt16 >( ( pData - aWW8_STD ) + 1 +
427  (2 * (rName.getLength() + 1)) ); // temporary
428 
429  nPOPosStdLen1 = m_rWW8Export.pO->size(); // Adr1 for adding the length
430 
432  m_rWW8Export.pO->insert( m_rWW8Export.pO->end(), aWW8_STD, pData );
433 
434  nPOPosStdLen2 = nPOPosStdLen1 + 8; // Adr2 for adding of "end of upx"
435 
436  // write names
437  SwWW8Writer::InsUInt16( *m_rWW8Export.pO, rName.getLength() ); // length
439  m_rWW8Export.pO->push_back( sal_uInt8(0) ); // Despite P-String 0 at the end!
440 }
441 
442 void MSWordStyles::SetStyleDefaults( const SwFormat& rFormat, bool bPap )
443 {
444  const SwModify* pOldMod = m_rExport.m_pOutFormatNode;
445  m_rExport.m_pOutFormatNode = &rFormat;
446  bool aFlags[ static_cast< sal_uInt16 >(RES_FRMATR_END) - RES_CHRATR_BEGIN ];
447  sal_uInt16 nStt, nEnd, n;
448  if( bPap )
449  {
450  nStt = RES_PARATR_BEGIN;
451  nEnd = RES_FRMATR_END;
452  }
453  else
454  {
455  nStt = RES_CHRATR_BEGIN;
456  nEnd = RES_TXTATR_END;
457  }
458 
459  // dynamic defaults
460  const SfxItemPool& rPool = *rFormat.GetAttrSet().GetPool();
461  for( n = nStt; n < nEnd; ++n )
462  aFlags[ n - RES_CHRATR_BEGIN ] = nullptr != rPool.GetPoolDefaultItem( n )
463  || SfxItemState::SET == m_rExport.m_pDoc->GetDfltTextFormatColl()->GetItemState( n, false );
464 
465  // static defaults, that differs between WinWord and SO
466  if( bPap )
467  {
468  aFlags[ static_cast< sal_uInt16 >(RES_PARATR_WIDOWS) - RES_CHRATR_BEGIN ] = true;
469  aFlags[ static_cast< sal_uInt16 >(RES_PARATR_HYPHENZONE) - RES_CHRATR_BEGIN ] = true;
470  aFlags[ static_cast< sal_uInt16 >(RES_FRAMEDIR) - RES_CHRATR_BEGIN ] = true;
471  }
472  else
473  {
474  aFlags[ RES_CHRATR_FONTSIZE - RES_CHRATR_BEGIN ] = true;
475  aFlags[ RES_CHRATR_LANGUAGE - RES_CHRATR_BEGIN ] = true;
476  }
477 
478  const SfxItemSet* pOldI = m_rExport.GetCurItemSet();
479  m_rExport.SetCurItemSet( &rFormat.GetAttrSet() );
480 
481  const bool* pFlags = aFlags + ( nStt - RES_CHRATR_BEGIN );
482  for ( n = nStt; n < nEnd; ++n, ++pFlags )
483  {
484  if ( *pFlags && !m_rExport.ignoreAttributeForStyleDefaults( n )
485  && SfxItemState::SET != rFormat.GetItemState(n, false))
486  {
487  //If we are a character property then see if it is one of the
488  //western/asian ones that must be collapsed together for export to
489  //word. If so default to the western variant.
490  if ( bPap || m_rExport.CollapseScriptsforWordOk(
491  i18n::ScriptType::LATIN, n) )
492  {
493  m_rExport.AttrOutput().OutputItem( rFormat.GetFormatAttr( n ) );
494  }
495  }
496  }
497 
498  m_rExport.SetCurItemSet( pOldI );
499  m_rExport.m_pOutFormatNode = pOldMod;
500 }
501 
502 void WW8AttributeOutput::StartStyleProperties( bool bParProp, sal_uInt16 nStyle )
503 {
505 
506  sal_uInt16 nLen = bParProp ? 2 : 0; // default length
507  m_nStyleLenPos = m_rWW8Export.pO->size(); // adding length
508  // Don't save pointer, because it
509  // changes by _grow!
510 
511  SwWW8Writer::InsUInt16( *m_rWW8Export.pO, nLen ); // Style-Len
512 
514 
515  if ( bParProp )
516  SwWW8Writer::InsUInt16( *m_rWW8Export.pO, nStyle ); // Style-Number
517 }
518 
519 void MSWordStyles::WriteProperties( const SwFormat* pFormat, bool bParProp, sal_uInt16 nPos,
520  bool bInsDefCharSiz )
521 {
522  m_rExport.AttrOutput().StartStyleProperties( bParProp, nPos );
523 
524  OSL_ENSURE( m_rExport.m_pCurrentStyle == nullptr, "Current style not NULL" ); // set current style before calling out
525  m_rExport.m_pCurrentStyle = pFormat;
526 
527  m_rExport.OutputFormat( *pFormat, bParProp, !bParProp );
528 
529  OSL_ENSURE( m_rExport.m_pCurrentStyle == pFormat, "current style was changed" );
530  // reset current style...
531  m_rExport.m_pCurrentStyle = nullptr;
532 
533  if ( bInsDefCharSiz ) // not derived from other Style
534  SetStyleDefaults( *pFormat, bParProp );
535 
537 }
538 
539 void WW8AttributeOutput::EndStyleProperties( bool /*bParProp*/ )
540 {
541  sal_uInt16 nLen = m_rWW8Export.pO->size() - m_nStyleStartSize;
542  sal_uInt8* pUpxLen = m_rWW8Export.pO->data() + m_nStyleLenPos; // adding length
543  ShortToSVBT16( nLen, pUpxLen ); // add default length
544 }
545 
546 void MSWordStyles::GetStyleData( SwFormat* pFormat, bool& bFormatColl, sal_uInt16& nBase, sal_uInt16& nNext )
547 {
548  bFormatColl = pFormat->Which() == RES_TXTFMTCOLL || pFormat->Which() == RES_CONDTXTFMTCOLL;
549 
550  // Default: none
551  nBase = 0xfff;
552 
553  // Derived from?
554  if ( !pFormat->IsDefault() )
555  nBase = GetSlot( pFormat->DerivedFrom() );
556 
557  SwFormat* pNext;
558  if ( bFormatColl )
559  pNext = &static_cast<SwTextFormatColl*>(pFormat)->GetNextTextFormatColl();
560  else
561  pNext = pFormat; // CharFormat: next CharFormat == self
562 
563  nNext = GetSlot( pNext );
564 }
565 
567 {
568  m_rWW8Export.pTableStrm->WriteUInt16(0); // empty Style
569 }
570 
571 void MSWordStyles::OutputStyle(const SwNumRule* pNumRule, sal_uInt16 nPos)
572 {
574  /*nBase =*/ 0, /*nWwNext =*/ 0, /*nWWId =*/ 0, nPos,
575  /*bAutoUpdateFormat =*/ false );
576 
578 }
579 
580 // OutputStyle applies for TextFormatColls and CharFormats
581 void MSWordStyles::OutputStyle( SwFormat* pFormat, sal_uInt16 nPos )
582 {
583  if ( !pFormat )
585  else
586  {
587  bool bFormatColl;
588  sal_uInt16 nBase, nWwNext;
589 
590  GetStyleData( pFormat, bFormatColl, nBase, nWwNext );
591 
592  OUString aName = pFormat->GetName();
593  // We want to map LO's default style to Word's "Normal" style.
594  // Word looks for this specific style name when reading docx files.
595  // (It must be the English word regardless of language settings)
596  if ( nPos == 0 )
597  {
598  assert( pFormat->GetPoolFormatId() == RES_POOLCOLL_STANDARD );
599  aName = "Normal";
600  }
601  else if (aName.equalsIgnoreAsciiCase("Normal"))
602  {
603  // If LO has a style named "Normal"(!) rename it to something unique
604  const OUString aBaseName = "LO-" + aName;
605  aName = aBaseName;
606  // Check if we still have a clash, in which case we add a suffix
607  for ( int nSuffix = 0; ; ++nSuffix ) {
608  bool clash=false;
609  for ( sal_uInt16 n = 1; n < m_nUsedSlots; ++n )
610  if ( m_pFormatA[n] &&
611  m_pFormatA[n]->GetName().equalsIgnoreAsciiCase(aName) )
612  {
613  clash = true;
614  break;
615  }
616  if (!clash)
617  break;
618  // TODO: verify if we really need to increment nSuffix in 2 places
619  aName = aBaseName + OUString::number(++nSuffix);
620  }
621  }
622  else if (!bFormatColl && m_rExport.m_pStyles->GetStyleId(nPos).startsWith("ListLabel"))
623  {
624  // tdf#92335 don't export redundant DOCX import style "ListLabel"
625  return;
626  }
627 
628  m_rExport.AttrOutput().StartStyle( aName, (bFormatColl ? STYLE_TYPE_PARA : STYLE_TYPE_CHAR),
629  nBase, nWwNext, GetWWId( *pFormat ), nPos,
630  pFormat->IsAutoUpdateFormat() );
631 
632  if ( bFormatColl )
633  WriteProperties( pFormat, true, nPos, nBase==0xfff ); // UPX.papx
634 
635  WriteProperties( pFormat, false, nPos, bFormatColl && nBase==0xfff ); // UPX.chpx
636 
638  }
639 }
640 
642 {
643  WW8Fib& rFib = *m_rWW8Export.pFib;
644 
645  sal_uLong nCurPos = m_rWW8Export.pTableStrm->Tell();
646  if ( nCurPos & 1 ) // start on even
647  {
648  m_rWW8Export.pTableStrm->WriteChar( char(0) ); // Address
649  ++nCurPos;
650  }
651  rFib.m_fcStshfOrig = rFib.m_fcStshf = nCurPos;
652  m_nStyleCountPos = nCurPos + 2; // count is added later
653 
654  static sal_uInt8 aStShi[] = {
655  0x12, 0x00,
656  0x0F, 0x00, 0x0A, 0x00, 0x01, 0x00, 0x5B, 0x00,
657  0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
658  0x00, 0x00 };
659 
660  m_rWW8Export.pTableStrm->WriteBytes(&aStShi, sizeof(aStShi));
661 }
662 
663 void WW8AttributeOutput::EndStyles( sal_uInt16 nNumberOfStyles )
664 {
665  WW8Fib& rFib = *m_rWW8Export.pFib;
666 
669 }
670 
672 {
673  m_rExport.m_bStyDef = true;
674 
676 
677  sal_uInt16 n;
678  // HACK
679  // Ms Office seems to have an internal limitation of 4091 styles
680  // and refuses to load .docx with more, even though the spec seems to allow that;
681  // so simply if there are more styles, don't export those
682  // Implementing check for all exports DOCX, DOC, RTF
683  sal_uInt16 const nLimit = MSWORD_MAX_STYLES_LIMIT;
684  m_nUsedSlots = std::min(nLimit, m_nUsedSlots);
685 
686  for ( n = 0; n < m_nUsedSlots; n++ )
687  {
688  if (m_aNumRules.find(n) != m_aNumRules.end())
689  OutputStyle(m_aNumRules[n], n);
690  else
691  OutputStyle( m_pFormatA[n], n );
692  }
693 
694  m_rExport.AttrOutput().EndStyles( m_nUsedSlots );
695 
696  m_rExport.m_bStyDef = false;
697 }
698 
699 const SwNumRule* MSWordStyles::GetSwNumRule(sal_uInt16 nId) const
700 {
701  std::map<sal_uInt16, const SwNumRule*>::const_iterator it = m_aNumRules.find(nId);
702  assert(it != m_aNumRules.end());
703  return it->second;
704 }
705 
706 // Fonts
707 
708 wwFont::wwFont(const OUString &rFamilyName, FontPitch ePitch, FontFamily eFamily,
709  rtl_TextEncoding eChrSet)
710  : mbAlt(false), mePitch(ePitch), meFamily(eFamily), meChrSet(eChrSet)
711 {
712  FontMapExport aResult(rFamilyName);
713  msFamilyNm = aResult.msPrimary;
714  msAltNm = aResult.msSecondary;
715  if (!msAltNm.isEmpty() && msAltNm != msFamilyNm &&
716  (msFamilyNm.getLength() + msAltNm.getLength() + 2 <= 65) )
717  {
718  //max size of szFfn in 65 chars
719  mbAlt = true;
720  }
721 
722  memset(maWW8_FFN, 0, sizeof(maWW8_FFN));
723 
724  maWW8_FFN[0] = static_cast<sal_uInt8>( 6 - 1 + 0x22 + ( 2 * ( 1 + msFamilyNm.getLength() ) ));
725  if (mbAlt)
726  maWW8_FFN[0] = static_cast< sal_uInt8 >(maWW8_FFN[0] + 2 * ( 1 + msAltNm.getLength()));
727 
728  sal_uInt8 aB = 0;
729  switch(ePitch)
730  {
731  case PITCH_VARIABLE:
732  aB |= 2; // aF.prg = 2
733  break;
734  case PITCH_FIXED:
735  aB |= 1;
736  break;
737  default: // aF.prg = 0 : DEFAULT_PITCH (windows.h)
738  break;
739  }
740  aB |= 1 << 2; // aF.fTrueType = 1; don't know any better;
741 
742  switch(eFamily)
743  {
744  case FAMILY_ROMAN:
745  aB |= 1 << 4; // aF.ff = 1;
746  break;
747  case FAMILY_SWISS:
748  aB |= 2 << 4; // aF.ff = 2;
749  break;
750  case FAMILY_MODERN:
751  aB |= 3 << 4; // aF.ff = 3;
752  break;
753  case FAMILY_SCRIPT:
754  aB |= 4 << 4; // aF.ff = 4;
755  break;
756  case FAMILY_DECORATIVE:
757  aB |= 5 << 4; // aF.ff = 5;
758  break;
759  default: // aF.ff = 0; FF_DONTCARE (windows.h)
760  break;
761  }
762  maWW8_FFN[1] = aB;
763 
764  ShortToSVBT16( 400, &maWW8_FFN[2] ); // don't know any better
765  // 400 == FW_NORMAL (windows.h)
766 
767  //#i61927# For unicode fonts like Arial Unicode, Word 97+ sets the chs
768  //to SHIFTJIS presumably to capture that it's a multi-byte encoding font
769  //but Word95 doesn't do this, and sets it to 0 (ANSI), so we should do the
770  //same
772 
773  if (mbAlt)
774  maWW8_FFN[5] = static_cast< sal_uInt8 >(msFamilyNm.getLength() + 1);
775 }
776 
777 void wwFont::Write(SvStream *pTableStrm) const
778 {
779  pTableStrm->WriteBytes(maWW8_FFN, sizeof(maWW8_FFN)); // fixed part
780  // from Ver8 following two fields interjected,
781  // we ignore them.
782  //char panose[ 10 ]; // 0x6 PANOSE
783  //char fs[ 24 ]; // 0x10 FONTSIGNATURE
784  SwWW8Writer::FillCount(*pTableStrm, 0x22);
785  SwWW8Writer::WriteString16(*pTableStrm, msFamilyNm, true);
786  if (mbAlt)
787  SwWW8Writer::WriteString16(*pTableStrm, msAltNm, true);
788 }
789 
790 void wwFont::WriteDocx( DocxAttributeOutput* rAttrOutput ) const
791 {
792  // no font embedding, panose id, subsetting, ... implemented
793 
794  if (!msFamilyNm.isEmpty())
795  {
796  rAttrOutput->StartFont( msFamilyNm );
797 
798  if ( mbAlt )
799  rAttrOutput->FontAlternateName( msAltNm );
801  rAttrOutput->FontFamilyType( meFamily );
802  rAttrOutput->FontPitchType( mePitch );
803  rAttrOutput->EmbedFont( msFamilyNm, meFamily, mePitch );
804 
805  rAttrOutput->EndFont();
806  }
807 }
808 
809 void wwFont::WriteRtf( const RtfAttributeOutput* rAttrOutput ) const
810 {
811  rAttrOutput->FontFamilyType( meFamily, *this );
812  rAttrOutput->FontPitchType( mePitch );
813  rAttrOutput->FontCharset(
815  rAttrOutput->StartFont( msFamilyNm );
816  if ( mbAlt )
817  rAttrOutput->FontAlternateName( msAltNm );
818  rAttrOutput->EndFont();
819 }
820 
821 bool operator<(const wwFont &r1, const wwFont &r2)
822 {
823  int nRet = memcmp(r1.maWW8_FFN, r2.maWW8_FFN, sizeof(r1.maWW8_FFN));
824  if (nRet == 0)
825  {
826  nRet = r1.msFamilyNm.compareTo(r2.msFamilyNm);
827  if (nRet == 0)
828  nRet = r1.msAltNm.compareTo(r2.msAltNm);
829  }
830  return nRet < 0;
831 }
832 
833 sal_uInt16 wwFontHelper::GetId(const wwFont &rFont)
834 {
835  sal_uInt16 nRet;
836  std::map<wwFont, sal_uInt16>::const_iterator aIter = maFonts.find(rFont);
837  if (aIter != maFonts.end())
838  nRet = aIter->second;
839  else
840  {
841  nRet = static_cast< sal_uInt16 >(maFonts.size());
842  maFonts[rFont] = nRet;
843  }
844  return nRet;
845 }
846 
848 {
849  GetId(wwFont("Times New Roman", PITCH_VARIABLE,
850  FAMILY_ROMAN, RTL_TEXTENCODING_MS_1252));
851 
853  RTL_TEXTENCODING_SYMBOL));
854 
856  RTL_TEXTENCODING_MS_1252));
857 
858  const SvxFontItem* pFont = GetDfltAttr(RES_CHRATR_FONT);
859 
860  GetId(wwFont(pFont->GetFamilyName(), pFont->GetPitch(),
861  pFont->GetFamily(), pFont->GetCharSet()));
862 
863  const SfxItemPool& rPool = rDoc.GetAttrPool();
864  if (nullptr != (pFont = rPool.GetPoolDefaultItem(RES_CHRATR_FONT)))
865  {
866  GetId(wwFont(pFont->GetFamilyName(), pFont->GetPitch(),
867  pFont->GetFamily(), pFont->GetCharSet()));
868  }
869 
870  if (!bLoadAllFonts)
871  return;
872 
873  const sal_uInt16 aTypes[] = { RES_CHRATR_FONT, RES_CHRATR_CJK_FONT, RES_CHRATR_CTL_FONT, 0 };
874  for (const sal_uInt16* pId = aTypes; *pId; ++pId)
875  {
876  for (const SfxPoolItem* pItem : rPool.GetItemSurrogates(*pId))
877  {
878  pFont = static_cast<const SvxFontItem*>(pItem);
879  GetId(wwFont(pFont->GetFamilyName(), pFont->GetPitch(),
880  pFont->GetFamily(), pFont->GetCharSet()));
881  }
882  }
883 }
884 
885 sal_uInt16 wwFontHelper::GetId(const SvxFontItem& rFont)
886 {
887  wwFont aFont(rFont.GetFamilyName(), rFont.GetPitch(), rFont.GetFamily(),
888  rFont.GetCharSet());
889  return GetId(aFont);
890 }
891 
892 std::vector< const wwFont* > wwFontHelper::AsVector() const
893 {
894  std::vector<const wwFont *> aFontList( maFonts.size() );
895 
896  for ( const auto& aFont : maFonts )
897  aFontList[aFont.second] = &aFont.first;
898 
899  return aFontList;
900 }
901 
902 void wwFontHelper::WriteFontTable(SvStream *pTableStream, WW8Fib& rFib)
903 {
904  rFib.m_fcSttbfffn = pTableStream->Tell();
905  /*
906  * Reserve some space to fill in the len after we know how big it is
907  */
908  SwWW8Writer::WriteLong(*pTableStream, 0);
909 
910  /*
911  * Convert from fast insertion map to linear vector in the order that we
912  * want to write.
913  */
914  std::vector<const wwFont *> aFontList( AsVector() );
915 
916  /*
917  * Write them all to pTableStream
918  */
919  for ( auto aFont : aFontList )
920  aFont->Write(pTableStream);
921 
922  /*
923  * Write the position and len in the FIB
924  */
925  rFib.m_lcbSttbfffn = pTableStream->Tell() - rFib.m_fcSttbfffn;
926  SwWW8Writer::WriteLong( *pTableStream, rFib.m_fcSttbfffn, maFonts.size());
927 }
928 
930 {
931  std::vector<const wwFont *> aFontList( AsVector() );
932 
933  for ( auto aFont : aFontList )
934  aFont->WriteDocx(&rAttrOutput);
935 }
936 
938 {
939  std::vector<const wwFont *> aFontList( AsVector() );
940 
941  for ( auto aFont : aFontList )
942  aFont->WriteRtf(&rAttrOutput);
943 }
944 
946  : nOfs( nOffset )
947 {
948 }
949 
950 void WW8_WrPlc0::Append( sal_uLong nStartCpOrFc )
951 {
952  aPos.push_back( nStartCpOrFc - nOfs );
953 }
954 
956 {
957  for( const auto& rPos : aPos )
958  {
959  rStrm.WriteUInt32(rPos);
960  }
961 }
962 
963 // class MSWordSections : translate PageDescs into Sections
964 // also deals with header and footer
965 
967  : mbDocumentIsProtected( false )
968 {
969  const SwSectionFormat *pFormat = nullptr;
970  rExport.m_pCurrentPageDesc = &rExport.m_pDoc->GetPageDesc( 0 );
971 
972  const SfxPoolItem* pI;
973  const SwNode* pNd = rExport.m_pCurPam->GetContentNode();
974  const SfxItemSet* pSet = pNd ? &static_cast<const SwContentNode*>(pNd)->GetSwAttrSet() : nullptr;
975 
976  sal_uLong nRstLnNum = pSet ? pSet->Get( RES_LINENUMBER ).GetStartValue() : 0;
977 
978  const SwTableNode* pTableNd = rExport.m_pCurPam->GetNode().FindTableNode();
979  const SwSectionNode* pSectNd = nullptr;
980  if ( pTableNd )
981  {
982  pSet = &pTableNd->GetTable().GetFrameFormat()->GetAttrSet();
983  pNd = pTableNd;
984  }
985  else if (pNd && nullptr != ( pSectNd = pNd->FindSectionNode() ))
986  {
987  if ( TOX_HEADER_SECTION == pSectNd->GetSection().GetType() &&
988  pSectNd->StartOfSectionNode()->IsSectionNode() )
989  {
990  pSectNd = pSectNd->StartOfSectionNode()->GetSectionNode();
991  }
992 
993  if ( TOX_CONTENT_SECTION == pSectNd->GetSection().GetType() )
994  {
995  pNd = pSectNd;
996  rExport.m_pCurPam->GetPoint()->nNode = *pNd;
997  }
998 
999  if ( CONTENT_SECTION == pSectNd->GetSection().GetType() )
1000  pFormat = pSectNd->GetSection().GetFormat();
1001  }
1002 
1003  // tdf#118393: FILESAVE: DOCX Export loses header/footer
1004  rExport.m_bFirstTOCNodeWithSection = pSectNd &&
1005  ( TOX_HEADER_SECTION == pSectNd->GetSection().GetType() ||
1006  TOX_CONTENT_SECTION == pSectNd->GetSection().GetType() );
1007 
1008  // Try to get page descriptor of the first node
1009  if ( pSet &&
1010  SfxItemState::SET == pSet->GetItemState( RES_PAGEDESC, true, &pI ) &&
1011  static_cast<const SwFormatPageDesc*>(pI)->GetPageDesc() )
1012  {
1013  AppendSection( *static_cast<const SwFormatPageDesc*>(pI), *pNd, pFormat, nRstLnNum );
1014  }
1015  else
1016  AppendSection( rExport.m_pCurrentPageDesc, pFormat, nRstLnNum, /*bIsFirstParagraph=*/true );
1017 }
1018 
1020  : MSWordSections( rExport )
1021  , m_bHeaderFooterWritten( false )
1022 {
1023  // to be in sync with the AppendSection() call in the MSWordSections
1024  // constructor
1025  aCps.push_back( 0 );
1026 }
1027 
1029 {
1030 }
1031 
1033 {
1034 }
1035 
1037 {
1038  return false; // only relevant for WW8
1039 }
1040 
1042 {
1043  return m_bHeaderFooterWritten;
1044 }
1045 
1046 sal_uInt16 MSWordSections::CurrentNumberOfColumns( const SwDoc &rDoc ) const
1047 {
1048  OSL_ENSURE( !aSects.empty(), "no segment inserted yet" );
1049  if ( aSects.empty() )
1050  return 1;
1051 
1052  return NumberOfColumns( rDoc, aSects.back() );
1053 }
1054 
1055 sal_uInt16 MSWordSections::NumberOfColumns( const SwDoc &rDoc, const WW8_SepInfo& rInfo )
1056 {
1057  const SwPageDesc* pPd = rInfo.pPageDesc;
1058  if ( !pPd )
1059  pPd = &rDoc.GetPageDesc( 0 );
1060 
1061  const SfxItemSet &rSet = pPd->GetMaster().GetAttrSet();
1062  SfxItemSet aSet( *rSet.GetPool(), svl::Items<RES_COL, RES_COL>{} );
1063  aSet.SetParent( &rSet );
1064 
1065  //0xffffffff, what the hell is going on with that!, fixme most terribly
1066  if ( rInfo.pSectionFormat && reinterpret_cast<SwSectionFormat*>(sal_IntPtr(-1)) != rInfo.pSectionFormat )
1067  aSet.Put( rInfo.pSectionFormat->GetFormatAttr( RES_COL ) );
1068 
1069  const SwFormatCol& rCol = aSet.Get( RES_COL );
1070  const SwColumns& rColumns = rCol.GetColumns();
1071  return rColumns.size();
1072 }
1073 
1075 {
1076  if ( !aSects.empty() )
1077  return &aSects.back();
1078 
1079  return nullptr;
1080 }
1081 
1083  const SwSectionFormat* pSectionFormat, sal_uLong nLnNumRestartNo, bool bIsFirstParagraph )
1084 {
1085  if (HeaderFooterWritten()) {
1086  return; // #i117955# prevent new sections in endnotes
1087  }
1088  aSects.emplace_back( pPd, pSectionFormat, nLnNumRestartNo, boost::none, nullptr, bIsFirstParagraph );
1089  NeedsDocumentProtected( aSects.back() );
1090 }
1091 
1092 void WW8_WrPlcSepx::AppendSep( WW8_CP nStartCp, const SwPageDesc* pPd,
1093  const SwSectionFormat* pSectionFormat, sal_uLong nLnNumRestartNo )
1094 {
1095  if (HeaderFooterWritten()) {
1096  return; // #i117955# prevent new sections in endnotes
1097  }
1098  aCps.push_back( nStartCp );
1099  AppendSection( pPd, pSectionFormat, nLnNumRestartNo );
1100 }
1101 
1103  const SwNode& rNd, const SwSectionFormat* pSectionFormat, sal_uLong nLnNumRestartNo )
1104 {
1105  if (HeaderFooterWritten()) {
1106  return; // #i117955# prevent new sections in endnotes
1107  }
1108 
1109  WW8_SepInfo aI( rPD.GetPageDesc(), pSectionFormat, nLnNumRestartNo, rPD.GetNumOffset(), &rNd );
1110 
1111  aSects.push_back( aI );
1112  NeedsDocumentProtected( aI );
1113 }
1114 
1116  const SwNode& rNd, const SwSectionFormat* pSectionFormat, sal_uLong nLnNumRestartNo )
1117 {
1118  if (HeaderFooterWritten()) {
1119  return; // #i117955# prevent new sections in endnotes
1120  }
1121  aCps.push_back( nStartCp );
1122  AppendSection( rPD, rNd, pSectionFormat, nLnNumRestartNo );
1123 }
1124 
1126 {
1127  sal_uInt8 nInfoFlags = 0;
1128  const SwFootnoteInfo& rInfo = rWrt.m_pDoc->GetFootnoteInfo();
1129  if( !rInfo.aErgoSum.isEmpty() ) nInfoFlags |= 0x02;
1130  if( !rInfo.aQuoVadis.isEmpty() ) nInfoFlags |= 0x04;
1131 
1132  sal_uInt8 nEmptyStt = 0;
1133  if( nInfoFlags )
1134  {
1135  pTextPos->Append( nCpStt ); // empty footnote separator
1136 
1137  if( 0x02 & nInfoFlags ) // Footnote continuation separator
1138  {
1139  pTextPos->Append( nCpStt );
1140  rWrt.WriteStringAsPara( rInfo.aErgoSum );
1141  rWrt.WriteStringAsPara( OUString() );
1142  nCpStt = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1143  }
1144  else
1145  pTextPos->Append( nCpStt );
1146 
1147  if( 0x04 & nInfoFlags ) // Footnote continuation notice
1148  {
1149  pTextPos->Append( nCpStt );
1150  rWrt.WriteStringAsPara( rInfo.aQuoVadis );
1151  rWrt.WriteStringAsPara( OUString() );
1152  nCpStt = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1153  }
1154  else
1155  pTextPos->Append( nCpStt );
1156 
1157  nEmptyStt = 3;
1158  }
1159 
1160  while( 6 > nEmptyStt++ )
1161  pTextPos->Append( nCpStt );
1162 
1163  // set the flags at the Dop right away
1164  WW8Dop& rDop = *rWrt.pDop;
1165  // Footnote Info
1166  switch( rInfo.eNum )
1167  {
1168  case FTNNUM_PAGE: rDop.rncFootnote = 2; break;
1169  case FTNNUM_CHAPTER: rDop.rncFootnote = 1; break;
1170  default: rDop.rncFootnote = 0; break;
1171  } // rncFootnote
1173  rDop.nFootnote = rInfo.nFootnoteOffset + 1;
1174  rDop.fpc = rWrt.m_bFootnoteAtTextEnd ? 2 : 1;
1175 
1176  // Endnote Info
1177  rDop.rncEdn = 0; // rncEdn: Don't Restart
1178  const SwEndNoteInfo& rEndInfo = rWrt.m_pDoc->GetEndNoteInfo();
1180  rDop.nEdn = rEndInfo.nFootnoteOffset + 1;
1181  rDop.epc = rWrt.m_bEndAtTextEnd ? 3 : 0;
1182 }
1183 
1184 void MSWordSections::SetHeaderFlag( sal_uInt8& rHeadFootFlags, const SwFormat& rFormat,
1185  sal_uInt8 nFlag )
1186 {
1187  const SfxPoolItem* pItem;
1188  if( SfxItemState::SET == rFormat.GetItemState(RES_HEADER, true, &pItem)
1189  && static_cast<const SwFormatHeader*>(pItem)->IsActive() &&
1190  static_cast<const SwFormatHeader*>(pItem)->GetHeaderFormat() )
1191  rHeadFootFlags |= nFlag;
1192 }
1193 
1194 void MSWordSections::SetFooterFlag( sal_uInt8& rHeadFootFlags, const SwFormat& rFormat,
1195  sal_uInt8 nFlag )
1196 {
1197  const SfxPoolItem* pItem;
1198  if( SfxItemState::SET == rFormat.GetItemState(RES_FOOTER, true, &pItem)
1199  && static_cast<const SwFormatFooter*>(pItem)->IsActive() &&
1200  static_cast<const SwFormatFooter*>(pItem)->GetFooterFormat() )
1201  rHeadFootFlags |= nFlag;
1202 }
1203 
1204 void WW8_WrPlcSepx::OutHeaderFooter( WW8Export& rWrt, bool bHeader,
1205  const SwFormat& rFormat, sal_uLong& rCpPos, sal_uInt8 nHFFlags,
1206  sal_uInt8 nFlag, sal_uInt8 nBreakCode)
1207 {
1208  if ( nFlag & nHFFlags )
1209  {
1210  pTextPos->Append( rCpPos );
1211  rWrt.WriteHeaderFooterText( rFormat, bHeader);
1212  rWrt.WriteStringAsPara( OUString() ); // CR to the end ( otherwise WW complains )
1213  rCpPos = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1214  }
1215  else
1216  {
1217  pTextPos->Append( rCpPos );
1218  if ((bHeader? rWrt.m_bHasHdr : rWrt.m_bHasFtr) && nBreakCode!=0)
1219  {
1220  rWrt.WriteStringAsPara( OUString() ); // Empty paragraph for empty header/footer
1221  rWrt.WriteStringAsPara( OUString() ); // a CR that WW8 needs for end of the stream
1222  rCpPos = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1223  }
1224  }
1225 }
1226 
1228 {
1229  if (rInfo.IsProtected())
1230  mbDocumentIsProtected = true;
1231 }
1232 
1234 {
1235  bool bRet = false;
1236  if (
1237  pSectionFormat &&
1238  (reinterpret_cast<SwSectionFormat*>(sal_IntPtr(-1)) != pSectionFormat)
1239  )
1240  {
1241  const SwSection *pSection = pSectionFormat->GetSection();
1242  if (pSection && pSection->IsProtect())
1243  {
1244  bRet = true;
1245  }
1246  }
1247  return bRet;
1248 }
1249 
1251 {
1252  // 2 values getting set
1253  // Dop.fFacingPages == Header and Footer different
1254  // Dop.fSwapBordersFacingPgs == mirrored borders
1255  sal_uInt16 nEnde = 0;
1256  for( const WW8_SepInfo& rSepInfo : aSects )
1257  {
1258  if( !rSepInfo.pSectionFormat )
1259  {
1260  const SwPageDesc* pPd = rSepInfo.pPageDesc;
1261  if( pPd->GetFollow() && pPd != pPd->GetFollow() &&
1262  pPd->GetFollow()->GetFollow() == pPd->GetFollow() &&
1263  rSepInfo.pPDNd &&
1264  pPd->IsFollowNextPageOfNode( *rSepInfo.pPDNd ) )
1265  // so this is first page and subsequent, so only respect follow
1266  pPd = pPd->GetFollow();
1267 
1268  // left-/right chain of pagedescs ?
1269  else if( !( 1 & nEnde ) &&
1270  pPd->GetFollow() && pPd != pPd->GetFollow() &&
1271  pPd->GetFollow()->GetFollow() == pPd &&
1272  (( UseOnPage::Left == ( UseOnPage::All & pPd->ReadUseOn() ) &&
1273  UseOnPage::Right == ( UseOnPage::All & pPd->GetFollow()->ReadUseOn() )) ||
1274  ( UseOnPage::Right == ( UseOnPage::All & pPd->ReadUseOn() ) &&
1275  UseOnPage::Left == ( UseOnPage::All & pPd->GetFollow()->ReadUseOn() )) ))
1276  {
1277  rWrt.pDop->fFacingPages = rWrt.pDop->fMirrorMargins = true;
1278  nEnde |= 1;
1279  }
1280 
1281  if( !( 1 & nEnde ) &&
1282  ( !pPd->IsHeaderShared() || !pPd->IsFooterShared() ))
1283  {
1284  rWrt.pDop->fFacingPages = true;
1285  nEnde |= 1;
1286  }
1287  if( !( 2 & nEnde ) &&
1289  {
1290  rWrt.pDop->fSwapBordersFacingPgs =
1291  rWrt.pDop->fMirrorMargins = true;
1292  nEnde |= 2;
1293  }
1294 
1295  if( 3 == nEnde )
1296  break; // We do not need to go any further
1297  }
1298  }
1299 }
1300 
1302 {
1303  const SfxPoolItem* pItem;
1304  return SfxItemState::SET == rFormat.GetItemState(RES_BOX, true, &pItem) &&
1305  ( static_cast<const SvxBoxItem*>(pItem)->GetTop() ||
1306  static_cast<const SvxBoxItem*>(pItem)->GetBottom() ||
1307  static_cast<const SvxBoxItem*>(pItem)->GetLeft() ||
1308  static_cast<const SvxBoxItem*>(pItem)->GetRight() );
1309 }
1310 
1312 {
1313  m_rWW8Export.pO->clear();
1314 }
1315 
1317 {
1320  switch( rInfo.eNum )
1321  {
1322  case FTNNUM_PAGE: m_rWW8Export.pO->push_back( sal_uInt8/*rncRstPage*/ (2) ); break;
1323  case FTNNUM_CHAPTER: m_rWW8Export.pO->push_back( sal_uInt8/*rncRstSect*/ (1) ); break;
1324  default: m_rWW8Export.pO->push_back( sal_uInt8/*rncCont*/ (0) ); break;
1325  }
1326 }
1327 
1329 {
1330  //If the document is to be exported as protected, then if a segment
1331  //is not protected, set the unlocked flag
1332  if ( m_rWW8Export.pSepx->DocumentIsProtected() && !bProtected )
1333  {
1335  m_rWW8Export.pO->push_back( 1 );
1336  }
1337 }
1338 
1340 {
1341  // sprmSNLnnMod - activate Line Numbering and define Modulo
1344 
1345  // sprmSDxaLnn - xPosition of Line Number
1348 
1349  // sprmSLnc - restart number: 0 per page, 1 per section, 2 never restart
1350  if ( nRestartNo || !rLnNumInfo.IsRestartEachPage() )
1351  {
1353  m_rWW8Export.pO->push_back( nRestartNo ? 1 : 2 );
1354  }
1355 
1356  // sprmSLnnMin - Restart the Line Number with given value
1357  if ( nRestartNo )
1358  {
1360  SwWW8Writer::InsUInt16( *m_rWW8Export.pO, static_cast<sal_uInt16>(nRestartNo) - 1 );
1361  }
1362 }
1363 
1365 {
1366  // sprmSFTitlePage
1368  m_rWW8Export.pO->push_back( 1 );
1369 }
1370 
1371 void WW8AttributeOutput::SectionPageBorders( const SwFrameFormat* pPdFormat, const SwFrameFormat* pPdFirstPgFormat )
1372 {
1373  // write border of page
1374  sal_uInt16 nPgBorder = MSWordSections::HasBorderItem( *pPdFormat ) ? 0 : USHRT_MAX;
1375  if ( pPdFormat != pPdFirstPgFormat )
1376  {
1377  if ( MSWordSections::HasBorderItem( *pPdFirstPgFormat ) )
1378  {
1379  if ( USHRT_MAX == nPgBorder )
1380  {
1381  nPgBorder = 1;
1382  // only the first page outlined -> Get the BoxItem from the correct format
1383  m_rWW8Export.m_pISet = &pPdFirstPgFormat->GetAttrSet();
1384  OutputItem( pPdFirstPgFormat->GetFormatAttr( RES_BOX ) );
1385  }
1386  }
1387  else if ( !nPgBorder )
1388  nPgBorder = 2;
1389  }
1390 
1391  // [MS-DOC] 2.9.255 SPgbPropOperand; 2.9.185 PgbOffsetFrom
1392  if (m_bFromEdge)
1393  nPgBorder |= (1<<5);
1394 
1395  if ( USHRT_MAX != nPgBorder )
1396  {
1397  // write the Flag and Border Attribute
1399  SwWW8Writer::InsUInt16( *m_rWW8Export.pO, nPgBorder );
1400  }
1401 }
1402 
1404 {
1406  m_rWW8Export.pO->push_back( bBiDi? 1: 0 );
1407 }
1408 
1409 void WW8AttributeOutput::SectionPageNumbering( sal_uInt16 nNumType, const ::boost::optional<sal_uInt16>& oPageRestartNumber )
1410 {
1411  // sprmSNfcPgn
1412  sal_uInt8 nb = WW8Export::GetNumId( nNumType );
1414  m_rWW8Export.pO->push_back( nb );
1415 
1416  if ( oPageRestartNumber )
1417  {
1418  // sprmSFPgnRestart
1420  m_rWW8Export.pO->push_back( 1 );
1421 
1422  // sprmSPgnStart
1424  SwWW8Writer::InsUInt16( *m_rWW8Export.pO, oPageRestartNumber.get() );
1425  }
1426 }
1427 
1429 {
1430  if ( 2 != nBreakCode ) // new page is the default
1431  {
1433  m_rWW8Export.pO->push_back( nBreakCode );
1434  }
1435 }
1436 
1438 {
1439  if ( !pA )
1440  return;
1441 
1442  if ( !pO->empty() ) // are there attributes ?
1443  {
1444  pA->m_nLen = pO->size();
1445  pA->m_pData.reset(new sal_uInt8 [pO->size()]);
1446  // store for later
1447  memcpy( pA->m_pData.get(), pO->data(), pO->size() );
1448  pO->clear(); // clear HdFt-Text
1449  }
1450  else // no attributes there
1451  {
1452  pA->m_pData.reset();
1453  pA->m_nLen = 0;
1454  }
1455 }
1456 
1457 void WW8AttributeOutput::TextVerticalAdjustment( const drawing::TextVerticalAdjust nVA )
1458 {
1459  if ( drawing::TextVerticalAdjust_TOP != nVA ) // top alignment is the default
1460  {
1461  sal_uInt8 nMSVA = 0;
1462  switch( nVA )
1463  {
1464  case drawing::TextVerticalAdjust_CENTER:
1465  nMSVA = 1;
1466  break;
1467  case drawing::TextVerticalAdjust_BOTTOM: //Writer = 2, Word = 3
1468  nMSVA = 3;
1469  break;
1470  case drawing::TextVerticalAdjust_BLOCK: //Writer = 3, Word = 2
1471  nMSVA = 2;
1472  break;
1473  default:
1474  break;
1475  }
1477  m_rWW8Export.pO->push_back( nMSVA );
1478  }
1479 }
1480 
1482  const SwFrameFormat& rFormat, const SwFrameFormat& rLeftFormat, const SwFrameFormat& rFirstPageFormat, sal_uInt8 nBreakCode )
1483 {
1484  sal_uLong nCpPos = Fc2Cp( Strm().Tell() );
1485 
1487  if ( !(nHeadFootFlags & WW8_HEADER_EVEN) && pDop->fFacingPages )
1488  pSepx->OutHeaderFooter( *this, true, rFormat, nCpPos, nHeadFootFlags, WW8_HEADER_ODD, nBreakCode );
1489  else
1490  pSepx->OutHeaderFooter( *this, true, rLeftFormat, nCpPos, nHeadFootFlags, WW8_HEADER_EVEN, nBreakCode );
1492  pSepx->OutHeaderFooter( *this, true, rFormat, nCpPos, nHeadFootFlags, WW8_HEADER_ODD, nBreakCode );
1493 
1495  if ( !(nHeadFootFlags & WW8_FOOTER_EVEN) && pDop->fFacingPages )
1496  pSepx->OutHeaderFooter( *this, false, rFormat, nCpPos, nHeadFootFlags, WW8_FOOTER_ODD, nBreakCode );
1497  else
1498  pSepx->OutHeaderFooter( *this, false, rLeftFormat, nCpPos, nHeadFootFlags, WW8_FOOTER_EVEN, nBreakCode );
1500  pSepx->OutHeaderFooter( *this, false, rFormat, nCpPos, nHeadFootFlags, WW8_FOOTER_ODD, nBreakCode );
1501 
1502  //#i24344# Drawing objects cannot be directly shared between main hd/ft
1503  //and title hd/ft so we need to differentiate them
1505  pSepx->OutHeaderFooter( *this, true, rFirstPageFormat, nCpPos, nHeadFootFlags, WW8_HEADER_FIRST, nBreakCode );
1506  pSepx->OutHeaderFooter( *this, false, rFirstPageFormat, nCpPos, nHeadFootFlags, WW8_FOOTER_FIRST, nBreakCode );
1507 }
1508 
1510 {
1511  const SwPageDesc* pPd = rSepInfo.pPageDesc;
1512 
1513  if ( rSepInfo.pSectionFormat && !pPd )
1514  pPd = &m_pDoc->GetPageDesc( 0 );
1515 
1516  m_pCurrentPageDesc = pPd;
1517 
1518  if ( !pPd )
1519  return;
1520 
1521  bool bOldPg = m_bOutPageDescs;
1522  m_bOutPageDescs = true;
1523 
1525 
1527 
1528  // forms
1530 
1531  // line numbers
1532  const SwLineNumberInfo& rLnNumInfo = m_pDoc->GetLineNumberInfo();
1533  if ( rLnNumInfo.IsPaintLineNumbers() )
1534  AttrOutput().SectionLineNumbering( rSepInfo.nLnNumRestartNo, rLnNumInfo );
1535 
1536  /* sprmSBkc, break code: 0 No break, 1 New column
1537  2 New page, 3 Even page, 4 Odd page
1538  */
1539  sal_uInt8 nBreakCode = 2; // default start new page
1540  bool bOutPgDscSet = true, bLeftRightPgChain = false, bOutputStyleItemSet = false;
1541  bool bEnsureHeaderFooterWritten = rSepInfo.pSectionFormat && rSepInfo.bIsFirstParagraph;
1542  const SwFrameFormat* pPdFormat = &pPd->GetMaster();
1543  if ( rSepInfo.pSectionFormat )
1544  {
1545  // if pSectionFormat is set, then there is a SectionNode
1546  // valid pointer -> start Section ,
1547  // 0xfff -> Section terminated
1548  nBreakCode = 0; // consecutive section
1549 
1550  if ( rSepInfo.pPDNd && rSepInfo.pPDNd->IsContentNode() )
1551  {
1552  if ( !NoPageBreakSection( &rSepInfo.pPDNd->GetContentNode()->GetSwAttrSet() ) )
1553  {
1554  nBreakCode = 2;
1555  }
1556  }
1557 
1558  if ( reinterpret_cast<SwSectionFormat*>(sal_IntPtr(-1)) == rSepInfo.pSectionFormat )
1559  bEnsureHeaderFooterWritten |= !rSepInfo.pPDNd && GetExportFormat() != ExportFormat::RTF;
1560  else
1561  {
1562  if ( nBreakCode == 0 )
1563  bOutPgDscSet = false;
1564 
1565  // produce Itemset, which inherits PgDesk-Attr-Set:
1566  // as child also the parent is searched if 'deep'-OutputItemSet
1567  const SfxItemSet* pPdSet = &pPdFormat->GetAttrSet();
1568  SfxItemSet aSet( *pPdSet->GetPool(), pPdSet->GetRanges() );
1569  aSet.SetParent( pPdSet );
1570 
1571  // at the child ONLY change column structure according to Sect-Attr.
1572 
1573  const SvxLRSpaceItem &rSectionLR =
1574  ItemGet<SvxLRSpaceItem>( *(rSepInfo.pSectionFormat), RES_LR_SPACE );
1575  const SvxLRSpaceItem &rPageLR =
1576  ItemGet<SvxLRSpaceItem>( *pPdFormat, RES_LR_SPACE );
1577 
1578  SvxLRSpaceItem aResultLR( rPageLR.GetLeft() +
1579  rSectionLR.GetLeft(), rPageLR.GetRight() +
1580  rSectionLR.GetRight(), 0, 0, RES_LR_SPACE );
1581  //i120133: The Section width should consider section indent value.
1582  if (rSectionLR.GetLeft()+rSectionLR.GetRight()!=0)
1583  {
1584  const SwFormatCol& rCol = dynamic_cast<const SwFormatCol&>(rSepInfo.pSectionFormat->GetFormatAttr(RES_COL));
1585  SwFormatCol aCol(rCol);
1586  aCol.SetAdjustValue(rSectionLR.GetLeft()+rSectionLR.GetRight());
1587  aSet.Put(aCol);
1588  }
1589  else
1590  aSet.Put(rSepInfo.pSectionFormat->GetFormatAttr(RES_COL));
1591 
1592  aSet.Put( aResultLR );
1593 
1594  // and write into the WW-File
1595  const SfxItemSet* pOldI = m_pISet;
1596  m_pISet = &aSet;
1597 
1598  // Switch off test on default item values, if page description
1599  // set (value of <bOutPgDscSet>) isn't written.
1600  AttrOutput().OutputStyleItemSet( aSet, bOutPgDscSet );
1601  bOutputStyleItemSet = true;
1602 
1603  //Cannot export as normal page framedir, as continuous sections
1604  //cannot contain any grid settings like proper sections
1605  AttrOutput().SectionBiDi( SvxFrameDirection::Horizontal_RL_TB == TrueFrameDirection( *rSepInfo.pSectionFormat ) );
1606 
1607  m_pISet = pOldI;
1608  }
1609  }
1610 
1611  // Libreoffice 4.0 introduces support for page styles (SwPageDesc) with
1612  // a different header/footer for the first page. The same effect can be
1613  // achieved by chaining two page styles together (SwPageDesc::GetFollow)
1614  // which are identical except for header/footer.
1615  // The latter method was previously used by the doc/docx import filter.
1616  // In both of these cases, we emit a single Word section with different
1617  // first page header/footer.
1618  const SwFrameFormat* pPdFirstPgFormat = &pPd->GetFirstMaster();
1619  bool titlePage = !pPd->IsFirstShared();
1620  if ( bOutPgDscSet )
1621  {
1622  // if a Follow is set and it does not point to itself,
1623  // then there is a page chain.
1624  // If this emulates a "first page", we can detect it here and write
1625  // it as title page.
1626  // With Left/Right changes it's different - we have to detect where
1627  // the change of pages is, but here it's too late for that!
1628  // tdf#101814 if there is already a explicit first-page, no point
1629  // in checking heuristics here.
1630  if ( !titlePage && pPd->GetFollow() && pPd != pPd->GetFollow() &&
1631  pPd->GetFollow()->GetFollow() == pPd->GetFollow() &&
1632  pPd->IsHeaderShared() && pPd->IsFooterShared() &&
1633  ( !rSepInfo.pPDNd || pPd->IsFollowNextPageOfNode( *rSepInfo.pPDNd ) ) )
1634  {
1635  const SwPageDesc *pFollow = pPd->GetFollow();
1636  const SwFrameFormat& rFollowFormat = pFollow->GetMaster();
1637  if (sw::util::IsPlausableSingleWordSection(*pPdFirstPgFormat, rFollowFormat))
1638  {
1639  if (rSepInfo.pPDNd)
1640  pPdFirstPgFormat = pPd->GetPageFormatOfNode( *rSepInfo.pPDNd );
1641  else
1642  pPdFirstPgFormat = &pPd->GetMaster();
1643 
1644  m_pCurrentPageDesc = pPd = pFollow;
1645  pPdFormat = &rFollowFormat;
1646 
1647  // has different headers/footers for the title page
1648  titlePage = true;
1649  }
1650  }
1651 
1652  if( titlePage )
1654 
1655  const SfxItemSet* pOldI = m_pISet;
1656 
1657  const SfxPoolItem* pItem;
1658  if ( titlePage && SfxItemState::SET ==
1659  pPdFirstPgFormat->GetItemState( RES_PAPER_BIN, true, &pItem ) )
1660  {
1661  m_pISet = &pPdFirstPgFormat->GetAttrSet();
1662  m_bOutFirstPage = true;
1663  AttrOutput().OutputItem( *pItem );
1664  m_bOutFirstPage = false;
1665  }
1666 
1667  // left-/right chain of pagedescs ?
1668  if ( pPd->GetFollow() && pPd != pPd->GetFollow() &&
1669  pPd->GetFollow()->GetFollow() == pPd &&
1670  (( UseOnPage::Left == ( UseOnPage::All & pPd->ReadUseOn() ) &&
1671  UseOnPage::Right == ( UseOnPage::All & pPd->GetFollow()->ReadUseOn() )) ||
1672  ( UseOnPage::Right == ( UseOnPage::All & pPd->ReadUseOn() ) &&
1673  UseOnPage::Left == ( UseOnPage::All & pPd->GetFollow()->ReadUseOn() )) ))
1674  {
1675  bLeftRightPgChain = true;
1676 
1677  // which is the reference point? (left or right?)
1678  // assume it is on the right side!
1679  if ( UseOnPage::Left == ( UseOnPage::All & pPd->ReadUseOn() ) )
1680  {
1681  nBreakCode = 3;
1682  pPd = pPd->GetFollow();
1683  pPdFormat = &pPd->GetMaster();
1684  }
1685  else
1686  nBreakCode = 4;
1687  }
1688 
1689  m_pISet = &pPdFormat->GetAttrSet();
1690  if (!bOutputStyleItemSet)
1691  AttrOutput().OutputStyleItemSet( pPdFormat->GetAttrSet(), false );
1692  AttrOutput().SectionPageBorders( pPdFormat, pPdFirstPgFormat );
1693  m_pISet = pOldI;
1694 
1695  // then the rest of the settings from PageDesc
1697 
1698  // will it be only left or only right pages?
1699  if ( 2 == nBreakCode )
1700  {
1701  if ( UseOnPage::Left == ( UseOnPage::All & pPd->ReadUseOn() ) )
1702  nBreakCode = 3;
1703  else if ( UseOnPage::Right == ( UseOnPage::All & pPd->ReadUseOn() ) )
1704  nBreakCode = 4;
1705  }
1706  }
1707 
1708  AttrOutput().SectionType( nBreakCode );
1709 
1710  if( rSepInfo.pPageDesc ) {
1712  }
1713 
1714  // Header or Footer
1715  sal_uInt8 nHeadFootFlags = 0;
1716 
1717  const SwFrameFormat* pPdLeftFormat = bLeftRightPgChain
1718  ? &pPd->GetFollow()->GetMaster()
1719  : &pPd->GetLeft();
1720 
1721  // Ensure that headers are written if section is first paragraph
1722  if ( nBreakCode != 0 || bEnsureHeaderFooterWritten )
1723  {
1724  if ( titlePage )
1725  {
1726  // there is a First Page:
1727  MSWordSections::SetHeaderFlag( nHeadFootFlags, *pPdFirstPgFormat, WW8_HEADER_FIRST );
1728  MSWordSections::SetFooterFlag( nHeadFootFlags, *pPdFirstPgFormat, WW8_FOOTER_FIRST );
1729  }
1730  MSWordSections::SetHeaderFlag( nHeadFootFlags, *pPdFormat, WW8_HEADER_ODD );
1731  MSWordSections::SetFooterFlag( nHeadFootFlags, *pPdFormat, WW8_FOOTER_ODD );
1732 
1733  if ( !pPd->IsHeaderShared() || bLeftRightPgChain )
1734  MSWordSections::SetHeaderFlag( nHeadFootFlags, *pPdLeftFormat, WW8_HEADER_EVEN );
1735 
1736  if ( !pPd->IsFooterShared() || bLeftRightPgChain )
1737  MSWordSections::SetFooterFlag( nHeadFootFlags, *pPdLeftFormat, WW8_FOOTER_EVEN );
1738  }
1739 
1740  // binary filters only
1741  SetupSectionPositions( pA );
1742 
1743  /*
1744  !!!!!!!!!!!
1745  // borders at header and footer texts would be done like this:
1746  // This should use something like pOut,
1747  // which is repeated with every special text line.
1748  const SwFrameFormat* pFFormat = rFt.GetFooterFormat();
1749  const SvxBoxItem& rBox = pFFormat->GetBox(false);
1750  OutWW8_SwFormatBox1( m_rWW8Export.pOut, rBox, false);
1751  !!!!!!!!!!!
1752  You can turn this into paragraph attributes, which are then observed in each paragraph.
1753  Applies to background / border.
1754  !!!!!!!!!!!
1755  */
1756 
1757  const SwTextNode *pOldPageRoot = GetHdFtPageRoot();
1758  SetHdFtPageRoot( rSepInfo.pPDNd ? rSepInfo.pPDNd->GetTextNode() : nullptr );
1759 
1760  WriteHeadersFooters( nHeadFootFlags, *pPdFormat, *pPdLeftFormat, *pPdFirstPgFormat, nBreakCode );
1761 
1762  SetHdFtPageRoot( pOldPageRoot );
1763 
1764  AttrOutput().EndSection();
1765 
1766  // outside of the section properties again
1767  m_bOutPageDescs = bOldPg;
1768 }
1769 
1771 {
1772  sal_uLong nCpStart = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1773 
1774  OSL_ENSURE( !pTextPos, "who set the pointer?" );
1775  pTextPos.reset( new WW8_WrPlc0( nCpStart ) );
1776 
1777  WriteFootnoteEndText( rWrt, nCpStart );
1778  CheckForFacinPg( rWrt );
1779 
1780  unsigned int nOldIndex = rWrt.GetHdFtIndex();
1781  rWrt.SetHdFtIndex( 0 );
1782 
1783  for (WW8_SepInfo & rSepInfo : aSects)
1784  {
1785  std::shared_ptr<WW8_PdAttrDesc> const pAttrDesc(new WW8_PdAttrDesc);
1786  m_SectionAttributes.push_back(pAttrDesc);
1787 
1788  rWrt.SectionProperties( rSepInfo, pAttrDesc.get() );
1789 
1790  // FIXME: this writes the section properties, but not of all sections;
1791  // it's possible that later in the document (e.g. in endnotes) sections
1792  // are added, but they won't have their properties written here!
1793  m_bHeaderFooterWritten = true;
1794  }
1795  rWrt.SetHdFtIndex( nOldIndex ); //0
1796 
1797  if ( pTextPos->Count() )
1798  {
1799  // HdFt available?
1800  sal_uLong nCpEnd = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1801  pTextPos->Append( nCpEnd ); // End of last Header/Footer for PlcfHdd
1802 
1803  if ( nCpEnd > nCpStart )
1804  {
1805  ++nCpEnd;
1806  pTextPos->Append( nCpEnd + 1 ); // End of last Header/Footer for PlcfHdd
1807 
1808  rWrt.WriteStringAsPara( OUString() ); // CR to the end ( otherwise WW complains )
1809  }
1810  rWrt.m_pFieldHdFt->Finish( nCpEnd, rWrt.pFib->m_ccpText + rWrt.pFib->m_ccpFootnote );
1811  rWrt.pFib->m_ccpHdr = nCpEnd - nCpStart;
1812  }
1813  else
1814  {
1815  pTextPos.reset();
1816  }
1817 
1818  return rWrt.pFib->m_ccpHdr != 0;
1819 }
1820 
1822 {
1823  OSL_ENSURE(m_SectionAttributes.size() == static_cast<size_t>(aSects.size())
1824  , "WriteSepx(): arrays out of sync!");
1825  for (const auto & rSectionAttribute : m_SectionAttributes) // all sections
1826  {
1827  WW8_PdAttrDesc *const pA = rSectionAttribute.get();
1828  if (pA->m_nLen && pA->m_pData != nullptr)
1829  {
1830  pA->m_nSepxFcPos = rStrm.Tell();
1831  rStrm.WriteUInt16(pA->m_nLen);
1832  rStrm.WriteBytes(pA->m_pData.get(), pA->m_nLen);
1833  }
1834  }
1835 }
1836 
1838 {
1839  OSL_ENSURE(m_SectionAttributes.size() == static_cast<size_t>(aSects.size())
1840  , "WritePlcSed(): arrays out of sync!");
1841  OSL_ENSURE( aCps.size() == aSects.size() + 1, "WrPlcSepx: DeSync" );
1842  sal_uLong nFcStart = rWrt.pTableStrm->Tell();
1843 
1844  for( decltype(aSects)::size_type i = 0; i <= aSects.size(); i++ )
1845  {
1846  sal_uInt32 nP = aCps[i];
1847  rWrt.pTableStrm->WriteUInt32(nP);
1848  }
1849 
1850  static WW8_SED aSed = {{4, 0},{0, 0, 0, 0},{0, 0},{0xff, 0xff, 0xff, 0xff}};
1851 
1852  for (const auto & rSectionAttribute : m_SectionAttributes)
1853  {
1854  // Sepx-Pos
1855  UInt32ToSVBT32( rSectionAttribute->m_nSepxFcPos, aSed.fcSepx );
1856  rWrt.pTableStrm->WriteBytes(&aSed, sizeof(aSed));
1857  }
1858  rWrt.pFib->m_fcPlcfsed = nFcStart;
1859  rWrt.pFib->m_lcbPlcfsed = rWrt.pTableStrm->Tell() - nFcStart;
1860 }
1861 
1863 {
1864  // Don't write out the PlcfHdd if ccpHdd is 0: it's a validation failure case.
1865  if( rWrt.pFib->m_ccpHdr != 0 && pTextPos && pTextPos->Count() )
1866  {
1867  rWrt.pFib->m_fcPlcfhdd = rWrt.pTableStrm->Tell();
1868  pTextPos->Write( *rWrt.pTableStrm ); // Plc0
1869  rWrt.pFib->m_lcbPlcfhdd = rWrt.pTableStrm->Tell() -
1870  rWrt.pFib->m_fcPlcfhdd;
1871  }
1872 }
1873 
1874 void MSWordExportBase::WriteHeaderFooterText( const SwFormat& rFormat, bool bHeader )
1875 {
1876  const SwFormatContent *pContent;
1877  if ( bHeader )
1878  {
1879  m_bHasHdr = true;
1880  const SwFormatHeader& rHd = rFormat.GetHeader();
1881  OSL_ENSURE( rHd.GetHeaderFormat(), "Header text is not here" );
1882  pContent = &rHd.GetHeaderFormat()->GetContent();
1883  }
1884  else
1885  {
1886  m_bHasFtr = true;
1887  const SwFormatFooter& rFt = rFormat.GetFooter();
1888  OSL_ENSURE( rFt.GetFooterFormat(), "Footer text is not here" );
1889  pContent = &rFt.GetFooterFormat()->GetContent();
1890  }
1891 
1892  const SwNodeIndex* pSttIdx = pContent->GetContentIdx();
1893 
1894  if ( pSttIdx )
1895  {
1896  SwNodeIndex aIdx( *pSttIdx, 1 ),
1897  aEnd( *pSttIdx->GetNode().EndOfSectionNode() );
1898  sal_uLong nStart = aIdx.GetIndex();
1899  sal_uLong nEnd = aEnd.GetIndex();
1900 
1901  // range, i.e. valid node
1902  if ( nStart < nEnd )
1903  {
1904  bool bOldKF = m_bOutKF;
1905  m_bOutKF = true;
1906  WriteSpecialText( nStart, nEnd, TXT_HDFT );
1907  m_bOutKF = bOldKF;
1908  }
1909  else
1910  pSttIdx = nullptr;
1911  }
1912 
1913  if ( !pSttIdx )
1914  {
1915  // there is no Header/Footer, but a CR is still necessary
1916  OSL_ENSURE( pSttIdx, "Header/Footer text is not really present" );
1918  }
1919 }
1920 
1921 // class WW8_WrPlcFootnoteEdn : Collect the Footnotes and Endnotes and output their text
1922 // and Plcs at the end of the document.
1923 // WW8_WrPlcFootnoteEdn is the class for Footnotes and Endnotes
1924 
1926 {
1927 }
1928 
1930 {
1931 }
1932 
1934 {
1935  aCps.push_back( nCp );
1936  aContent.push_back( &rFootnote );
1937 }
1938 
1939 WW8_Annotation::WW8_Annotation(const SwPostItField* pPostIt, WW8_CP nRangeStart, WW8_CP nRangeEnd)
1940  :
1942  m_nRangeStart(nRangeStart),
1943  m_nRangeEnd(nRangeEnd)
1944 {
1945  mpRichText = pPostIt->GetTextObject();
1946  if (!mpRichText)
1947  msSimpleText = pPostIt->GetText();
1948  msOwner = pPostIt->GetPar1();
1949  m_sInitials = pPostIt->GetInitials();
1950  maDateTime = DateTime(pPostIt->GetDate(), pPostIt->GetTime());
1951 }
1952 
1954  :
1955  mpRichText(nullptr),
1957  m_nRangeStart(0),
1958  m_nRangeEnd(0)
1959 {
1960  msSimpleText = pRedline->GetComment();
1961  msOwner = SW_MOD()->GetRedlineAuthor(pRedline->GetAuthor());
1962  maDateTime = pRedline->GetTimeStamp();
1963 }
1964 
1966 {
1967  if (m_nRangeStart != m_nRangeEnd)
1968  {
1969  return true;
1970  }
1971 
1972  return !m_bIgnoreEmpty;
1973 }
1974 
1975 void WW8_WrPlcAnnotations::AddRangeStartPosition(const OUString& rName, WW8_CP nStartCp,
1976  bool bIgnoreEmpty)
1977 {
1978  m_aRangeStartPositions[rName] = std::make_pair(nStartCp, bIgnoreEmpty);
1979 }
1980 
1982 {
1983  aCps.push_back( nCp );
1984  WW8_Annotation* p;
1985  if( m_aRangeStartPositions.find(pPostIt->GetName()) != m_aRangeStartPositions.end() )
1986  {
1987  auto [nStartCp, bIgnoreEmpty] = m_aRangeStartPositions[pPostIt->GetName()];
1988  p = new WW8_Annotation(pPostIt, nStartCp, nCp);
1989  p->m_bIgnoreEmpty = bIgnoreEmpty;
1990  m_aRangeStartPositions.erase(pPostIt->GetName());
1991  }
1992  else
1993  {
1994  p = new WW8_Annotation(pPostIt, nCp, nCp);
1995  }
1996  aContent.push_back( p );
1997 }
1998 
2000 {
2001  maProcessedRedlines.insert(pRedline);
2002  aCps.push_back( nCp );
2003  WW8_Annotation* p = new WW8_Annotation(pRedline);
2004  aContent.push_back( p );
2005 }
2006 
2008 {
2009  return maProcessedRedlines.find(pRedline) == maProcessedRedlines.end();
2010 }
2011 
2013 {
2014  for(const void * p : aContent)
2015  delete static_cast<WW8_Annotation const *>(p);
2016 }
2017 
2019  WW8_CP& rCount )
2020 {
2021  sal_uInt16 nLen = aContent.size();
2022  if ( !nLen )
2023  return false;
2024 
2025  sal_uLong nCpStart = rWrt.Fc2Cp( rWrt.Strm().Tell() );
2026  pTextPos.reset( new WW8_WrPlc0( nCpStart ) );
2027  sal_uInt16 i;
2028 
2029  switch ( nTTyp )
2030  {
2031  case TXT_ATN:
2032  for ( i = 0; i < nLen; i++ )
2033  {
2034  // beginning for PlcfAtnText
2035  pTextPos->Append( rWrt.Fc2Cp( rWrt.Strm().Tell() ));
2036 
2037  rWrt.WritePostItBegin();
2038  const WW8_Annotation& rAtn = *static_cast<const WW8_Annotation*>(aContent[i]);
2039  if (rAtn.mpRichText)
2040  rWrt.WriteOutliner(*rAtn.mpRichText, nTTyp);
2041  else
2042  {
2043  OUString sText(rAtn.msSimpleText);
2044  rWrt.WriteStringAsPara(sText.replace(0x0A, 0x0B));
2045  }
2046  }
2047  break;
2048 
2049  case TXT_TXTBOX:
2050  case TXT_HFTXTBOX:
2051  for ( i = 0; i < nLen; i++ )
2052  {
2053  // textbox content
2054  WW8_CP nCP = rWrt.Fc2Cp( rWrt.Strm().Tell() );
2055  aCps.insert( aCps.begin()+i, nCP );
2056  pTextPos->Append( nCP );
2057 
2058  if( aContent[ i ] != nullptr )
2059  {
2060  // is it a writer or sdr - textbox?
2061  const SdrObject& rObj = *static_cast<SdrObject const *>(aContent[ i ]);
2062  if (rObj.GetObjInventor() == SdrInventor::FmForm)
2063  {
2064  sal_uInt8 nOldTyp = rWrt.m_nTextTyp;
2065  rWrt.m_nTextTyp = nTTyp;
2066  rWrt.GetOCXExp().ExportControl(rWrt, dynamic_cast<const SdrUnoObj&>(rObj));
2067  rWrt.m_nTextTyp = nOldTyp;
2068  }
2069  else if( dynamic_cast<const SdrTextObj*>( &rObj) != nullptr )
2070  rWrt.WriteSdrTextObj(dynamic_cast<const SdrTextObj&>(rObj), nTTyp);
2071  else
2072  {
2073  const SwFrameFormat* pFormat = ::FindFrameFormat( &rObj );
2074  OSL_ENSURE( pFormat, "where is the format?" );
2075 
2076  const SwNodeIndex* pNdIdx = pFormat->GetContent().GetContentIdx();
2077  OSL_ENSURE( pNdIdx, "where is the StartNode of the Textbox?" );
2078  rWrt.WriteSpecialText( pNdIdx->GetIndex() + 1,
2079  pNdIdx->GetNode().EndOfSectionIndex(),
2080  nTTyp );
2081  {
2082  SwNodeIndex aContentIdx = *pNdIdx;
2083  ++aContentIdx;
2084  if ( aContentIdx.GetNode().IsTableNode() )
2085  {
2086  bool bContainsOnlyTables = true;
2087  do {
2088  aContentIdx = *(aContentIdx.GetNode().EndOfSectionNode());
2089  ++aContentIdx;
2090  if ( !aContentIdx.GetNode().IsTableNode() &&
2091  aContentIdx.GetIndex() != pNdIdx->GetNode().EndOfSectionIndex() )
2092  {
2093  bContainsOnlyTables = false;
2094  }
2095  } while ( aContentIdx.GetNode().IsTableNode() );
2096  if ( bContainsOnlyTables )
2097  {
2098  // Additional paragraph containing a space to
2099  // assure that by WW created RTF from written WW8
2100  // does not crash WW.
2101  rWrt.WriteStringAsPara( " " );
2102  }
2103  }
2104  }
2105  }
2106  }
2107  else if (i < aSpareFormats.size() && aSpareFormats[i])
2108  {
2109  const SwFrameFormat& rFormat = *aSpareFormats[i];
2110  const SwNodeIndex* pNdIdx = rFormat.GetContent().GetContentIdx();
2111  rWrt.WriteSpecialText( pNdIdx->GetIndex() + 1,
2112  pNdIdx->GetNode().EndOfSectionIndex(), nTTyp );
2113  }
2114 
2115  // CR at end of one textbox text ( otherwise WW gpft :-( )
2116  rWrt.WriteStringAsPara( OUString() );
2117  }
2118  break;
2119 
2120  case TXT_EDN:
2121  case TXT_FTN:
2122  for ( i = 0; i < nLen; i++ )
2123  {
2124  // beginning for PlcfFootnoteText/PlcfEdnText
2125  pTextPos->Append( rWrt.Fc2Cp( rWrt.Strm().Tell() ));
2126 
2127  // Note content
2128  const SwFormatFootnote* pFootnote = static_cast<SwFormatFootnote const *>(aContent[ i ]);
2129  rWrt.WriteFootnoteBegin( *pFootnote );
2130  const SwNodeIndex* pIdx = pFootnote->GetTextFootnote()->GetStartNode();
2131  OSL_ENSURE( pIdx, "Where is the start node of Foot-/Endnote?" );
2132  rWrt.WriteSpecialText( pIdx->GetIndex() + 1,
2133  pIdx->GetNode().EndOfSectionIndex(),
2134  nTTyp );
2135  }
2136  break;
2137 
2138  default:
2139  OSL_ENSURE( false, "What kind of SubDocType is that?" );
2140  }
2141 
2142  pTextPos->Append( rWrt.Fc2Cp( rWrt.Strm().Tell() ));
2143  // CR to the end ( otherwise WW complains )
2144  rWrt.WriteStringAsPara( OUString() );
2145 
2146  WW8_CP nCpEnd = rWrt.Fc2Cp( rWrt.Strm().Tell() );
2147  pTextPos->Append( nCpEnd );
2148  rCount = nCpEnd - nCpStart;
2149 
2150  return ( rCount != 0 );
2151 }
2152 
2153 static bool lcl_AuthorComp( const std::pair<OUString,OUString>& aFirst, const std::pair<OUString,OUString>& aSecond)
2154 {
2155  return aFirst.first < aSecond.first;
2156 }
2157 
2158 static bool lcl_PosComp( const std::pair<WW8_CP, int>& aFirst, const std::pair<WW8_CP, int>& aSecond)
2159 {
2160  return aFirst.first < aSecond.first;
2161 }
2162 
2164  WW8_FC& rTextStart, sal_Int32& rTextCount, WW8_FC& rRefStart, sal_Int32& rRefCount ) const
2165 {
2166 
2167  sal_uLong nFcStart = rWrt.pTableStrm->Tell();
2168  sal_uInt16 nLen = aCps.size();
2169  if ( !nLen )
2170  return;
2171 
2172  OSL_ENSURE( aCps.size() + 2 == pTextPos->Count(), "WritePlc: DeSync" );
2173 
2174  std::vector<std::pair<OUString,OUString> > aStrArr;
2175  WW8Fib& rFib = *rWrt.pFib; // n+1-th CP-Pos according to the manual
2176  bool bWriteCP = true;
2177 
2178  switch ( nTTyp )
2179  {
2180  case TXT_ATN:
2181  {
2182  std::vector< std::pair<WW8_CP, int> > aRangeStartPos; // The second of the pair is the original index before sorting.
2183  std::vector< std::pair<WW8_CP, int> > aRangeEndPos; // Same, so we can map between the indexes before/after sorting.
2184  std::map<int, int> aAtnStartMap; // Maps from annotation index to start index.
2185  std::map<int, int> aStartAtnMap; // Maps from start index to annotation index.
2186  std::map<int, int> aStartEndMap; // Maps from start index to end index.
2187  // then write first the GrpXstAtnOwners
2188  int nIdx = 0;
2189  for ( sal_uInt16 i = 0; i < nLen; ++i )
2190  {
2191  const WW8_Annotation& rAtn = *static_cast<const WW8_Annotation*>(aContent[i]);
2192  aStrArr.emplace_back(rAtn.msOwner,rAtn.m_sInitials);
2193  // record start and end positions for ranges
2194  if (rAtn.HasRange())
2195  {
2196  aRangeStartPos.emplace_back(rAtn.m_nRangeStart, nIdx);
2197  aRangeEndPos.emplace_back(rAtn.m_nRangeEnd, nIdx);
2198  ++nIdx;
2199  }
2200  }
2201 
2202  //sort and remove duplicates
2203  std::sort(aStrArr.begin(), aStrArr.end(),&lcl_AuthorComp);
2204  auto aIter = std::unique(aStrArr.begin(), aStrArr.end());
2205  aStrArr.erase(aIter, aStrArr.end());
2206 
2207  // Also sort the start and end positions. We need to reference
2208  // the start index in the annotation table and also need to
2209  // reference the end index in the start table, so build a map
2210  // that knows what index to reference, after sorting.
2211  std::sort(aRangeStartPos.begin(), aRangeStartPos.end(), &lcl_PosComp);
2212  for (decltype(aRangeStartPos)::size_type i = 0; i < aRangeStartPos.size(); ++i)
2213  {
2214  aAtnStartMap[aRangeStartPos[i].second] = i;
2215  aStartAtnMap[i] = aRangeStartPos[i].second;
2216  }
2217  std::sort(aRangeEndPos.begin(), aRangeEndPos.end(), &lcl_PosComp);
2218  for (decltype(aRangeEndPos)::size_type i = 0; i < aRangeEndPos.size(); ++i)
2219  aStartEndMap[aAtnStartMap[ aRangeEndPos[i].second ]] = i;
2220 
2221  for ( decltype(aStrArr)::size_type i = 0; i < aStrArr.size(); ++i )
2222  {
2223  const OUString& sAuthor = aStrArr[i].first;
2224  SwWW8Writer::WriteShort(*rWrt.pTableStrm, sAuthor.getLength());
2225  SwWW8Writer::WriteString16(*rWrt.pTableStrm, sAuthor,
2226  false);
2227  }
2228 
2229  rFib.m_fcGrpStAtnOwners = nFcStart;
2230  nFcStart = rWrt.pTableStrm->Tell();
2231  rFib.m_lcbGrpStAtnOwners = nFcStart - rFib.m_fcGrpStAtnOwners;
2232 
2233  // Commented text ranges
2234  if( !aRangeStartPos.empty() )
2235  {
2236  // Commented text ranges starting positions (Plcfbkf.aCP)
2237  rFib.m_fcPlcfAtnbkf = nFcStart;
2238  for ( decltype(aRangeStartPos)::size_type i = 0; i < aRangeStartPos.size(); ++i )
2239  {
2240  SwWW8Writer::WriteLong( *rWrt.pTableStrm, aRangeStartPos[i].first );
2241  }
2242  SwWW8Writer::WriteLong( *rWrt.pTableStrm, rFib.m_ccpText + 1);
2243 
2244  // Commented text ranges additional information (Plcfbkf.aFBKF)
2245  for ( decltype(aRangeStartPos)::size_type i = 0; i < aRangeStartPos.size(); ++i )
2246  {
2247  SwWW8Writer::WriteShort( *rWrt.pTableStrm, aStartEndMap[i] ); // FBKF.ibkl
2248  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 ); // FBKF.bkc
2249  }
2250 
2251  nFcStart = rWrt.pTableStrm->Tell();
2252  rFib.m_lcbPlcfAtnbkf = nFcStart - rFib.m_fcPlcfAtnbkf;
2253 
2254  // Commented text ranges ending positions (PlcfBkl.aCP)
2255  rFib.m_fcPlcfAtnbkl = nFcStart;
2256  for ( decltype(aRangeEndPos)::size_type i = 0; i < aRangeEndPos.size(); ++i )
2257  {
2258  SwWW8Writer::WriteLong( *rWrt.pTableStrm, aRangeEndPos[i].first );
2259  }
2260  SwWW8Writer::WriteLong( *rWrt.pTableStrm, rFib.m_ccpText + 1);
2261 
2262  nFcStart = rWrt.pTableStrm->Tell();
2263  rFib.m_lcbPlcfAtnbkl = nFcStart - rFib.m_fcPlcfAtnbkl;
2264 
2265  // Commented text ranges as bookmarks (SttbfAtnBkmk)
2266  rFib.m_fcSttbfAtnbkmk = nFcStart;
2267  SwWW8Writer::WriteShort( *rWrt.pTableStrm, sal_Int16(sal_uInt16(0xFFFF)) ); // SttbfAtnBkmk.fExtend
2268  SwWW8Writer::WriteShort( *rWrt.pTableStrm, aRangeStartPos.size() ); // SttbfAtnBkmk.cData
2269  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0xA ); // SttbfAtnBkmk.cbExtra
2270 
2271  for ( decltype(aRangeStartPos)::size_type i = 0; i < aRangeStartPos.size(); ++i )
2272  {
2273  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 ); // SttbfAtnBkmk.cchData
2274  // One ATNBE structure for all text ranges
2275  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0x0100 ); // ATNBE.bmc
2276  SwWW8Writer::WriteLong( *rWrt.pTableStrm, aStartAtnMap[i] ); // ATNBE.lTag
2277  SwWW8Writer::WriteLong( *rWrt.pTableStrm, -1 ); // ATNBE.lTagOld
2278  }
2279 
2280  nFcStart = rWrt.pTableStrm->Tell();
2281  rFib.m_lcbSttbfAtnbkmk = nFcStart - rFib.m_fcSttbfAtnbkmk;
2282  }
2283 
2284  // Write the extended >= Word XP ATRD records
2285  for( sal_uInt16 i = 0; i < nLen; ++i )
2286  {
2287  const WW8_Annotation& rAtn = *static_cast<const WW8_Annotation*>(aContent[i]);
2288 
2289  sal_uInt32 nDTTM = sw::ms::DateTime2DTTM(rAtn.maDateTime);
2290 
2291  SwWW8Writer::WriteLong( *rWrt.pTableStrm, nDTTM );
2292  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2293  SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2294  SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2295  SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2296  }
2297 
2298  rFib.m_fcAtrdExtra = nFcStart;
2299  nFcStart = rWrt.pTableStrm->Tell();
2300  rFib.m_lcbAtrdExtra = nFcStart - rFib.m_fcAtrdExtra;
2301  rFib.m_fcHplxsdr = 0x01010002; //WTF, but apparently necessary
2302  rFib.m_lcbHplxsdr = 0;
2303  }
2304  break;
2305  case TXT_TXTBOX:
2306  case TXT_HFTXTBOX:
2307  {
2308  pTextPos->Write( *rWrt.pTableStrm );
2309  const std::vector<sal_uInt32>* pShapeIds = GetShapeIdArr();
2310  OSL_ENSURE( pShapeIds, "Where are the ShapeIds?" );
2311 
2312  for ( sal_uInt16 i = 0; i < nLen; ++i )
2313  {
2314  // write textbox story - FTXBXS
2315  // is it a writer or sdr - textbox?
2316  const SdrObject* pObj = static_cast<SdrObject const *>(aContent[ i ]);
2317  sal_Int32 nCnt = 1;
2318  if (dynamic_cast< const SdrTextObj *>( pObj ))
2319  {
2320  // find the "highest" SdrObject of this
2321  const SwFrameFormat& rFormat = *::FindFrameFormat( pObj );
2322 
2323  const SwFormatChain* pChn = &rFormat.GetChain();
2324  while ( pChn->GetNext() )
2325  {
2326  // has a chain?
2327  // then calc the cur pos in the chain
2328  ++nCnt;
2329  pChn = &pChn->GetNext()->GetChain();
2330  }
2331  }
2332  if( nullptr == pObj )
2333  {
2334  if (i < aSpareFormats.size() && aSpareFormats[i])
2335  {
2336  const SwFrameFormat& rFormat = *aSpareFormats[i];
2337 
2338  const SwFormatChain* pChn = &rFormat.GetChain();
2339  while( pChn->GetNext() )
2340  {
2341  // has a chain?
2342  // then calc the cur pos in the chain
2343  ++nCnt;
2344  pChn = &pChn->GetNext()->GetChain();
2345  }
2346  }
2347  }
2348  // long cTxbx / iNextReuse
2349  SwWW8Writer::WriteLong( *rWrt.pTableStrm, nCnt );
2350  // long cReusable
2351  SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2352  // short fReusable
2353  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2354  // long reserved
2355  SwWW8Writer::WriteLong( *rWrt.pTableStrm, -1 );
2356  // long lid
2358  (*pShapeIds)[i]);
2359  // long txidUndo
2360  SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2361  }
2362  SwWW8Writer::FillCount( *rWrt.pTableStrm, 22 );
2363  bWriteCP = false;
2364  }
2365  break;
2366  }
2367 
2368  if ( bWriteCP )
2369  {
2370  // write CP Positions
2371  for ( sal_uInt16 i = 0; i < nLen; i++ )
2372  SwWW8Writer::WriteLong( *rWrt.pTableStrm, aCps[ i ] );
2373 
2374  // n+1-th CP-Pos according to the manual
2376  rFib.m_ccpText + rFib.m_ccpFootnote + rFib.m_ccpHdr + rFib.m_ccpEdn +
2377  rFib.m_ccpTxbx + rFib.m_ccpHdrTxbx + 1 );
2378 
2379  if ( TXT_ATN == nTTyp )
2380  {
2381  sal_uInt16 nlTag = 0;
2382  for ( sal_uInt16 i = 0; i < nLen; ++i )
2383  {
2384  const WW8_Annotation& rAtn = *static_cast<const WW8_Annotation*>(aContent[i]);
2385 
2386  //aStrArr is sorted
2387  auto aIter = std::lower_bound(aStrArr.begin(),
2388  aStrArr.end(), std::pair<OUString,OUString>(rAtn.msOwner,OUString()),
2389  &lcl_AuthorComp);
2390  OSL_ENSURE(aIter != aStrArr.end() && aIter->first == rAtn.msOwner,
2391  "Impossible");
2392  sal_uInt16 nFndPos = static_cast< sal_uInt16 >(aIter - aStrArr.begin());
2393  OUString sInitials( aIter->second );
2394  sal_uInt8 nInitialsLen = static_cast<sal_uInt8>(sInitials.getLength());
2395  if ( nInitialsLen > 9 )
2396  {
2397  sInitials = sInitials.copy( 0, 9 );
2398  nInitialsLen = 9;
2399  }
2400 
2401  // xstUsrInitl[ 10 ] pascal-style String holding initials
2402  // of annotation author
2403  SwWW8Writer::WriteShort(*rWrt.pTableStrm, nInitialsLen);
2404  SwWW8Writer::WriteString16(*rWrt.pTableStrm, sInitials,
2405  false);
2407  (9 - nInitialsLen) * 2 );
2408 
2409  // documents layout of WriteShort's below:
2410 
2411  // SVBT16 ibst; // index into GrpXstAtnOwners
2412  // SVBT16 ak; // not used
2413  // SVBT16 grfbmc; // not used
2414  // SVBT32 ITagBkmk; // when not -1, this tag identifies the ATNBE
2415 
2416  SwWW8Writer::WriteShort( *rWrt.pTableStrm, nFndPos );
2417  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2418  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2419  if (rAtn.HasRange())
2420  {
2421  SwWW8Writer::WriteLong( *rWrt.pTableStrm, nlTag );
2422  ++nlTag;
2423  }
2424  else
2425  SwWW8Writer::WriteLong( *rWrt.pTableStrm, -1 );
2426  }
2427  }
2428  else
2429  {
2430  sal_uInt16 nNo = 0;
2431  for ( sal_uInt16 i = 0; i < nLen; ++i ) // write Flags
2432  {
2433  const SwFormatFootnote* pFootnote = static_cast<SwFormatFootnote const *>(aContent[ i ]);
2435  !pFootnote->GetNumStr().isEmpty() ? 0 : ++nNo );
2436  }
2437  }
2438  }
2439  rRefStart = nFcStart;
2440  nFcStart = rWrt.pTableStrm->Tell();
2441  rRefCount = nFcStart - rRefStart;
2442 
2443  pTextPos->Write( *rWrt.pTableStrm );
2444 
2445  switch ( nTTyp )
2446  {
2447  case TXT_TXTBOX:
2448  case TXT_HFTXTBOX:
2449  for ( sal_uInt16 i = 0; i < nLen; ++i )
2450  {
2451  // write break descriptor (BKD)
2452  // short itxbxs
2454  // short dcpDepend
2455  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2456  // short flags : icol/fTableBreak/fColumnBreak/fMarked/
2457  // fUnk/fTextOverflow
2458  SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0x800 );
2459  }
2460  SwWW8Writer::FillCount( *rWrt.pTableStrm, 6 );
2461  break;
2462  }
2463 
2464  rTextStart = nFcStart;
2465  rTextCount = rWrt.pTableStrm->Tell() - nFcStart;
2466 }
2467 
2468 const std::vector<sal_uInt32>* WW8_WrPlcSubDoc::GetShapeIdArr() const
2469 {
2470  return nullptr;
2471 }
2472 
2473 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
std::map< wwFont, sal_uInt16 > maFonts
Keep track of fonts that need to be exported.
Definition: wrtww8.hxx:325
virtual void EndStyleProperties(bool bParProp) override
End of (paragraph or run) properties of a style.
Definition: wrtw8sty.cxx:539
long GetLeft() const
bool WriteGenericText(WW8Export &rWrt, sal_uInt8 nTTyp, WW8_CP &rCount)
Definition: wrtw8sty.cxx:2018
sal_uInt16 CurrentNumberOfColumns(const SwDoc &rDoc) const
Number of columns based on the most recent WW8_SepInfo.
Definition: wrtw8sty.cxx:1046
WW8_CP m_nRangeEnd
Definition: wrtww8.hxx:1232
SwSectionNode * FindSectionNode()
Search section node, in which it is.
Definition: ndsect.cxx:960
SvxNumType GetNumberingType() const
const SwEndNode * EndOfSectionNode() const
Definition: node.hxx:682
Subgroup labels.
Definition: poolfmt.hxx:345
static sal_uInt16 GetWWId(const SwFormat &rFormat)
Definition: wrtw8sty.cxx:210
SwCharFormat * GetAnchorCharFormat(SwDoc &rDoc) const
Definition: docftn.cxx:183
Exporter of the binary Word file formats.
Definition: wrtww8.hxx:963
sal_uInt16 nEdn
Definition: ww8scan.hxx:1679
static bool lcl_AuthorComp(const std::pair< OUString, OUString > &aFirst, const std::pair< OUString, OUString > &aSecond)
Definition: wrtw8sty.cxx:2153
WW8_FC m_fcStshf
Definition: ww8scan.hxx:1243
virtual AttributeOutputBase & AttrOutput() const =0
Access to the attribute output class.
void SetHdFtIndex(unsigned int nHdFtIndex)
Definition: wrtww8.hxx:1112
SwNode & GetNode(bool bPoint=true) const
Definition: pam.hxx:223
#define RES_COL
Definition: hintids.hxx:214
void WriteProperties(const SwFormat *pFormat, bool bPap, sal_uInt16 nPos, bool bInsDefCharSiz)
Outputs attributes of one style.
Definition: wrtw8sty.cxx:519
const HdFtFlags WW8_FOOTER_FIRST
Definition: ww8scan.hxx:1594
sal_uInt16 rncEdn
Definition: ww8scan.hxx:1678
virtual void SectionTitlePage()=0
Has different headers/footers for the title page.
Class to collect and output the sections/headers/footers.
Definition: wrtww8.hxx:198
int GetAssignedOutlineStyleLevel() const
Definition: fmtcol.cxx:588
virtual void EndStyles(sal_uInt16 nNumberOfStyles)=0
End of the styles table.
std::unique_ptr< ww::bytes > pO
Buffer.
Definition: wrtww8.hxx:966
SvStream * pTableStrm
Definition: wrtww8.hxx:968
Represents the style of a paragraph.
Definition: fmtcol.hxx:55
unsigned int GetHdFtIndex() const
Definition: wrtww8.hxx:1111
The class that has handlers for various resource types when exporting as DOCX.
void AddRangeStartPosition(const OUString &rName, WW8_CP nStartCp, bool bIgnoreEmpty)
Definition: wrtw8sty.cxx:1975
const sal_uInt16 sprmSBkc
Definition: sprmids.hxx:539
#define WW8_RESERVED_SLOTS
Definition: wrtw8sty.cxx:122
std::vector< SwColumn > SwColumns
Definition: fmtclds.hxx:57
bool IsSectionNode() const
Definition: node.hxx:644
std::unique_ptr< WW8Fib > pFib
File Information Block.
Definition: wrtww8.hxx:970
#define RES_CONDTXTFMTCOLL
Definition: hintids.hxx:278
sal_Int32 m_lcbStshf
Definition: ww8scan.hxx:1244
bool m_bEndAtTextEnd
Definition: wrtww8.hxx:555
void EmbedFont(const OUString &name, FontFamily family, FontPitch pitch)
Write out the font into the document, if it's an embedded font.
FAMILY_SCRIPT
#define RES_HEADER
Definition: hintids.hxx:201
std::unique_ptr< WW8_WrPlcField > m_pFieldHdFt
Definition: wrtww8.hxx:518
Pagedescriptor Client of SwPageDesc that is "described" by the attribute.
Definition: fmtpdsc.hxx:35
No numbering.
Definition: poolfmt.hxx:306
SwFrameFormat & GetLeft()
Definition: pagedesc.hxx:217
void SetStyleDefaults(const SwFormat &rFormat, bool bPap)
Definition: wrtw8sty.cxx:442
sal_uInt8 SVBT16[2]
SvStream & WriteUInt16(sal_uInt16 nUInt16)
const sal_uInt16 sprmSPgnStart97
Definition: sprmids.hxx:554
bool IsDefault() const
Definition: format.hxx:109
#define RES_CHRATR_FONTSIZE
Definition: hintids.hxx:76
void WriteStringAsPara(const OUString &rText)
Definition: wrtww8.cxx:1804
SwPageDesc * GetPageDesc()
Definition: fmtpdsc.hxx:62
const SwLineNumberInfo & GetLineNumberInfo() const
Definition: lineinfo.cxx:50
#define RES_CHRATR_LANGUAGE
Definition: hintids.hxx:78
bool HasRange() const
An annotation has a range if start != end or the m_bIgnoreEmpty flag is cleared.
Definition: wrtw8sty.cxx:1965
void OutputStyle(SwFormat *pFormat, sal_uInt16 nPos)
Outputs one style - called (in a loop) from OutputStylesTable().
Definition: wrtw8sty.cxx:581
const SwFormatHeader & GetHeader(bool=true) const
Definition: fmthdft.hxx:97
FAMILY_MODERN
virtual void StartStyleProperties(bool bParProp, sal_uInt16 nStyle) override
Start of (paragraph or run) properties of a style.
Definition: wrtw8sty.cxx:502
void Append(sal_uLong nStartCpOrFc)
Definition: wrtw8sty.cxx:950
bool m_bFootnoteAtTextEnd
Definition: wrtww8.hxx:554
const sal_uInt16 sprmSRncFtn
Definition: sprmids.hxx:582
const sal_uInt16 sprmSNLnnMod
Definition: sprmids.hxx:547
WW8_CP m_nRangeStart
Definition: wrtww8.hxx:1232
bool mbAlt
Definition: wrtww8.hxx:307
sal_uInt16 m_nStyleStartSize
For output of styles.
sal_uInt16 GetCountBy() const
Definition: lineinfo.hxx:75
virtual void EndStyles(sal_uInt16 nNumberOfStyles) override
End of the styles table.
Definition: wrtw8sty.cxx:663
void SetAdjustValue(sal_Int16 n)
Definition: fmtclds.hxx:96
OUString msFamilyNm
Definition: wrtww8.hxx:305
SwNodeIndex nNode
Definition: pam.hxx:37
const SfxPoolItem * GetPoolDefaultItem(sal_uInt16 nWhich) const
virtual void SectFootnoteEndnotePr() override
for footnote/endnote section properties
Definition: wrtw8sty.cxx:1316
std::size_t GetAuthor() const
Definition: redline.hxx:125
void OutputStylesTable()
Output the styles table.
Definition: wrtw8sty.cxx:671
std::vector< const SwFrameFormat * > aSpareFormats
Definition: wrtww8.hxx:1195
Pages/field.
Definition: poolfmt.hxx:115
virtual void EndSection()=0
End of the section properties.
sal_uIntPtr sal_uLong
const tools::Time GetTime() const
Definition: docufld.hxx:473
const sal_uInt16 sprmSPgbProp
Definition: sprmids.hxx:570
#define RES_FRAMEDIR
Definition: hintids.hxx:225
void EndFont() const
End the font.
void WriteFontTable(SvStream *pTableStream, WW8Fib &pFib)
Definition: wrtw8sty.cxx:902
SwFrameFormat & GetFirstMaster()
Definition: pagedesc.hxx:218
No numbering.
Definition: poolfmt.hxx:310
bool IsAutoRule() const
Definition: numrule.hxx:227
#define RES_FRMATR_END
Definition: hintids.hxx:236
void WritePlcHdd(WW8Export &rWrt) const
Definition: wrtw8sty.cxx:1862
void WriteFootnoteEndText(WW8Export &rWrt, sal_uLong nCpStt)
Definition: wrtw8sty.cxx:1125
bool m_bOutPageDescs
PageDescs (section properties) are being written.
Definition: wrtww8.hxx:546
Definition: doc.hxx:185
sal_Int16 nfcFootnoteRef
Definition: ww8scan.hxx:1771
void StartFont(const OUString &rFamilyName) const
Start the font.
sal_Int16 nId
Content 1st level.
Definition: poolfmt.hxx:375
virtual bool CollapseScriptsforWordOk(sal_uInt16 nScript, sal_uInt16 nWhich)=0
Guess the script (asian/western).
virtual OUString GetPar1() const override
Author.
Definition: docufld.cxx:1787
#define RES_CHRATR_FONT
Definition: hintids.hxx:75
void WriteRtf(const RtfAttributeOutput *rAttrOutput) const
Definition: wrtw8sty.cxx:809
SwNode & GetNode() const
Definition: ndindex.hxx:118
const OUString & GetName() const
Definition: numrule.hxx:222
virtual void StartStyles() override
Start of the styles table.
Definition: wrtw8sty.cxx:641
Content, content of frame (header, footer, fly).
Definition: fmtcntnt.hxx:31
SwSectionFormat * GetFormat()
Definition: section.hxx:337
WW8_FC m_fcPlcfAtnbkf
Definition: ww8scan.hxx:1389
#define RES_CHRATR_CJK_FONT
Definition: hintids.hxx:90
FAMILY_ROMAN
WW8_CP Fc2Cp(sal_uLong nFc) const
Definition: wrtww8.hxx:1080
void BuildStyleIds()
Based on pFormatA, fill in m_aStyleIds with unique, MS-like names.
Definition: wrtw8sty.cxx:320
MSWordStyles(const MSWordStyles &)=delete
virtual void SectionFormProtection(bool bProtected) override
Protection of forms.
Definition: wrtw8sty.cxx:1328
virtual const std::vector< sal_uInt32 > * GetShapeIdArr() const
Definition: wrtw8sty.cxx:2468
bool m_bOutFirstPage
Definition: wrtww8.hxx:547
virtual bool HeaderFooterWritten() override
Definition: wrtw8sty.cxx:1041
std::vector< const wwFont * > AsVector() const
Convert from fast insertion map to linear vector in the order that we want to write.
Definition: wrtw8sty.cxx:892
std::vector< sal_uLong > aPos
Definition: wrtw8sty.cxx:107
const SwNumRule * GetSwNumRule(sal_uInt16 nId) const
Get numbering rule of the nId-th style.
Definition: wrtw8sty.cxx:699
#define RES_TXTATR_END
Definition: hintids.hxx:158
const SfxItemSet * GetCurItemSet() const
Getter for pISet.
Definition: wrtww8.hxx:709
sal_uInt16 nPOPosStdLen1
For output of styles.
FontPitch GetPitch() const
virtual ExportFormat GetExportFormat() const =0
virtual void SectionPageNumbering(sal_uInt16 nNumType, const ::boost::optional< sal_uInt16 > &oPageRestartNumber) override
The style of the page numbers.
Definition: wrtw8sty.cxx:1409
SwTableFormat * GetFrameFormat()
Definition: swtable.hxx:201
OString const & GetStyleId(sal_uInt16 nId) const
Get styleId of the nId-th style (nId is its position in pFormatA).
Definition: wrtw8sty.cxx:372
FontFamily GetFamily() const
sal_uInt32 m_lcbAtrdExtra
Definition: ww8scan.hxx:1478
sal_uLong m_nStyleCountPos
For output of styles.
Content 5th level.
Definition: poolfmt.hxx:379
static void SetHeaderFlag(sal_uInt8 &rHeadFootFlags, const SwFormat &rFormat, sal_uInt8 nFlag)
Definition: wrtw8sty.cxx:1184
sal_uInt8 SVBT32[4]
#define MSWORD_MAX_STYLES_LIMIT
Definition: wrtww8.hxx:1601
WW8_FC m_fcSttbfAtnbkmk
Definition: ww8scan.hxx:1362
const SwSection & GetSection() const
Definition: node.hxx:541
SwContentNode * GetContentNode(bool bPoint=true) const
Definition: pam.hxx:229
void SectionProperties(const WW8_SepInfo &rSectionInfo, WW8_PdAttrDesc *pA=nullptr)
Write section properties.
Definition: wrtw8sty.cxx:1509
bool const m_bListStyles
If list styles are requested to be exported as well.
Definition: wrtww8.hxx:1549
const SwTextFootnote * GetTextFootnote() const
Definition: fmtftn.hxx:85
std::vector< WW8_SepInfo > aSects
Definition: wrtww8.hxx:202
sal_uInt16 sal_Unicode
bool IsAssignedToListLevelOfOutlineStyle() const
Definition: fmtcol.hxx:109
bool IsRestartEachPage() const
Definition: lineinfo.hxx:90
void FontCharset(sal_uInt8 nCharSet) const
Font charset.
void FontPitchType(FontPitch ePitch) const
Font pitch.
bool IsFollowNextPageOfNode(const SwNode &rNd) const
Definition: pagedesc.cxx:345
virtual void EndStyle()=0
End of a style in the styles table.
void OutputFormat(const SwFormat &rFormat, bool bPapFormat, bool bChpFormat, bool bFlyFormat=false)
Output attributes.
Definition: ww8atr.cxx:754
rtl_TextEncoding GetCharSet() const
const SwTextFormatColl * GetDfltTextFormatColl() const
Definition: doc.hxx:771
virtual void SectionLineNumbering(sal_uLong nRestartNo, const SwLineNumberInfo &rLnNumInfo) override
Numbering of the lines in the document.
Definition: wrtw8sty.cxx:1339
void StartFont(const OUString &rFamilyName) const
Start the font.
The class that has handlers for various resource types when exporting as RTF.
const OUString & GetName() const
Definition: format.hxx:111
const sal_uInt16 sprmSNfcPgn
Definition: sprmids.hxx:543
Footer, for pageformats Client of FrameFormat describing the footer.
Definition: fmthdft.hxx:64
StyleType
sal_uLong GetIndex() const
Definition: ndindex.hxx:151
const OUString & GetText() const
Definition: docufld.hxx:483
Content 6th level.
Definition: poolfmt.hxx:389
const sal_uInt8 MAXLEVEL
Definition: swtypes.hxx:95
SvxNumberType aFormat
Definition: ftninfo.hxx:46
#define RES_PAPER_BIN
Definition: hintids.hxx:195
SvStream & WriteUInt32(sal_uInt32 nUInt32)
void Append(WW8_CP nCp, const SwPostItField *pPostIt)
Definition: wrtw8sty.cxx:1981
void WritePostItBegin(ww::bytes *pO=nullptr)
Definition: ww8atr.cxx:2562
const SwTable & GetTable() const
Definition: node.hxx:497
const HdFtFlags WW8_FOOTER_EVEN
Definition: ww8scan.hxx:1591
DateTime maDateTime
Definition: wrtww8.hxx:1231
void Set_UInt16(sal_uInt8 *&p, sal_uInt16 n)
Definition: ww8struc.hxx:47
const SfxPoolItem * GetDfltAttr(sal_uInt16 nWhich)
Get the default attribute from corresponding default attribute table.
Definition: hints.cxx:153
const OUString & GetNumStr() const
Definition: fmtftn.hxx:70
void Write(SvStream *pTableStram) const
Definition: wrtw8sty.cxx:777
#define RES_TXTFMTCOLL
Definition: hintids.hxx:275
#define RES_PARATR_BEGIN
Definition: hintids.hxx:160
PITCH_VARIABLE
void FontAlternateName(const OUString &rName) const
Alternate name for the font.
Text body indent.
Definition: poolfmt.hxx:254
virtual void SectFootnoteEndnotePr()
for footnote/endnote section properties
SwFrameFormat * FindFrameFormat(SdrObject *pObj)
The Get reverse way: seeks the format to the specified object.
Definition: dcontact.cxx:125
std::map< sal_uInt16, const SwNumRule * > m_aNumRules
Slot <-> List style map.
Definition: wrtww8.hxx:1550
bool IsNewRedlineComment(const SwRedlineData *pRedLine)
Definition: wrtw8sty.cxx:2007
virtual void EndStyle() override
End of a style in the styles table.
Definition: wrtw8sty.cxx:384
void OutputItem(const SfxPoolItem &rHt)
Call the right virtual function according to the type of the item.
Definition: ww8atr.cxx:5131
FAMILY_DECORATIVE
bool m_bHeaderFooterWritten
Definition: wrtww8.hxx:250
SwAttrPool * GetPool() const
Definition: swatrset.hxx:190
virtual void SectionBiDi(bool bBiDi) override
Columns populated from right/numbers on the right side?
Definition: wrtw8sty.cxx:1403
virtual void DefaultStyle() override
Write default style.
Definition: wrtw8sty.cxx:566
Collects and outputs fonts.
Definition: wrtww8.hxx:299
const sal_uInt16 sprmSVjc
Definition: sprmids.hxx:552
virtual void TextVerticalAdjustment(const css::drawing::TextVerticalAdjust) override
Definition: wrtw8sty.cxx:1457
virtual void SetupSectionPositions(WW8_PdAttrDesc *)
Setup the pA's info.
Definition: wrtww8.hxx:755
sal_uInt16 GetPoolFormatId() const
Get and set Pool style IDs.
Definition: format.hxx:143
const HdFtFlags WW8_HEADER_ODD
Definition: ww8scan.hxx:1590
rtl_TextEncoding const meChrSet
Definition: wrtww8.hxx:310
void Write(SvStream &rStrm)
Definition: wrtw8sty.cxx:955
Base class for various Writer styles.
Definition: format.hxx:43
sal_uInt16 rncFootnote
Definition: ww8scan.hxx:1621
sal_Int32 m_lcbGrpStAtnOwners
Definition: ww8scan.hxx:1360
void ExportControl(WW8Export &rWrt, const SdrUnoObj &rFormObj)
Definition: wrtw8esh.cxx:3068
SwMSConvertControls & GetOCXExp()
Definition: wrtww8.hxx:1028
static void WriteString16(SvStream &rStrm, const OUString &rStr, bool bAddZero)
Definition: wrtww8.cxx:1768
virtual void SetupSectionPositions(WW8_PdAttrDesc *pA) override
Setup the pA's info.
Definition: wrtw8sty.cxx:1437
const ::boost::optional< sal_uInt16 > & GetNumOffset() const
Definition: fmtpdsc.hxx:65
bool IsProtected() const
Definition: wrtw8sty.cxx:1233
bool IsContentNode() const
Definition: node.hxx:628
bool IsHeaderShared() const
Definition: pagedesc.hxx:295
const SwTextNode * GetHdFtPageRoot() const
Top node of host page when in header/footer.
Definition: wrtww8.hxx:761
void FontFamilyType(FontFamily eFamily, const wwFont &rFont) const
Font family.
sal_uInt16 GetPosFromLeft() const
Definition: lineinfo.hxx:72
virtual ~MSWordSections()
Definition: wrtw8sty.cxx:1028
WW8Export & m_rWW8Export
Reference to the export, where to get the data from.
virtual ~WW8_WrPlcSubDoc()
Definition: wrtw8sty.cxx:1929
void EndFont() const
End the font.
Style of a layout element.
Definition: frmfmt.hxx:57
WW8_FC m_fcHplxsdr
Definition: ww8scan.hxx:1511
SVBT32 fcSepx
Definition: wrtw8sty.cxx:94
const sal_uInt16 sprmSLnnMin
Definition: sprmids.hxx:553
#define SW_MOD()
Definition: swmodule.hxx:255
const OutlinerParaObject * mpRichText
Definition: wrtww8.hxx:1227
OUString msOwner
Definition: wrtww8.hxx:1229
Footnote anchor.
Definition: poolfmt.hxx:128
virtual void SectionType(sal_uInt8 nBreakCode)=0
The type of breaking.
bool const bIsFirstParagraph
Definition: wrtww8.hxx:183
void WritePlcSed(WW8Export &rWrt) const
Definition: wrtw8sty.cxx:1837
sal_Int16 nfcEdnRef
Definition: ww8scan.hxx:1772
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
void SetCurItemSet(const SfxItemSet *pS)
Setter for pISet.
Definition: wrtww8.hxx:712
Complimentary close.
Definition: poolfmt.hxx:255
const SwSectionFormat * pSectionFormat
Definition: wrtww8.hxx:179
void BuildStylesTable()
Create the style table, called from the constructor.
Definition: wrtw8sty.cxx:279
#define RES_CHRATR_CTL_FONT
Definition: hintids.hxx:95
static sal_uInt16 NumberOfColumns(const SwDoc &rDoc, const WW8_SepInfo &rInfo)
Number of columns of the provided WW8_SepInfo.
Definition: wrtw8sty.cxx:1055
Internet visited.
Definition: poolfmt.hxx:122
const SwColumns & GetColumns() const
Definition: fmtclds.hxx:112
std::unique_ptr< WW8_WrPlcSepx > pSepx
Sections/headers/footers.
Definition: wrtww8.hxx:974
WW8_FC m_nSepxFcPos
Definition: wrtw8sty.cxx:86
std::vector< WW8_CP > aCps
Definition: wrtww8.hxx:1193
const SwStartNode * StartOfSectionNode() const
Definition: node.hxx:131
WW8_CP m_ccpHdrTxbx
Definition: ww8scan.hxx:1211
const SwFrameFormat * GetFooterFormat() const
Definition: fmthdft.hxx:85
WW8_WrPlcSepx(const WW8_WrPlcSepx &)=delete
For the output of sections.
Definition: wrtw8sty.cxx:82
const SwPosition * GetPoint() const
Definition: pam.hxx:207
const sal_uInt16 sprmSFBiDi
Definition: sprmids.hxx:564
Subgroup footer.
Definition: poolfmt.hxx:336
sal_Int32 m_lcbSttbfAtnbkmk
Definition: ww8scan.hxx:1363
bool IsProtect() const
Definition: section.cxx:354
PITCH_FIXED
No numbering.
Definition: poolfmt.hxx:322
const SwPageDesc & GetPageDesc(const size_t i) const
Definition: doc.hxx:875
sal_uInt16 epc
Definition: ww8scan.hxx:1680
void WriteDocx(DocxAttributeOutput *rAttrOutput) const
Definition: wrtw8sty.cxx:790
void FontAlternateName(const OUString &rName) const
Alternate name for the font.
void CheckForFacinPg(const WW8Export &rWrt) const
Definition: wrtw8sty.cxx:1250
virtual void DefaultStyle()=0
Write default style.
sal_uInt8 rtl_TextEncodingToWinCharsetRTF(OUString const &rFontName, OUString const &rAltName, rtl_TextEncoding eTextEncoding)
MSOffice appears to set the charset of unicode fonts to MS 932.
DateTime maDateTime
sal_uInt16 GetId(const SwNumRule &rNumRule)
Return the numeric id of the numbering rule.
Definition: wrtw8num.cxx:73
const SwModify * m_pOutFormatNode
Definition: wrtww8.hxx:530
std::unique_ptr< WW8Dop > pDop
DOcument Properties.
Definition: wrtww8.hxx:971
Text body.
Definition: poolfmt.hxx:251
bool m_bFirstTOCNodeWithSection
Definition: wrtww8.hxx:490
std::unique_ptr< WW8_WrPlc0 > pTextPos
Definition: wrtww8.hxx:1196
static bool lcl_PosComp(const std::pair< WW8_CP, int > &aFirst, const std::pair< WW8_CP, int > &aSecond)
Definition: wrtw8sty.cxx:2158
bool mbDocumentIsProtected
Definition: wrtww8.hxx:201
int i
SwContentNode * GetContentNode()
Definition: node.hxx:615
#define RES_PARATR_HYPHENZONE
Definition: hintids.hxx:167
static void WriteShort(SvStream &rStrm, sal_Int16 nVal)
Definition: wrtww8.hxx:937
std::unique_ptr< SwFormat *[]> m_pFormatA
Slot <-> Character and paragraph style array (0 for list styles).
Definition: wrtww8.hxx:1547
UseOnPage ReadUseOn() const
Definition: pagedesc.hxx:214
std::vector< const void * > aContent
Definition: wrtww8.hxx:1194
static sal_uInt8 GetNumId(sal_uInt16 eNumType)
Convert the SVX numbering type to id.
Definition: ww8atr.cxx:690
WW8_FC m_fcGrpStAtnOwners
Definition: ww8scan.hxx:1359
const WW8_SepInfo * CurrentSectionInfo()
The most recent WW8_SepInfo.
Definition: wrtw8sty.cxx:1074
std::size_t WriteBytes(const void *pData, std::size_t nSize)
Internet normal.
Definition: poolfmt.hxx:121
size_t size() const
Definition: docary.hxx:91
Header Left&Right.
Definition: poolfmt.hxx:331
#define RES_CHRATR_BEGIN
Definition: hintids.hxx:68
const SwFormatFooter & GetFooter(bool=true) const
Definition: fmthdft.hxx:99
const DateTime & GetTimeStamp() const
Definition: redline.hxx:127
No numbering.
Definition: poolfmt.hxx:314
virtual bool HeaderFooterWritten()
Definition: wrtw8sty.cxx:1036
Endnote anchor.
Definition: poolfmt.hxx:129
OUString msSimpleText
Definition: wrtww8.hxx:1228
void AppendSep(WW8_CP nStartCp, const SwPageDesc *pPd, const SwSectionFormat *pSectionFormat, sal_uLong nLnNumRestartNo)
Definition: wrtw8sty.cxx:1092
virtual void StartSection()=0
Start of the section properties.
bool operator<(const wwFont &r1, const wwFont &r2)
Definition: wrtw8sty.cxx:821
virtual void SectionTitlePage() override
Has different headers/footers for the title page.
Definition: wrtw8sty.cxx:1364
std::vector< OString > m_aStyleIds
We need to build style id's for DOCX export; ideally we should roundtrip that, but this is good enoug...
Definition: wrtww8.hxx:1553
Label drawing objects.
Definition: poolfmt.hxx:358
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
Definition: format.cxx:398
Connection (text flow) between two FlyFrames.
Definition: fmtcnct.hxx:31
Marks a node in the document model.
Definition: ndindex.hxx:31
#define RES_LINENUMBER
Definition: hintids.hxx:221
std::unique_ptr< sal_uInt8[]> m_pData
Definition: wrtw8sty.cxx:84
bool IsFooterShared() const
Definition: pagedesc.hxx:299
FontFamily const meFamily
Definition: wrtww8.hxx:309
wwFont(const OUString &rFamilyName, FontPitch ePitch, FontFamily eFamily, rtl_TextEncoding eChrSet)
Definition: wrtw8sty.cxx:708
static void SetFooterFlag(sal_uInt8 &rHeadFootFlags, const SwFormat &rFormat, sal_uInt8 nFlag)
Definition: wrtw8sty.cxx:1194
void WriteGenericPlc(WW8Export &rWrt, sal_uInt8 nTTyp, WW8_FC &rTextStt, sal_Int32 &rTextCnt, WW8_FC &rRefStt, sal_Int32 &rRefCnt) const
Definition: wrtw8sty.cxx:2163
sal_Int32 m_lcbStshfOrig
Definition: ww8scan.hxx:1242
MSWordExportBase & m_rExport
Definition: wrtww8.hxx:1545
No numbering.
Definition: poolfmt.hxx:318
bool empty() const
void InsUInt16(sal_uInt16 n)
Definition: wrtww8.hxx:1127
bool IsAutoUpdateFormat() const
Query / set bAutoUpdateFormat-flag.
Definition: format.hxx:168
WW8_CP m_ccpTxbx
Definition: ww8scan.hxx:1210
OUString aErgoSum
Definition: ftninfo.hxx:95
FontPitch
Find suitable names for exporting this font.
Definition: msfilter.hxx:245
static bool HasBorderItem(const SwFormat &rFormat)
Should we output borders?
Definition: wrtw8sty.cxx:1301
virtual void SectionPageBorders(const SwFrameFormat *pFormat, const SwFrameFormat *pFirstPageFormat)=0
Description of the page borders.
void SetHdFtPageRoot(const SwTextNode *pNd)
Top node of host page when in header/footer.
Definition: wrtww8.hxx:758
SfxItemPool * GetPool() const
void OutHeaderFooter(WW8Export &rWrt, bool bHeader, const SwFormat &rFormat, sal_uLong &rCpPos, sal_uInt8 nHFFlags, sal_uInt8 nFlag, sal_uInt8 nBreakCode)
Definition: wrtw8sty.cxx:1204
WW8_FC m_fcAtrdExtra
Definition: ww8scan.hxx:1477
SwFlyFrameFormat * GetNext() const
Definition: fmtcnct.hxx:54
Text body first line indent.
Definition: poolfmt.hxx:252
const OUString & GetName() const
Definition: docufld.hxx:486
virtual SdrInventor GetObjInventor() const
< purpose of derivation from SwClient: character style for displaying the numbers.
Definition: lineinfo.hxx:37
virtual void StartStyle(const OUString &rName, StyleType eType, sal_uInt16 nBase, sal_uInt16 nNext, sal_uInt16 nWwIdi, sal_uInt16 nId, bool bAutoUpdate) override
Start of a style in the styles table.
Definition: wrtw8sty.cxx:398
virtual void SectionPageNumbering(sal_uInt16 nNumType, const ::boost::optional< sal_uInt16 > &oPageRestartNumber)=0
The style of the page numbers.
sal_Int32 WW8_CP
Definition: ww8struc.hxx:153
SwPaM * m_pCurPam
Definition: wrtww8.hxx:569
::boost::optional< sal_uInt16 > const oPgRestartNo
Definition: wrtww8.hxx:182
virtual void EndStyleProperties(bool bParProp)=0
End of (paragraph or run) properties of a style.
STD - STyle Definition.
Definition: ww8struc.hxx:169
#define RES_LR_SPACE
Definition: hintids.hxx:196
std::vector< std::shared_ptr< WW8_PdAttrDesc > > m_SectionAttributes
Definition: wrtww8.hxx:248
virtual void SectionFormProtection(bool bProtected)=0
Protection of forms.
const SwPageDesc * GetFollow() const
Definition: pagedesc.hxx:245
const SwNodeIndex * GetContentIdx() const
Definition: fmtcntnt.hxx:46
void FontPitchType(FontPitch ePitch) const
Font pitch.
virtual ~WW8_WrPlcAnnotations() override
Definition: wrtw8sty.cxx:2012
#define RES_FOOTER
Definition: hintids.hxx:202
void WriteHeaderFooterText(const SwFormat &rFormat, bool bHeader)
Write header/footer text.
Definition: wrtw8sty.cxx:1874
WW8_FC m_fcSttbfffn
Definition: ww8scan.hxx:1294
sal_uInt16 Which() const
for Querying of Writer-functions.
Definition: format.hxx:78
void AppendSection(const SwPageDesc *pPd, const SwSectionFormat *pSectionFormat, sal_uLong nLnNumRestartNo, bool bIsFirstParagraph=false)
Definition: wrtw8sty.cxx:1082
void NeedsDocumentProtected(const WW8_SepInfo &rInfo)
Definition: wrtw8sty.cxx:1227
const sal_uInt16 sprmSDxaLnn
Definition: sprmids.hxx:548
WW8_CP m_ccpEdn
Definition: ww8scan.hxx:1209
FontFamily
const OUString & GetFamilyName() const
WW8_FC m_fcPlcfAtnbkl
Definition: ww8scan.hxx:1392
SwFormat * DerivedFrom() const
Definition: format.hxx:108
const OUString & GetComment() const
Definition: redline.hxx:126
SwFrameFormat & GetMaster()
Definition: pagedesc.hxx:216
sal_uLong EndOfSectionIndex() const
Definition: node.hxx:677
sal_uInt16 BuildGetSlot(const SwFormat &rFormat)
Get slot number during building the style table.
Definition: wrtw8sty.cxx:181
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:79
Content 9th level.
Definition: poolfmt.hxx:392
SVBT16 aBits1
Definition: wrtw8sty.cxx:93
bool m_bIgnoreEmpty
Definition: wrtww8.hxx:1233
const OutlinerParaObject * GetTextObject() const
Definition: docufld.hxx:488
drawing::TextVerticalAdjust GetVerticalAdjustment() const
Definition: pagedesc.hxx:241
virtual void StartStyleProperties(bool bParProp, sal_uInt16 nStyle)=0
Start of (paragraph or run) properties of a style.
const SwPageDesc * m_pCurrentPageDesc
Definition: wrtww8.hxx:488
const SwPageDesc * pPageDesc
Definition: wrtww8.hxx:178
const SwCharFormats * GetCharFormats() const
Definition: doc.hxx:734
const SwFormatChain & GetChain(bool=true) const
Definition: fmtcnct.hxx:70
const SwFrameFormat * GetPageFormatOfNode(const SwNode &rNd, bool bCheckForThisPgDc=true) const
Definition: pagedesc.cxx:320
SwCharFormat * GetCharFormat(SwDoc &rDoc) const
Definition: docftn.cxx:141
const sal_uInt16 sprmSFProtected
Definition: sprmids.hxx:536
void Append(WW8_CP nCp, const SwFormatFootnote &rFootnote)
Definition: wrtw8sty.cxx:1933
SvStream & Strm() const
Definition: wrtww8.hxx:1156
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
bool IsPaintLineNumbers() const
Definition: lineinfo.hxx:81
const SwTextFormatColls * GetTextFormatColls() const
Definition: doc.hxx:773
const Date GetDate() const
Definition: docufld.hxx:472
unsigned char sal_uInt8
sal_uInt16 m_aHeadingParagraphStyles[MAXLEVEL]
Definition: wrtww8.hxx:1546
void GetStyleData(SwFormat *pFormat, bool &bFormatColl, sal_uInt16 &nBase, sal_uInt16 &nNext)
Return information about one style.
Definition: wrtw8sty.cxx:546
void WriteSpecialText(sal_uLong nStart, sal_uLong nEnd, sal_uInt8 nTTyp)
Set the pCurPam appropriately and call WriteText().
Definition: wrtww8.cxx:1824
sal_uInt8 rtl_TextEncodingToWinCharset(rtl_TextEncoding eTextEncoding)
MSOffice appears to set the charset of unicode fonts to MS 932.
sal_uInt32 DateTime2DTTM(const DateTime &rDT)
Convert from DTTM to Writer's DateTime.
const o3tl::enumarray< SvxAdjust, unsigned short > aSvxToUnoAdjust USHRT_MAX
Definition: unosett.cxx:261
const SwNumRuleTable & GetNumRuleTable() const
Definition: doc.hxx:1055
Marginalia.
Definition: poolfmt.hxx:258
bool bLoadAllFonts
If true, all fonts are loaded before processing the document.
Definition: wrtww8.hxx:341
FAMILY_SWISS
sal_Int32 m_lcbSttbfffn
Definition: ww8scan.hxx:1295
bool WriteKFText(WW8Export &rWrt)
Definition: wrtw8sty.cxx:1770
const HdFtFlags WW8_HEADER_FIRST
Definition: ww8scan.hxx:1593
SwFootnoteNum eNum
Definition: ftninfo.hxx:97
Document Properties.
Definition: ww8scan.hxx:1598
sal_uInt16 Count() const
Definition: wrtw8sty.cxx:115
virtual ~WW8_WrPlcSepx() override
Definition: wrtw8sty.cxx:1032
void FontCharset(sal_uInt8 nCharSet, rtl_TextEncoding nEncoding) const
Font charset.
sal_uInt16 nFootnoteOffset
Definition: ftninfo.hxx:47
Item2Range GetItemSurrogates(sal_uInt16 nWhich) const
SVBT16 fnMpr
Definition: wrtw8sty.cxx:96
void WriteFootnoteBegin(const SwFormatFootnote &rFootnote, ww::bytes *pO=nullptr)
Definition: ww8atr.cxx:3320
WW8_WrPlc0(WW8_WrPlc0 const &)=delete
static void impl_SkipOdd(std::unique_ptr< ww::bytes > const &pO, std::size_t nTableStrmTell)
For WW8 only - extend pO so that the size of pTableStrm is even.
Definition: wrtw8sty.cxx:378
sal_uInt8 m_nTextTyp
Definition: wrtww8.hxx:540
WW8_Annotation(const SwPostItField *pPostIt, WW8_CP nRangeStart, WW8_CP nRangeEnd)
Definition: wrtw8sty.cxx:1939
void WriteSdrTextObj(const SdrTextObj &rObj, sal_uInt8 nTyp)
Definition: wrtw8esh.cxx:1327
void IncrementHdFtIndex()
Definition: wrtww8.hxx:1113
virtual void EmptyParagraph()=0
Empty paragraph.
sal_uInt16 GetId(const SvxFontItem &rFont)
Definition: wrtw8sty.cxx:885
sal_uInt64 Tell() const
FIB - the File Information Block.
Definition: ww8scan.hxx:1099
const SfxPoolItem & GetFormatAttr(sal_uInt16 nWhich, bool bInParents=true) const
If bInParents is FALSE, search only in this format for attribute.
Definition: format.cxx:379
void WriteSepx(SvStream &rStrm) const
Definition: wrtw8sty.cxx:1821
std::unique_ptr< WW8_WrPlc0 > pTextPos
Definition: wrtww8.hxx:251
virtual void StartSection() override
Start of the section properties.
Definition: wrtw8sty.cxx:1311
sal_uInt16 GetSlot(const SwFormat *pFormat) const
Get id of the style (rFormat).
Definition: wrtw8sty.cxx:172
WW8_CP m_ccpText
Definition: ww8scan.hxx:1204
sal_uInt16 fpc
Definition: ww8scan.hxx:1616
sal_uLong nOfs
Definition: wrtw8sty.cxx:108
bool IsPlausableSingleWordSection(const SwFrameFormat &rTitleFormat, const SwFrameFormat &rFollowFormat)
See if two page formats can be expressed as a single word section.
virtual void SectionBiDi(bool bBiDi)=0
Columns populated from right/numbers on the right side?
WW8_CP m_ccpFootnote
Definition: ww8scan.hxx:1205
std::vector< WW8_CP > aCps
Definition: wrtww8.hxx:247
SvStream & WriteChar(char nChar)
OUString m_sInitials
Definition: wrtww8.hxx:1230
Header, for PageFormats Client of FrameFormat describing the header.
Definition: fmthdft.hxx:33
static void InsUInt16(ww::bytes &rO, sal_uInt16 n)
Definition: wrtww8.cxx:1732
sal_uInt16 m_nLen
Definition: wrtw8sty.cxx:85
sal_uInt32 m_lcbHplxsdr
Definition: ww8scan.hxx:1512
void OutputStyleItemSet(const SfxItemSet &rSet, bool bTestForDefault)
Use OutputItem() on an item set - for styles.
Definition: ww8atr.cxx:5377
const SwAttrSet & GetSwAttrSet() const
Does node has already its own auto-attributes? Access to SwAttrSet.
Definition: node.hxx:723
const SwFormatContent & GetContent(bool=true) const
Definition: fmtcntnt.hxx:55
long GetRight() const
void InitFontTable(const SwDoc &rDoc)
rDoc used only to get the initial standard font(s) in use.
Definition: wrtw8sty.cxx:847
SwTableNode * FindTableNode()
Search table node, in which it is.
Definition: node.cxx:351
sal_uInt16 m_nUsedSlots
Definition: wrtww8.hxx:1548
OUString msAltNm
Definition: wrtww8.hxx:306
sal_uLong const nLnNumRestartNo
Definition: wrtww8.hxx:181
#define RES_PARATR_WIDOWS
Definition: hintids.hxx:165
OString const aName
#define RES_BOX
Definition: hintids.hxx:211
const sal_uInt16 * GetRanges() const
virtual void SectionLineNumbering(sal_uLong nRestartNo, const SwLineNumberInfo &rLnNumInfo)=0
Numbering of the lines in the document.
SVBT32 fcMpr
Definition: wrtw8sty.cxx:97
virtual bool ignoreAttributeForStyleDefaults(sal_uInt16) const
Used to filter out attributes that can be e.g. written to .doc but not to .docx.
Definition: wrtww8.hxx:667
SwNodeIndex * GetStartNode() const
Definition: txtftn.hxx:41
Line numbering.
Definition: poolfmt.hxx:126
SwFootnoteIdxs & GetFootnoteIdxs()
Definition: doc.hxx:628
const SwFormat * m_pCurrentStyle
Definition: wrtww8.hxx:531
Base class for WW8Export and DocxExport.
Definition: wrtww8.hxx:452
bool IsTableNode() const
Definition: node.hxx:640
Subgroup index tables.
Definition: poolfmt.hxx:367
WW8_FC m_fcStshfOrig
Definition: ww8scan.hxx:1239
virtual void StartStyle(const OUString &rName, StyleType eType, sal_uInt16 nBase, sal_uInt16 nNext, sal_uInt16 nWwId, sal_uInt16 nId, bool bAutoUpdate)=0
Start of a style in the styles table.
Subgroup table of contents.
Definition: poolfmt.hxx:374
virtual void WriteHeadersFooters(sal_uInt8 nHeadFootFlags, const SwFrameFormat &rFormat, const SwFrameFormat &rLeftFormat, const SwFrameFormat &rFirstPageFormat, sal_uInt8 nBreakCode)=0
Output the actual headers and footers.
SwSectionNode * GetSectionNode()
Definition: node.hxx:607
virtual void StartStyles()=0
Start of the styles table.
virtual void WriteHeadersFooters(sal_uInt8 nHeadFootFlags, const SwFrameFormat &rFormat, const SwFrameFormat &rLeftFormat, const SwFrameFormat &rFirstPageFormat, sal_uInt8 nBreakCode) override
Output the actual headers and footers.
Definition: wrtw8sty.cxx:1481
virtual void SectionPageBorders(const SwFrameFormat *pFormat, const SwFrameFormat *pFirstPageFormat) override
Description of the page borders.
Definition: wrtw8sty.cxx:1371
const SfxItemSet * m_pISet
Definition: wrtww8.hxx:459
bool IsFirstShared() const
Definition: pagedesc.cxx:375
void WriteOutliner(const OutlinerParaObject &rOutliner, sal_uInt8 nTyp)
Definition: wrtw8esh.cxx:1355
SectionType GetType() const
Definition: section.hxx:171
static bool NoPageBreakSection(const SfxItemSet *pSet)
Definition: wrtw8nds.cxx:3041
const SwAttrSet & GetAttrSet() const
For querying the attribute array.
Definition: format.hxx:116
std::map< const OUString, std::pair< WW8_CP, bool > > m_aRangeStartPositions
Definition: wrtww8.hxx:1247
const OUString & GetInitials() const
Definition: docufld.hxx:484
SwSection * GetSection() const
Definition: section.cxx:675
FontPitch const mePitch
Definition: wrtww8.hxx:308
#define RES_PAGEDESC
Definition: hintids.hxx:198
MSWordSections(const MSWordSections &)
index of authorities.
Definition: poolfmt.hxx:408
sal_Int32 WW8_FC
Definition: ww8struc.hxx:152
sal_uInt8 maWW8_FFN[6]
Definition: wrtww8.hxx:304
static void WriteLong(SvStream &rStrm, sal_Int32 nVal)
Definition: wrtww8.hxx:940
static void FillCount(SvStream &rStrm, sal_uLong nCount)
Definition: wrtww8.cxx:954
std::set< const SwRedlineData * > maProcessedRedlines
Definition: wrtww8.hxx:1245
virtual void TextVerticalAdjustment(const css::drawing::TextVerticalAdjust)
WW8_CP m_ccpHdr
Definition: ww8scan.hxx:1206
const SwFootnoteInfo & GetFootnoteInfo() const
Definition: doc.hxx:624
const sal_uInt16 sprmSLnc
Definition: sprmids.hxx:546
SvxFrameDirection TrueFrameDirection(const SwFrameFormat &rFlyFormat) const
Right to left?
Definition: wrtw8nds.cxx:1594
static void InsAsString16(ww::bytes &rO, const OUString &rStr)
Definition: wrtww8.cxx:1750
SwDoc * m_pDoc
Definition: wrtww8.hxx:567
const SwEndNoteInfo & GetEndNoteInfo() const
Definition: doc.hxx:626
virtual void SectionType(sal_uInt8 nBreakCode) override
The type of breaking.
Definition: wrtw8sty.cxx:1428
sal_uInt16 nFootnote
Definition: ww8scan.hxx:1622
sal_Int32 m_lcbPlcfAtnbkl
Definition: ww8scan.hxx:1393
const SwFrameFormat * GetHeaderFormat() const
Definition: fmthdft.hxx:54
const HdFtFlags WW8_FOOTER_ODD
Definition: ww8scan.hxx:1592
sal_Int32 m_lcbPlcfAtnbkf
Definition: ww8scan.hxx:1390
const SwAttrPool & GetAttrPool() const
Definition: doc.hxx:1307
Doc. subtitle.
Definition: poolfmt.hxx:424
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
Definition: ndtxt.hxx:843
const sal_uInt16 sprmSFTitlePage
Definition: sprmids.hxx:540
const SwNode * pPDNd
Definition: wrtww8.hxx:180
std::unique_ptr< MSWordStyles > m_pStyles
Definition: wrtww8.hxx:494
OUString aQuoVadis
Definition: ftninfo.hxx:94
const HdFtFlags WW8_HEADER_EVEN
Definition: ww8scan.hxx:1589
const sal_uInt16 sprmSFPgnRestart
Definition: sprmids.hxx:544
void FontFamilyType(FontFamily eFamily) const
Font family.
Base class of the Writer document model elements.
Definition: node.hxx:79
const SvxNumberType & GetNumType() const
Definition: pagedesc.hxx:192