LibreOffice Module sw (master)  1
wrtw8esh.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 <memory>
21 #include <com/sun/star/embed/Aspects.hpp>
22 
23 #include <hintids.hxx>
24 
25 #include <officecfg/Office/Common.hxx>
26 #include <o3tl/any.hxx>
27 #include <com/sun/star/drawing/XShape.hpp>
28 #include <vcl/svapp.hxx>
29 #include <sot/storage.hxx>
30 #include <svl/itemiter.hxx>
31 #include <svl/stritem.hxx>
32 #include <svl/whiter.hxx>
33 #include <svx/svdobj.hxx>
34 #include <svx/svdotext.hxx>
35 #include <svx/svdpage.hxx>
36 #include <editeng/outlobj.hxx>
37 #include <editeng/editobj.hxx>
38 #include <editeng/brushitem.hxx>
39 #include <editeng/boxitem.hxx>
40 #include <editeng/lrspitem.hxx>
41 #include <editeng/ulspitem.hxx>
42 #include <editeng/fontitem.hxx>
43 #include <editeng/frmdiritem.hxx>
44 #include <editeng/flditem.hxx>
45 #include <editeng/shaditem.hxx>
46 #include <editeng/eeitem.hxx>
47 #include <editeng/formatbreakitem.hxx>
48 #include <svx/svdouno.hxx>
49 #include <svx/unoapi.hxx>
50 #include <svx/svdview.hxx>
51 #include <svx/unopage.hxx>
52 #include <fmtcnct.hxx>
53 #include <fmtanchr.hxx>
54 #include <fmtsrnd.hxx>
55 #include <fmtornt.hxx>
56 #include <fmtfsize.hxx>
57 #include <fmtfollowtextflow.hxx>
58 #include <frmfmt.hxx>
59 #include <fmtcntnt.hxx>
60 #include <ndindex.hxx>
61 #include <doc.hxx>
62 #include <drawdoc.hxx>
63 #include <IDocumentSettingAccess.hxx>
64 #include <IDocumentDrawModelAccess.hxx>
65 #include <pam.hxx>
66 #include <swrect.hxx>
67 #include <ndgrf.hxx>
68 #include <grfatr.hxx>
69 #include <ndole.hxx>
70 #include <pagedesc.hxx>
71 #include <poolfmt.hxx>
72 #include "ww8par.hxx"
73 #include <breakit.hxx>
74 #include <com/sun/star/i18n/XBreakIterator.hpp>
75 #include <com/sun/star/lang/XServiceInfo.hpp>
76 #include "attributeoutputbase.hxx"
77 #include "writerhelper.hxx"
78 #include "writerwordglue.hxx"
79 #include "wrtww8.hxx"
80 #include "escher.hxx"
81 #include <ndtxt.hxx>
82 #include "WW8FFData.hxx"
83 #include <com/sun/star/beans/XPropertySet.hpp>
84 #include <com/sun/star/form/XFormComponent.hpp>
85 #include <IDocumentStylePoolAccess.hxx>
86 #include <oox/ole/olehelper.hxx>
87 #include <fmturl.hxx>
88 #include <frameformats.hxx>
89 #include <sfx2/sfxsids.hrc>
90 #include <unotools/saveopt.hxx>
91 #include <o3tl/enumrange.hxx>
92 #include <o3tl/enumarray.hxx>
93 #include <sfx2/docfile.hxx>
94 #include <tools/UnitConversion.hxx>
95 
96 #include <algorithm>
97 
98 using ::editeng::SvxBorderLine;
99 using namespace com::sun::star;
100 using namespace sw::util;
101 using namespace sw::types;
102 using ::com::sun::star::beans::XPropertySet;
103 using ::com::sun::star::drawing::XShape;
104 
105 bool SwBasicEscherEx::IsRelUrl() const
106 {
107  bool bRelUrl = false;
108  SfxMedium * pMedium = rWrt.GetWriter().GetMedia();
109  if ( pMedium )
110  bRelUrl = pMedium->IsRemote()
111  ? officecfg::Office::Common::Save::URL::Internet::get()
112  : officecfg::Office::Common::Save::URL::FileSystem::get();
113  return bRelUrl;
114 }
115 
116 OUString SwBasicEscherEx::GetBasePath() const
117 {
118  OUString sDocUrl;
119  SfxMedium * pMedium = rWrt.GetWriter().GetMedia();
120  if (pMedium)
121  {
122  const SfxItemSet* pPItemSet = pMedium->GetItemSet();
123  if( pPItemSet )
124  {
125  const SfxStringItem* pPItem = dynamic_cast< const SfxStringItem* >( pPItemSet->GetItem( SID_FILE_NAME ) );
126  if ( pPItem )
127  sDocUrl = pPItem->GetValue();
128  }
129  }
130 
131  return sDocUrl.copy(0, sDocUrl.lastIndexOf('/') + 1);
132 }
133 
134 OUString SwBasicEscherEx::BuildFileName(sal_uInt16& rnLevel, bool& rbRel, const OUString& rUrl)
135 {
136  OUString aDosName( INetURLObject( rUrl ).getFSysPath( FSysStyle::Dos ) );
137  rnLevel = 0;
138  rbRel = IsRelUrl();
139 
140  if (rbRel)
141  {
142  // try to convert to relative file name
143  OUString aTmpName( aDosName );
144  aDosName = INetURLObject::GetRelURL( GetBasePath(), rUrl,
145  INetURLObject::EncodeMechanism::WasEncoded, INetURLObject::DecodeMechanism::WithCharset );
146 
147  if (aDosName.startsWith(INET_FILE_SCHEME))
148  {
149  // not converted to rel -> back to old, return absolute flag
150  aDosName = aTmpName;
151  rbRel = false;
152  }
153  else if (aDosName.startsWith("./"))
154  {
155  aDosName = aDosName.copy(2);
156  }
157  else
158  {
159  while (aDosName.startsWith("../"))
160  {
161  ++rnLevel;
162  aDosName = aDosName.copy(3);
163  }
164  }
165  }
166  return aDosName;
167 }
168 
169 void SwBasicEscherEx::WriteHyperlinkWithinFly( SvMemoryStream& rStrm, const SwFormatURL* pINetFormatArg)
170 {
171  if ( !pINetFormatArg ) return;
172 
173  const sal_uInt8 aGuidStdLink[ 16 ] ={
174  0xD0, 0xC9, 0xEA, 0x79, 0xF9, 0xBA, 0xCE, 0x11, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B };
175  const sal_uInt8 aGuidUrlMoniker[ 16 ] = {
176  0xE0, 0xC9, 0xEA, 0x79, 0xF9, 0xBA, 0xCE, 0x11, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B };
177 
178  const sal_uInt8 aGuidFileMoniker[ 16 ] = {
179  0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 };
180  const sal_uInt8 aGuidFileTail[] = {
181  0xFF, 0xFF, 0xAD, 0xDE, 0x00, 0x00, 0x00, 0x00,
182  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
183  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
184  };
185  //const sal_uInt18 WW8_ID_HLINK = 0x01B8;
186  constexpr sal_uInt32 WW8_HLINK_BODY = 0x00000001;
187  constexpr sal_uInt32 WW8_HLINK_ABS = 0x00000002;
188  //const sal_uInt32 WW8_HLINK_DESCR = 0x00000014; /// Description.
189  constexpr sal_uInt32 WW8_HLINK_MARK = 0x00000008;
190  constexpr sal_uInt32 WW8_HLINK_FRAME = 0x00000080;
191  //const sal_uInt32 WW8_HLINK_UNC = 0x00000100; /// UNC path.
192  SvMemoryStream tmpStrm;
193  OUString tmpTextMark;
194 
195  OUString rUrl = pINetFormatArg->GetURL();
196  OUString rTarFrame = pINetFormatArg->GetTargetFrameName();
197  sal_uInt32 nFlags = 0;
198 
199  INetURLObject aUrlObj( rUrl );
200  const INetProtocol eProtocol = aUrlObj.GetProtocol();
201 
202  //Target Frame
203  if (!rTarFrame.isEmpty())
204  {
205  SwWW8Writer::WriteLong(tmpStrm, rTarFrame.getLength()+1);
206  SwWW8Writer::WriteString16(tmpStrm, rTarFrame, false);
207 
208  tmpStrm.WriteUInt16( 0 );
209 
210  nFlags |= WW8_HLINK_FRAME;
211  }
212 
213  // file link or URL
214  if (eProtocol == INetProtocol::File || (eProtocol == INetProtocol::NotValid && rUrl[0] != '#'))
215  {
216  sal_uInt16 nLevel;
217  bool bRel;
218  OUString aFileName( BuildFileName( nLevel, bRel, rUrl ));
219 
220  if( !bRel )
221  nFlags |= WW8_HLINK_ABS;
222 
223  nFlags |= WW8_HLINK_BODY;
224 
225  tmpStrm.WriteBytes(aGuidFileMoniker, sizeof(aGuidFileMoniker));
226  tmpStrm.WriteUInt16( nLevel );
227  SwWW8Writer::WriteLong(tmpStrm, aFileName.getLength()+1);
228  SwWW8Writer::WriteString8( tmpStrm, aFileName, true, RTL_TEXTENCODING_MS_1252 );
229  tmpStrm.WriteBytes(aGuidFileTail, sizeof(aGuidFileTail));
230 
231  //For UNICODE
232  SwWW8Writer::WriteLong(tmpStrm, 2*aFileName.getLength()+6);
233  SwWW8Writer::WriteLong(tmpStrm, 2*aFileName.getLength());
234  tmpStrm.WriteUInt16( 0x0003 );
235  SwWW8Writer::WriteString16(tmpStrm, aFileName, false);
236  }
237  else if( eProtocol != INetProtocol::NotValid )
238  {
239  tmpStrm.WriteBytes(aGuidUrlMoniker, sizeof(aGuidUrlMoniker));
240  SwWW8Writer::WriteLong(tmpStrm, 2*(rUrl.getLength()+1));
241 
242  SwWW8Writer::WriteString16(tmpStrm, rUrl, true);
243  nFlags |= WW8_HLINK_BODY | WW8_HLINK_ABS;
244  }
245  else if (rUrl[0] == '#' )
246  {
247  OUString aTextMark(rUrl.copy( 1 ));
248  aTextMark = aTextMark.replaceFirst(".", "!");
249  tmpTextMark = aTextMark;
250  }
251 
252  if (tmpTextMark.isEmpty() && aUrlObj.HasMark())
253  {
254  tmpTextMark = aUrlObj.GetMark();
255  }
256 
257  if (!tmpTextMark.isEmpty())
258  {
259  SwWW8Writer::WriteLong(tmpStrm, tmpTextMark.getLength()+1);
260  SwWW8Writer::WriteString16(tmpStrm, tmpTextMark, true);
261 
262  nFlags |= WW8_HLINK_MARK;
263  }
264 
265  rStrm.WriteBytes(aGuidStdLink, 16);
266  rStrm .WriteUInt32( 2 )
267  .WriteUInt32( nFlags );
268  tmpStrm.Seek( STREAM_SEEK_TO_BEGIN );
269  sal_uInt32 const nLen = tmpStrm.remainingSize();
270  if(nLen >0)
271  {
272  std::unique_ptr<sal_uInt8[]> pBuffer( new sal_uInt8[ nLen ] );
273  tmpStrm.ReadBytes(pBuffer.get(), nLen);
274  rStrm.WriteBytes(pBuffer.get(), nLen);
275  }
276 }
277 void SwBasicEscherEx::PreWriteHyperlinkWithinFly(const SwFrameFormat& rFormat,EscherPropertyContainer& rPropOpt)
278 {
279  const SfxPoolItem* pItem;
280  const SwAttrSet& rAttrSet = rFormat.GetAttrSet();
281  if (SfxItemState::SET != rAttrSet.GetItemState(RES_URL, true, &pItem))
282  return;
283 
284  const SwFormatURL *pINetFormat = dynamic_cast<const SwFormatURL*>(pItem);
285  if (!pINetFormat || pINetFormat->GetURL().isEmpty())
286  return;
287 
288  SvMemoryStream aStrm;
289  WriteHyperlinkWithinFly( aStrm, pINetFormat );
290  rPropOpt.AddOpt(ESCHER_Prop_pihlShape, true, 0, aStrm);
291  sal_uInt32 nValue;
292  OUString aNamestr = pINetFormat->GetName();
293  if (!aNamestr.isEmpty())
294  {
295  rPropOpt.AddOpt(ESCHER_Prop_wzName, aNamestr );
296  }
297  if(rPropOpt.GetOpt( ESCHER_Prop_fPrint, nValue))
298  {
299  nValue|=0x03080008;
300  rPropOpt.AddOpt(ESCHER_Prop_fPrint, nValue );
301  }
302  else
303  rPropOpt.AddOpt(ESCHER_Prop_fPrint, 0x03080008 );
304 }
305 
306 namespace
307 {
312  sal_uLong lcl_getSdrOrderNumber(const WW8Export& rWrt, DrawObj const *pObj)
313  {
314  return rWrt.GetSdrOrdNum(pObj->maContent.GetFrameFormat());
315  };
316 
319  class CompareDrawObjs
320  {
321  private:
322  const WW8Export& wrt;
323 
324  public:
325  explicit CompareDrawObjs(const WW8Export& rWrt) : wrt(rWrt) {};
326  bool operator()(DrawObj const *a, DrawObj const *b) const
327  {
328  sal_uLong aSort = lcl_getSdrOrderNumber(wrt, a);
329  sal_uLong bSort = lcl_getSdrOrderNumber(wrt, b);
330  return aSort < bSort;
331  }
332  };
333 
338  void lcl_makeZOrderArray(const WW8Export& rWrt,
339  std::vector<DrawObj> &rSrcArr,
340  std::vector<DrawObj*> &rDstArr)
341  {
342  rDstArr.clear();
343  rDstArr.reserve(rSrcArr.size());
344  for(DrawObj & i : rSrcArr)
345  {
346  rDstArr.push_back( &i );
347  }
348  std::sort(rDstArr.begin(), rDstArr.end(), CompareDrawObjs(rWrt));
349  }
350 
351 }
352 
353 // get a part fix for this type of element
354 bool WW8Export::MiserableFormFieldExportHack(const SwFrameFormat& rFrameFormat)
355 {
356  const SdrObject *pObject = rFrameFormat.FindRealSdrObject();
357  if (!pObject || pObject->GetObjInventor() != SdrInventor::FmForm)
358  return false;
359 
360  const SdrUnoObj *pFormObj = dynamic_cast< const SdrUnoObj* >(pObject);
361  if (!pFormObj)
362  return false;
363 
364  uno::Reference< awt::XControlModel > xControlModel =
365  pFormObj->GetUnoControlModel();
366  uno::Reference< lang::XServiceInfo > xInfo(xControlModel,
367  uno::UNO_QUERY);
368  uno::Reference<beans::XPropertySet> xPropSet(xControlModel, uno::UNO_QUERY);
369  if (!xInfo.is())
370  return false;
371 
372  if (xInfo->supportsService("com.sun.star.form.component.ComboBox"))
373  {
374  DoComboBox(xPropSet);
375  return true;
376  }
377 
378  return false;
379 }
380 
381 void WW8Export::DoComboBox(uno::Reference<beans::XPropertySet> const & xPropSet)
382 {
383  OUString sSelected;
384  uno::Sequence<OUString> aListItems;
385  xPropSet->getPropertyValue("StringItemList") >>= aListItems;
386  if (aListItems.hasElements())
387  {
388  uno::Any aTmp = xPropSet->getPropertyValue("DefaultText");
389  auto pStr = o3tl::tryAccess<OUString>(aTmp);
390  if (pStr)
391  sSelected = *pStr;
392  }
393 
394  OUString sName;
395  {
396  uno::Any aTmp = xPropSet->getPropertyValue("Name");
397  auto pStr = o3tl::tryAccess<OUString>(aTmp);
398  if (pStr)
399  sName = *pStr;
400  }
401 
402  OUString sHelp;
403  {
404  // property "Help" does not exist and due to the no-existence an exception is thrown.
405  try
406  {
407  uno::Any aTmp = xPropSet->getPropertyValue("HelpText");
408  auto pStr = o3tl::tryAccess<OUString>(aTmp);
409  if (pStr)
410  sHelp = *pStr;
411  }
412  catch( const uno::Exception& )
413  {}
414  }
415 
416  OUString sToolTip;
417  {
418  uno::Any aTmp = xPropSet->getPropertyValue("Name");
419  auto pStr = o3tl::tryAccess<OUString>(aTmp);
420  if (pStr)
421  sToolTip = *pStr;
422  }
423 
424  DoComboBox(sName, sHelp, sToolTip, sSelected, aListItems);
425 }
426 
427 void WW8Export::DoComboBox(const OUString &rName,
428  const OUString &rHelp,
429  const OUString &rToolTip,
430  const OUString &rSelected,
431  const uno::Sequence<OUString> &rListItems)
432 {
433  OutputField(nullptr, ww::eFORMDROPDOWN, FieldString(ww::eFORMDROPDOWN),
434  FieldFlags::Start | FieldFlags::CmdStart);
435  // write the reference to the "picture" structure
436  sal_uLong nDataStt = pDataStrm->Tell();
437  m_pChpPlc->AppendFkpEntry( Strm().Tell() );
438 
439  WriteChar( 0x01 );
440 
441  static sal_uInt8 aArr1[] =
442  {
443  0x03, 0x6a, 0,0,0,0, // sprmCPicLocation
444  0x06, 0x08, 0x01, // sprmCFData
445  0x55, 0x08, 0x01, // sprmCFSpec
446  0x02, 0x08, 0x01 // sprmCFFieldVanish
447  };
448  sal_uInt8* pDataAdr = aArr1 + 2;
449  Set_UInt32( pDataAdr, nDataStt );
450 
451  m_pChpPlc->AppendFkpEntry(Strm().Tell(), sizeof(aArr1), aArr1);
452 
453  OutputField(nullptr, ww::eFORMDROPDOWN, FieldString(ww::eFORMDROPDOWN),
454  FieldFlags::Close);
455 
456  ::sw::WW8FFData aFFData;
457 
458  aFFData.setType(2);
459  aFFData.setName(rName);
460  aFFData.setHelp(rHelp);
461  aFFData.setStatus(rToolTip);
462 
463  sal_uInt32 nListItems = rListItems.getLength();
464 
465  for (sal_uInt32 i = 0; i < nListItems; i++)
466  {
467  if (i < 0x20 && rSelected == rListItems[i])
468  aFFData.setResult(::sal::static_int_cast<sal_uInt8>(i));
469  aFFData.addListboxEntry(rListItems[i]);
470  }
471 
472  aFFData.Write(pDataStrm);
473 }
474 
475 void WW8Export::DoFormText(const SwInputField * pField)
476 {
477  OutputField(nullptr, ww::eFORMTEXT, FieldString(ww::eFORMTEXT),
478  FieldFlags::Start | FieldFlags::CmdStart);
479  // write the reference to the "picture" structure
480  sal_uLong nDataStt = pDataStrm->Tell();
481  m_pChpPlc->AppendFkpEntry( Strm().Tell() );
482 
483  WriteChar( 0x01 );
484  static sal_uInt8 aArr1[] = {
485  0x02, 0x08, 0x81, // sprmCFFieldVanish
486  0x03, 0x6a, 0,0,0,0, // sprmCPicLocation
487 
488  0x06, 0x08, 0x01, // sprmCFData
489  0x55, 0x08, 0x01 // sprmCFSpec
490  };
491  sal_uInt8* pDataAdr = aArr1 + 5;
492  Set_UInt32( pDataAdr, nDataStt );
493 
494  m_pChpPlc->AppendFkpEntry(Strm().Tell(),
495  sizeof( aArr1 ), aArr1 );
496 
497  ::sw::WW8FFData aFFData;
498 
499  aFFData.setType(0);
500  aFFData.setName(pField->GetPar2());
501  aFFData.setHelp(pField->GetHelp());
502  aFFData.setStatus(pField->GetToolTip());
503  aFFData.Write(pDataStrm);
504 
505  OutputField(nullptr, ww::eFORMTEXT, OUString(), FieldFlags::CmdEnd);
506 
507  const OUString fieldStr( pField->ExpandField(true, nullptr) );
508  SwWW8Writer::WriteString16(Strm(), fieldStr, false);
509 
510  static sal_uInt8 aArr2[] = {
511  0x55, 0x08, 0x01, // sprmCFSpec
512  0x75, 0x08, 0x01 // ???
513  };
514 
515  pDataAdr = aArr2 + 2;
516  Set_UInt32( pDataAdr, nDataStt );
517  m_pChpPlc->AppendFkpEntry(Strm().Tell(),
518  sizeof( aArr2 ), aArr2 );
519 
520  OutputField(nullptr, ww::eFORMTEXT, OUString(), FieldFlags::Close);
521 }
522 
523 PlcDrawObj::~PlcDrawObj()
524 {
525 }
526 
527 //It's irritating to have to change the RTL frames position into LTR ones
528 //so that word will have to place them in the right place. Doubly so that
529 //the SO drawings and writer frames have different ideas themselves as to
530 //how to be positioned when in RTL mode!
531 bool RTLGraphicsHack(SwTwips &rLeft, SwTwips nWidth,
532 sal_Int16 eHoriOri, sal_Int16 eHoriRel, SwTwips nPageLeft,
533  SwTwips nPageRight, SwTwips nPageSize)
534 {
535  bool bRet = false;
536  if (eHoriOri == text::HoriOrientation::NONE)
537  {
538  if (eHoriRel == text::RelOrientation::PAGE_FRAME)
539  {
540  rLeft = nPageSize - rLeft;
541  bRet = true;
542  }
543  else if (
544  (eHoriRel == text::RelOrientation::PAGE_PRINT_AREA) ||
545  (eHoriRel == text::RelOrientation::FRAME) ||
546  (eHoriRel == text::RelOrientation::PRINT_AREA)
547  )
548  {
549  rLeft = nPageSize - nPageLeft - nPageRight - rLeft;
550  bRet = true;
551  }
552  }
553  if (bRet)
554  rLeft -= nWidth;
555  return bRet;
556 }
557 
558 static bool RTLDrawingsHack(SwTwips &rLeft,
559  sal_Int16 eHoriOri, sal_Int16 eHoriRel, SwTwips nPageLeft,
560  SwTwips nPageRight, SwTwips nPageSize)
561 {
562  bool bRet = false;
563  if (eHoriOri == text::HoriOrientation::NONE)
564  {
565  if (eHoriRel == text::RelOrientation::PAGE_FRAME)
566  {
567  rLeft = nPageSize + rLeft;
568  bRet = true;
569  }
570  else if (
571  (eHoriRel == text::RelOrientation::PAGE_PRINT_AREA) ||
572  (eHoriRel == text::RelOrientation::FRAME) ||
573  (eHoriRel == text::RelOrientation::PRINT_AREA)
574  )
575  {
576  rLeft = nPageSize - nPageLeft - nPageRight + rLeft;
577  bRet = true;
578  }
579  }
580  return bRet;
581 }
582 
583 void WW8Export::MiserableRTLFrameFormatHack(SwTwips &rLeft, SwTwips &rRight,
584  const ww8::Frame &rFrameFormat)
585 {
586  //Require nasty bidi swap
587  if (SvxFrameDirection::Horizontal_RL_TB != m_rDoc.GetTextDirection(rFrameFormat.GetPosition()))
588  return;
589 
590  SwTwips nWidth = rRight - rLeft;
591  SwTwips nPageLeft, nPageRight;
592  SwTwips nPageSize = CurrentPageWidth(nPageLeft, nPageRight);
593 
594  const SwFormatHoriOrient& rHOr = rFrameFormat.GetFrameFormat().GetHoriOrient();
595 
596  bool bRet = false;
597  ww8::Frame::WriterSource eSource = rFrameFormat.GetWriterType();
598  if (eSource == ww8::Frame::eDrawing || eSource == ww8::Frame::eFormControl)
599  {
600  if (RTLDrawingsHack(rLeft, rHOr.GetHoriOrient(),
601  rHOr.GetRelationOrient(), nPageLeft, nPageRight, nPageSize))
602  {
603  bRet = true;
604  }
605  }
606  else
607  {
608  if (RTLGraphicsHack(rLeft, nWidth, rHOr.GetHoriOrient(),
609  rHOr.GetRelationOrient(), nPageLeft, nPageRight, nPageSize))
610  {
611  bRet = true;
612  }
613  }
614  if (bRet)
615  rRight = rLeft + nWidth;
616 }
617 
618 void PlcDrawObj::WritePlc( WW8Export& rWrt ) const
619 {
620  if (8 > rWrt.pFib->m_nVersion) // Cannot export drawobject in vers 7-
621  return;
622 
623  sal_uInt32 nFcStart = rWrt.pTableStrm->Tell();
624 
625  if (maDrawObjs.empty())
626  return;
627 
628  // write CPs
629  WW8Fib& rFib = *rWrt.pFib;
630  WW8_CP nCpOffs = GetCpOffset(rFib);
631 
632  for (const auto& rDrawObj : maDrawObjs)
633  SwWW8Writer::WriteLong(*rWrt.pTableStrm, rDrawObj.mnCp - nCpOffs);
634 
635  SwWW8Writer::WriteLong(*rWrt.pTableStrm, rFib.m_ccpText + rFib.m_ccpFootnote +
636  rFib.m_ccpHdr + rFib.m_ccpEdn + rFib.m_ccpTxbx + rFib.m_ccpHdrTxbx + 1);
637 
638  for (const auto& rDrawObj : maDrawObjs)
639  {
640  // write the fspa-struct
641  const ww8::Frame &rFrameFormat = rDrawObj.maContent;
642  const SwFrameFormat &rFormat = rFrameFormat.GetFrameFormat();
643  const SdrObject* pObj = rFormat.FindRealSdrObject();
644 
645  tools::Rectangle aRect;
646  SwFormatVertOrient rVOr = rFormat.GetVertOrient();
647  SwFormatHoriOrient rHOr = rFormat.GetHoriOrient();
648  // #i30669# - convert the positioning attributes.
649  // Most positions are converted, if layout information exists.
650  const bool bPosConverted =
651  WinwordAnchoring::ConvertPosition( rHOr, rVOr, rFormat );
652 
653  Point aObjPos;
654  bool bHasHeightWidthSwapped(false);
655  if (RES_FLYFRMFMT == rFormat.Which())
656  {
657  SwRect aLayRect(rFormat.FindLayoutRect(false, &aObjPos));
658  // the Object is not visible - so get the values from
659  // the format. The Position may not be correct.
660  if( aLayRect.IsEmpty() )
661  aRect.SetSize( rFormat.GetFrameSize().GetSize() );
662  else
663  {
664  // #i56090# Do not only consider the first client
665  // Note that we actually would have to find the maximum size of the
666  // frame format clients. However, this already should work in most cases.
667  const SwRect aSizeRect(rFormat.FindLayoutRect());
668  if ( aSizeRect.Width() > aLayRect.Width() )
669  aLayRect.Width( aSizeRect.Width() );
670 
671  aRect = aLayRect.SVRect();
672  }
673  }
674  else
675  {
676  OSL_ENSURE(pObj, "Where is the SDR-Object?");
677  if (pObj)
678  {
679  aRect = pObj->GetLogicRect();
680 
681  // rotating to vertical means swapping height and width as seen in SvxMSDffManager::ImportShape
682  const Degree100 nAngle = NormAngle36000( pObj->GetRotateAngle() );
683  const bool bAllowSwap = pObj->GetObjIdentifier() != OBJ_LINE && pObj->GetObjIdentifier() != OBJ_GRUP;
684  if ( bAllowSwap && (( nAngle > 4500_deg100 && nAngle <= 13500_deg100 ) || ( nAngle > 22500_deg100 && nAngle <= 31500_deg100 )) )
685  {
686  const tools::Long nWidth = aRect.getWidth();
687  const tools::Long nHeight = aRect.getHeight();
688  aRect.setWidth( nHeight );
689  aRect.setHeight( nWidth );
690  bHasHeightWidthSwapped = true;
691  }
692  }
693  }
694 
695  // #i30669# - use converted position, if conversion is performed.
696  // Unify position determination of Writer fly frames
697  // and drawing objects.
698  if ( bPosConverted )
699  {
700  aRect.SetPos( Point( rHOr.GetPos(), rVOr.GetPos() ) );
701  }
702  else
703  {
704  aRect -= rDrawObj.maParentPos;
705  aObjPos = aRect.TopLeft();
706  if (text::VertOrientation::NONE == rVOr.GetVertOrient())
707  {
708  // #i22673#
709  sal_Int16 eOri = rVOr.GetRelationOrient();
710  if (eOri == text::RelOrientation::CHAR || eOri == text::RelOrientation::TEXT_LINE)
711  aObjPos.setY( -rVOr.GetPos() );
712  else
713  aObjPos.setY( rVOr.GetPos() );
714  }
715  if (text::HoriOrientation::NONE == rHOr.GetHoriOrient())
716  aObjPos.setX( rHOr.GetPos() );
717  aRect.SetPos( aObjPos );
718  }
719 
720  sal_Int32 nThick = rDrawObj.mnThick;
721 
722  //If we are being exported as an inline hack, set
723  //corner to 0 and forget about border thickness for positioning
724  if (rFrameFormat.IsInline())
725  {
726  aRect.SetPos(Point(0,0));
727  nThick = 0;
728  }
729 
730  // spid
731  SwWW8Writer::WriteLong(*rWrt.pTableStrm, rDrawObj.mnShapeId);
732 
733  SwTwips nLeft = aRect.Left() + nThick;
734  SwTwips nRight = aRect.Right() - nThick;
735  SwTwips nTop = aRect.Top() + nThick;
736  SwTwips nBottom = aRect.Bottom() - nThick;
737 
738  // tdf#93675, 0 below line/paragraph and/or top line/paragraph with
739  // wrap top+bottom or other wraps is affecting the line directly
740  // above the anchor line, which seems odd, but a tiny adjustment
741  // here to bring the top down convinces msoffice to wrap like us
742  if (nTop == 0 && !rFrameFormat.IsInline() &&
743  rVOr.GetVertOrient() == text::VertOrientation::NONE &&
744  rVOr.GetRelationOrient() == text::RelOrientation::FRAME)
745  {
746  nTop = 8;
747  }
748 
749  //Nasty swap for bidi if necessary
750  rWrt.MiserableRTLFrameFormatHack(nLeft, nRight, rFrameFormat);
751 
752  // tdf#70838. Word relates the position to the unrotated rectangle,
753  // Writer to the rotated one. Because the rotation is around center,
754  // the difference counts half.
755  if(pObj && pObj->GetRotateAngle())
756  {
757  SwTwips nXOff;
758  SwTwips nYOff;
759  SwTwips nSnapWidth = pObj->GetSnapRect().getWidth();
760  SwTwips nSnapHeight = pObj->GetSnapRect().getHeight();
761  SwTwips nLogicWidth = pObj->GetLogicRect().getWidth();
762  SwTwips nLogicHeight = pObj->GetLogicRect().getHeight();
763  // +1 for to compensate integer arithmetic rounding errors
764  if(bHasHeightWidthSwapped)
765  {
766  nXOff = (nSnapWidth - nLogicHeight + 1) / 2;
767  nYOff = (nSnapHeight - nLogicWidth + 1) / 2;
768  }
769  else
770  {
771  nXOff = (nSnapWidth - nLogicWidth + 1) / 2;
772  nYOff = (nSnapHeight - nLogicHeight + 1) / 2;
773  }
774  nLeft += nXOff;
775  nRight += nXOff;
776  nTop += nYOff;
777  nBottom += nYOff;
778  }
779 
780  //xaLeft/yaTop/xaRight/yaBottom - rel. to anchor
781  //(most of) the border is outside the graphic is word, so
782  //change dimensions to fit
783  SwWW8Writer::WriteLong(*rWrt.pTableStrm, nLeft);
784  SwWW8Writer::WriteLong(*rWrt.pTableStrm, nTop);
785  SwWW8Writer::WriteLong(*rWrt.pTableStrm, nRight);
786  SwWW8Writer::WriteLong(*rWrt.pTableStrm, nBottom);
787 
788  //fHdr/bx/by/wr/wrk/fRcaSimple/fBelowText/fAnchorLock
789  sal_uInt16 nFlags=0;
790  //If nFlags isn't 0x14 its overridden by the escher properties
791  if (RndStdIds::FLY_AT_PAGE == rFormat.GetAnchor().GetAnchorId())
792  nFlags = 0x0000;
793  else
794  nFlags = 0x0014; // x-rel to text, y-rel to text
795 
796  const SwFormatSurround& rSurr = rFormat.GetSurround();
797  sal_uInt16 nContour = rSurr.IsContour() ? 0x0080 : 0x0040;
798  css::text::WrapTextMode eSurround = rSurr.GetSurround();
799 
800  /*
801  #i3958#
802  The inline elements being export as anchored to character inside
803  the shape field hack are required to be wrap through so as to flow
804  over the following dummy 0x01 graphic
805  */
806  if (rFrameFormat.IsInline())
807  eSurround = css::text::WrapTextMode_THROUGH;
808 
809  switch (eSurround)
810  {
811  case css::text::WrapTextMode_NONE:
812  nFlags |= 0x0020;
813  break;
814  case css::text::WrapTextMode_THROUGH:
815  nFlags |= 0x0060;
816  break;
817  case css::text::WrapTextMode_PARALLEL:
818  nFlags |= 0x0000 | nContour;
819  break;
820  case css::text::WrapTextMode_DYNAMIC:
821  nFlags |= 0x0600 | nContour;
822  break;
823  case css::text::WrapTextMode_LEFT:
824  nFlags |= 0x0200 | nContour;
825  break;
826  case css::text::WrapTextMode_RIGHT:
827  nFlags |= 0x0400 | nContour;
828  break;
829  default:
830  OSL_ENSURE(false, "Unsupported surround type for export");
831  break;
832  }
833  if (pObj && (pObj->GetLayer() == rWrt.m_rDoc.getIDocumentDrawModelAccess().GetHellId() ||
834  pObj->GetLayer() == rWrt.m_rDoc.getIDocumentDrawModelAccess().GetInvisibleHellId()))
835  {
836  nFlags |= 0x4000;
837  }
838 
839  /*
840  #i3958# Required to make this inline stuff work in WordXP, not
841  needed for 2003 interestingly
842  */
843  if (rFrameFormat.IsInline())
844  nFlags |= 0x8000;
845 
846  SwWW8Writer::WriteShort(*rWrt.pTableStrm, nFlags);
847 
848  // cTxbx
849  SwWW8Writer::WriteLong(*rWrt.pTableStrm, 0);
850  }
851 
852  RegisterWithFib(rFib, nFcStart, rWrt.pTableStrm->Tell() - nFcStart);
853 }
854 
855 void MainTextPlcDrawObj::RegisterWithFib(WW8Fib &rFib, sal_uInt32 nStart,
856  sal_uInt32 nLen) const
857 {
858  rFib.m_fcPlcfspaMom = nStart;
859  rFib.m_lcbPlcfspaMom = nLen;
860 }
861 
862 WW8_CP MainTextPlcDrawObj::GetCpOffset(const WW8Fib &) const
863 {
864  return 0;
865 }
866 
867 void HdFtPlcDrawObj::RegisterWithFib(WW8Fib &rFib, sal_uInt32 nStart,
868  sal_uInt32 nLen) const
869 {
870  rFib.m_fcPlcfspaHdr = nStart;
871  rFib.m_lcbPlcfspaHdr = nLen;
872 }
873 
874 WW8_CP HdFtPlcDrawObj::GetCpOffset(const WW8Fib &rFib) const
875 {
876  return rFib.m_ccpText + rFib.m_ccpFootnote;
877 }
878 
879 bool PlcDrawObj::Append( WW8Export const & rWrt, WW8_CP nCp, const ww8::Frame& rFormat,
880  const Point& rNdTopLeft )
881 {
882  bool bRet = false;
883  const SwFrameFormat &rFrameFormat = rFormat.GetFrameFormat();
884  if (TXT_HDFT == rWrt.m_nTextTyp || TXT_MAINTEXT == rWrt.m_nTextTyp)
885  {
886  if (RES_FLYFRMFMT == rFrameFormat.Which())
887  {
888  // check for textflyframe and if it is the first in a Chain
889  if (rFrameFormat.GetContent().GetContentIdx())
890  bRet = true;
891  }
892  else
893  bRet = true;
894  }
895 
896  if (bRet)
897  {
898  DrawObj aObj(rFormat, nCp, rNdTopLeft, rWrt.TrueFrameDirection(rFrameFormat),
899  rWrt.GetHdFtIndex());
900  maDrawObjs.push_back(aObj);
901  }
902  return bRet;
903 }
904 
905 void DrawObj::SetShapeDetails(sal_uInt32 nId, sal_Int32 nThick)
906 {
907  mnShapeId = nId;
908  mnThick = nThick;
909 }
910 
911 bool WW8_WrPlcTextBoxes::WriteText( WW8Export& rWrt )
912 {
913  rWrt.m_bInWriteEscher = true;
914  WW8_CP& rccp=TXT_TXTBOX == nTyp ? rWrt.pFib->m_ccpTxbx : rWrt.pFib->m_ccpHdrTxbx;
915 
916  bool bRet = WriteGenericText( rWrt, nTyp, rccp );
917 
918  WW8_CP nCP = rWrt.Fc2Cp( rWrt.Strm().Tell() );
919  WW8Fib& rFib = *rWrt.pFib;
920  WW8_CP nMyOffset = rFib.m_ccpText + rFib.m_ccpFootnote + rFib.m_ccpHdr + rFib.m_ccpAtn
921  + rFib.m_ccpEdn;
922  if( TXT_TXTBOX == nTyp )
923  rWrt.m_pFieldTextBxs->Finish( nCP, nMyOffset );
924  else
925  rWrt.m_pFieldHFTextBxs->Finish( nCP, nMyOffset + rFib.m_ccpTxbx );
926  rWrt.m_bInWriteEscher = false;
927  return bRet;
928 }
929 
930 void WW8_WrPlcTextBoxes::Append( const SdrObject& rObj, sal_uInt32 nShapeId )
931 {
932  aContent.push_back( &rObj );
933  aShapeIds.push_back( nShapeId );
934  //save NULL, if we have an actual SdrObject
935  aSpareFormats.push_back(nullptr);
936 }
937 
938 void WW8_WrPlcTextBoxes::Append( const SwFrameFormat* pFormat, sal_uInt32 nShapeId )
939 {
940  //no sdr object, we insert a NULL in the aContent and save the real fmt in aSpareFormats.
941  aContent.push_back( nullptr );
942  aShapeIds.push_back( nShapeId );
943  aSpareFormats.push_back(pFormat);
944 }
945 
946 const std::vector<sal_uInt32>* WW8_WrPlcTextBoxes::GetShapeIdArr() const
947 {
948  return &aShapeIds;
949 }
950 
951 sal_uInt32 WW8Export::GetSdrOrdNum( const SwFrameFormat& rFormat ) const
952 {
953  sal_uInt32 nOrdNum;
954  const SdrObject* pObj = rFormat.FindRealSdrObject();
955  if( pObj )
956  nOrdNum = pObj->GetOrdNum();
957  else
958  {
959  // no Layout for this format, then recalc the ordnum
960  SwFrameFormat* pFormat = const_cast<SwFrameFormat*>(&rFormat);
961  nOrdNum = std::distance(m_rDoc.GetSpzFrameFormats()->begin(),
962  m_rDoc.GetSpzFrameFormats()->find( pFormat ) );
963 
964  const SwDrawModel* pModel = m_rDoc.getIDocumentDrawModelAccess().GetDrawModel();
965  if( pModel )
966  nOrdNum += pModel->GetPage( 0 )->GetObjCount();
967  }
968  return nOrdNum;
969 }
970 
971 void WW8Export::AppendFlyInFlys(const ww8::Frame& rFrameFormat,
972  const Point& rNdTopLeft)
973 {
974  OSL_ENSURE(!m_pEscher, "the EscherStream was already written!");
975  if (m_pEscher)
976  return ;
977  PlcDrawObj *pDrwO;
978  if (TXT_HDFT == m_nTextTyp)
979  pDrwO = m_pHFSdrObjs.get();
980  else
981  pDrwO = m_pSdrObjs.get();
982 
983  if (rFrameFormat.IsInline())
984  {
985  OutputField(nullptr, ww::eSHAPE, FieldString(ww::eSHAPE),
986  FieldFlags::Start | FieldFlags::CmdStart | FieldFlags::CmdEnd);
987  }
988 
989  WW8_CP nCP = Fc2Cp(Strm().Tell());
990  bool bSuccess = pDrwO->Append(*this, nCP, rFrameFormat, rNdTopLeft);
991  OSL_ENSURE(bSuccess, "Couldn't export a graphical element!");
992 
993  if (bSuccess)
994  {
995  static const sal_uInt8 aSpec8[] =
996  {
997  0x03, 0x6a, 0, 0, 0, 0, // sprmCObjLocation
998  0x55, 0x08, 1 // sprmCFSpec
999  };
1000  // fSpec-Attribute true
1001 
1002  // A special character is required in the text for DrawObjects,
1003  // therefore a fSpec-Attribute
1004  m_pChpPlc->AppendFkpEntry( Strm().Tell() );
1005  WriteChar( 0x8 );
1006  m_pChpPlc->AppendFkpEntry( Strm().Tell(), sizeof( aSpec8 ), aSpec8 );
1007 
1008  //Need dummy picture frame
1009  if (rFrameFormat.IsInline())
1010  OutGrf(rFrameFormat);
1011  }
1012 
1013  if (rFrameFormat.IsInline())
1014  OutputField(nullptr, ww::eSHAPE, OUString(), FieldFlags::Close);
1015 }
1016 
1017 MSWord_SdrAttrIter::MSWord_SdrAttrIter( MSWordExportBase& rWr,
1018  const EditTextObject& rEditObj, sal_uInt8 nTyp )
1019  : MSWordAttrIter( rWr ), pEditObj(&rEditObj), pEditPool(nullptr), mnTyp(nTyp)
1020 {
1021  NextPara( 0 );
1022 }
1023 
1024 void MSWord_SdrAttrIter::NextPara( sal_Int32 nPar )
1025 {
1026  nPara = nPar;
1027  // Ignore change of attribute at position 0, because we expect that
1028  // the attributes are outputted at start of a paragraph anyway.
1029  aChrTextAtrArr.clear();
1030  aChrSetArr.clear();
1031  nCurrentSwPos = nTmpSwPos = 0;
1032 
1033  SfxItemSet aSet( pEditObj->GetParaAttribs( nPara ));
1034  pEditPool = aSet.GetPool();
1035  eNdChrSet = ItemGet<SvxFontItem>(aSet,EE_CHAR_FONTINFO).GetCharSet();
1036 
1037  assert(g_pBreakIt && g_pBreakIt->GetBreakIter().is());
1038  nScript = g_pBreakIt->GetBreakIter()->getScriptType( pEditObj->GetText(nPara), 0);
1039 
1040  pEditObj->GetCharAttribs( nPara, aTextAtrArr );
1041  nCurrentSwPos = SearchNext( 1 );
1042 }
1043 
1044 rtl_TextEncoding MSWord_SdrAttrIter::GetNextCharSet() const
1045 {
1046  if( !aChrSetArr.empty() )
1047  return aChrSetArr.back();
1048  return eNdChrSet;
1049 }
1050 
1051 // the first parameter in SearchNext() returns if it's a TextAtr
1052 sal_Int32 MSWord_SdrAttrIter::SearchNext( sal_Int32 nStartPos )
1053 {
1054  sal_Int32 nMinPos = SAL_MAX_INT32;
1055  for(const auto& rTextAtr : aTextAtrArr)
1056  {
1057  sal_Int32 nPos = rTextAtr.nStart; // first character attribute
1058  if( nPos >= nStartPos && nPos <= nMinPos )
1059  {
1060  nMinPos = nPos;
1061  SetCharSet(rTextAtr, true);
1062  }
1063 
1064  nPos = rTextAtr.nEnd; // last character attribute + 1
1065  if( nPos >= nStartPos && nPos < nMinPos )
1066  {
1067  nMinPos = nPos;
1068  SetCharSet(rTextAtr, false);
1069  }
1070  }
1071  return nMinPos;
1072 }
1073 
1074 void MSWord_SdrAttrIter::SetCharSet(const EECharAttrib& rAttr, bool bStart)
1075 {
1076  const SfxPoolItem& rItem = *rAttr.pAttr;
1077  if( rItem.Which() != EE_CHAR_FONTINFO )
1078  {
1079  return;
1080  }
1081 
1082  if( bStart )
1083  {
1084  rtl_TextEncoding eChrSet = static_cast<const SvxFontItem&>(rItem).GetCharSet();
1085  aChrSetArr.push_back( eChrSet );
1086  aChrTextAtrArr.push_back( &rAttr );
1087  }
1088  else
1089  {
1090  std::vector<const EECharAttrib*>::iterator it =
1091  std::find( aChrTextAtrArr.begin(), aChrTextAtrArr.end(), &rAttr );
1092  if ( it != aChrTextAtrArr.end() )
1093  {
1094  aChrSetArr.erase( aChrSetArr.begin() + (it - aChrTextAtrArr.begin()) );
1095  aChrTextAtrArr.erase( it );
1096  }
1097  }
1098 }
1099 
1100 void MSWord_SdrAttrIter::OutEEField(const SfxPoolItem& rHt)
1101 {
1102  const SvxFieldItem &rField = static_cast<const SvxFieldItem &>(rHt);
1103  const SvxFieldData *pField = rField.GetField();
1104  if (auto pURL = dynamic_cast< const SvxURLField *>( pField ))
1105  {
1106  sal_uInt8 nOldTextTyp = m_rExport.m_nTextTyp;
1107  m_rExport.m_nTextTyp = mnTyp;
1108  m_rExport.AttrOutput().StartURL( pURL->GetURL(), pURL->GetTargetFrame() );
1109 
1110  const OUString &rStr = pURL->GetRepresentation();
1111  m_rExport.AttrOutput().RawText(rStr, GetNodeCharSet());
1112 
1113  m_rExport.AttrOutput().EndURL(false);
1114  m_rExport.m_nTextTyp = nOldTextTyp;
1115  }
1116 }
1117 
1118 void MSWord_SdrAttrIter::OutAttr( sal_Int32 nSwPos )
1119 {
1120  //Collect the which ids belong to the run that we will export after
1121  //outputting the underlying paragraph attributes. We will exclude
1122  //writing these from the underlying paragraph attributes to avoid
1123  //duplicate attributes in docx export. Doesn't matter in doc
1124  //export as later props just override earlier ones.
1125  std::set<sal_uInt16> aUsedRunWhichs;
1126  for(const auto& rTextAtr : aTextAtrArr)
1127  {
1128  if (nSwPos >= rTextAtr.nStart && nSwPos < rTextAtr.nEnd)
1129  {
1130  sal_uInt16 nWhich = rTextAtr.pAttr->Which();
1131  aUsedRunWhichs.insert(nWhich);
1132  }
1133 
1134  if( nSwPos < rTextAtr.nStart )
1135  break;
1136  }
1137 
1138  OutParaAttr(true, &aUsedRunWhichs);
1139 
1140  if (aTextAtrArr.empty())
1141  return;
1142 
1143  const sw::BroadcastingModify* pOldMod = m_rExport.m_pOutFormatNode;
1144  m_rExport.m_pOutFormatNode = nullptr;
1145 
1146  const SfxItemPool* pSrcPool = pEditPool;
1147  const SfxItemPool& rDstPool = m_rExport.m_rDoc.GetAttrPool();
1148 
1149  nTmpSwPos = nSwPos;
1150  // Did we already produce a <w:sz> element?
1151  m_rExport.m_bFontSizeWritten = false;
1152  for(const auto& rTextAtr : aTextAtrArr)
1153  {
1154  if (nSwPos >= rTextAtr.nStart && nSwPos < rTextAtr.nEnd)
1155  {
1156  sal_uInt16 nWhich = rTextAtr.pAttr->Which();
1157  if (nWhich == EE_FEATURE_FIELD)
1158  {
1159  OutEEField(*(rTextAtr.pAttr));
1160  continue;
1161  }
1162  if (nWhich == EE_FEATURE_TAB)
1163  {
1164  m_rExport.WriteChar(0x9);
1165  continue;
1166  }
1167 
1168  const sal_uInt16 nSlotId = pSrcPool->GetSlotId(nWhich);
1169  if (nSlotId && nWhich != nSlotId)
1170  {
1171  nWhich = rDstPool.GetWhich(nSlotId);
1172  if (nWhich && nWhich != nSlotId &&
1173  nWhich < RES_UNKNOWNATR_BEGIN &&
1174  m_rExport.CollapseScriptsforWordOk(nScript,nWhich))
1175  {
1176  // use always the SW-Which Id !
1177  std::unique_ptr<SfxPoolItem> pI(rTextAtr.pAttr->Clone());
1178  pI->SetWhich( nWhich );
1179  // Will this item produce a <w:sz> element?
1180  bool bFontSizeItem = nWhich == RES_CHRATR_FONTSIZE || nWhich == RES_CHRATR_CJK_FONTSIZE;
1181  if (!m_rExport.m_bFontSizeWritten || !bFontSizeItem)
1182  m_rExport.AttrOutput().OutputItem( *pI );
1183  if (bFontSizeItem)
1184  m_rExport.m_bFontSizeWritten = true;
1185  }
1186  }
1187  }
1188 
1189  if( nSwPos < rTextAtr.nStart )
1190  break;
1191  }
1192  m_rExport.m_bFontSizeWritten = false;
1193 
1194  nTmpSwPos = 0; // HasTextItem only allowed in the above area
1195  m_rExport.m_pOutFormatNode = pOldMod;
1196 }
1197 
1198 bool MSWord_SdrAttrIter::IsTextAttr(sal_Int32 nSwPos)
1199 {
1200  return std::any_of(aTextAtrArr.begin(), aTextAtrArr.end(),
1201  [nSwPos](const EECharAttrib& rTextAtr) {
1202  return (nSwPos >= rTextAtr.nStart && nSwPos < rTextAtr.nEnd) &&
1203  (rTextAtr.pAttr->Which() == EE_FEATURE_FIELD ||
1204  rTextAtr.pAttr->Which() == EE_FEATURE_TAB);
1205  }
1206  );
1207 }
1208 
1209 // HasItem is used for the consolidation of the double attribute Underline and
1210 // WordLineMode as a TextItem. OutAttr() calls the output function, which can
1211 // query for other items at the start position of attribute via HasItem().
1212 // Only attributes with an end can be queried.
1213 // The search is done with bDeep.
1214 const SfxPoolItem* MSWord_SdrAttrIter::HasTextItem(sal_uInt16 nWhich) const
1215 {
1216  nWhich = sw::hack::TransformWhichBetweenPools(*pEditPool,
1217  m_rExport.m_rDoc.GetAttrPool(), nWhich);
1218  if (nWhich)
1219  {
1220  for (const auto& rTextAtr : aTextAtrArr)
1221  {
1222  if (nWhich == rTextAtr.pAttr->Which() && nTmpSwPos >= rTextAtr.nStart && nTmpSwPos < rTextAtr.nEnd)
1223  return rTextAtr.pAttr; // Found
1224  if (nTmpSwPos < rTextAtr.nStart)
1225  return nullptr;
1226  }
1227  }
1228  return nullptr;
1229 }
1230 
1231 const SfxPoolItem& MSWord_SdrAttrIter::GetItem( sal_uInt16 nWhich ) const
1232 {
1233  using sw::hack::GetSetWhichFromSwDocWhich;
1234  const SfxPoolItem* pRet = HasTextItem(nWhich);
1235  if (!pRet)
1236  {
1237  SfxItemSet aSet(pEditObj->GetParaAttribs(nPara));
1238  nWhich = GetSetWhichFromSwDocWhich(aSet, m_rExport.m_rDoc, nWhich);
1239  OSL_ENSURE(nWhich, "Impossible, catastrophic failure imminent");
1240  pRet = &aSet.Get(nWhich);
1241  }
1242  return *pRet;
1243 }
1244 
1245 //Drawing shapes properties inherit from a different pool that the document
1246 //styles. On export to .doc[x] they will default to style "Normal". Here explicitly
1247 //set any items which are not already set, but differ from "Normal".
1248 void MSWord_SdrAttrIter::SetItemsThatDifferFromStandard(bool bCharAttr, SfxItemSet& rSet)
1249 {
1250  SwTextFormatColl* pC = m_rExport.m_rDoc.getIDocumentStylePoolAccess().GetTextCollFromPool
1251  (RES_POOLCOLL_STANDARD, false);
1252 
1253  SfxWhichIter aWhichIter(rSet);
1254  for (sal_uInt16 nEEWhich = aWhichIter.FirstWhich(); nEEWhich; nEEWhich = aWhichIter.NextWhich())
1255  {
1256  if (SfxItemState::SET != rSet.GetItemState(nEEWhich, false))
1257  {
1258  sal_uInt16 nSwWhich = sw::hack::TransformWhichBetweenPools(m_rExport.m_rDoc.GetAttrPool(),
1259  *pEditPool, nEEWhich);
1260  if (!nSwWhich)
1261  continue;
1262  bool bWanted = ( bCharAttr ? ( nSwWhich >= RES_CHRATR_BEGIN && nSwWhich < RES_TXTATR_END )
1263  : ( nSwWhich >= RES_PARATR_BEGIN && nSwWhich < RES_FRMATR_END ) );
1264  if (!bWanted)
1265  continue;
1266 
1267  const SfxPoolItem& rDrawItem = rSet.Get(nEEWhich);
1268  const SfxPoolItem& rStandardItem = pC->GetFormatAttr(nSwWhich);
1269  if (rDrawItem != rStandardItem)
1270  rSet.Put(rDrawItem);
1271  }
1272  }
1273 }
1274 
1275 void MSWord_SdrAttrIter::OutParaAttr(bool bCharAttr, const std::set<sal_uInt16>* pWhichsToIgnore)
1276 {
1277  SfxItemSet aSet( pEditObj->GetParaAttribs( nPara ));
1278 
1279  SetItemsThatDifferFromStandard(bCharAttr, aSet);
1280 
1281  if (!aSet.Count())
1282  return;
1283 
1284  const SfxItemSet* pOldSet = m_rExport.GetCurItemSet();
1285  m_rExport.SetCurItemSet( &aSet );
1286 
1287  SfxItemIter aIter( aSet );
1288  const SfxPoolItem* pItem = aIter.GetCurItem();
1289 
1290  const SfxItemPool* pSrcPool = pEditPool,
1291  * pDstPool = &m_rExport.m_rDoc.GetAttrPool();
1292 
1293  do
1294  {
1295  sal_uInt16 nWhich = pItem->Which();
1296  if (pWhichsToIgnore && pWhichsToIgnore->find(nWhich) != pWhichsToIgnore->end())
1297  continue;
1298 
1299  sal_uInt16 nSlotId = pSrcPool->GetSlotId(nWhich);
1300 
1301  if ( nSlotId && nWhich != nSlotId &&
1302  0 != ( nWhich = pDstPool->GetWhich( nSlotId ) ) &&
1303  nWhich != nSlotId &&
1304  ( bCharAttr ? ( nWhich >= RES_CHRATR_BEGIN && nWhich < RES_TXTATR_END )
1305  : ( nWhich >= RES_PARATR_BEGIN && nWhich < RES_FRMATR_END ) ) )
1306  {
1307  // use always the SW-Which Id !
1308  std::unique_ptr<SfxPoolItem> pI(pItem->Clone());
1309  pI->SetWhich( nWhich );
1310  if (m_rExport.CollapseScriptsforWordOk(nScript,nWhich))
1311  m_rExport.AttrOutput().OutputItem(*pI);
1312  }
1313  } while ((pItem = aIter.NextItem()));
1314  m_rExport.SetCurItemSet( pOldSet );
1315 }
1316 
1317 void WW8Export::WriteSdrTextObj(const SdrTextObj& rTextObj, sal_uInt8 nTyp)
1318 {
1319  const OutlinerParaObject* pParaObj = nullptr;
1320  bool bOwnParaObj = false;
1321 
1322  /*
1323  #i13885#
1324  When the object is actively being edited, that text is not set into
1325  the objects normal text object, but lives in a separate object.
1326  */
1327  if (rTextObj.IsTextEditActive())
1328  {
1329  pParaObj = rTextObj.CreateEditOutlinerParaObject().release();
1330  bOwnParaObj = true;
1331  }
1332  else
1333  {
1334  pParaObj = rTextObj.GetOutlinerParaObject();
1335  }
1336 
1337  if( pParaObj )
1338  {
1339  WriteOutliner(*pParaObj, nTyp);
1340  if( bOwnParaObj )
1341  delete pParaObj;
1342  }
1343 }
1344 
1345 void WW8Export::WriteOutliner(const OutlinerParaObject& rParaObj, sal_uInt8 nTyp)
1346 {
1347  bool bAnyWrite = false;
1348  const EditTextObject& rEditObj = rParaObj.GetTextObject();
1349  MSWord_SdrAttrIter aAttrIter( *this, rEditObj, nTyp );
1350 
1351  sal_Int32 nPara = rEditObj.GetParagraphCount();
1352  sal_uInt8 bNul = 0;
1353  for( sal_Int32 n = 0; n < nPara; ++n )
1354  {
1355  if( n )
1356  aAttrIter.NextPara( n );
1357 
1358  OSL_ENSURE( pO->empty(), " pO is not empty at start of line" );
1359 
1360  OUString aStr( rEditObj.GetText( n ));
1361  sal_Int32 nCurrentPos = 0;
1362  const sal_Int32 nEnd = aStr.getLength();
1363 
1364  const SfxItemSet& aSet(rEditObj.GetParaAttribs(n));
1365  bool bIsRTLPara = false;
1366  const SfxPoolItem *pItem;
1367  if(SfxItemState::SET == aSet.GetItemState(EE_PARA_WRITINGDIR, true, &pItem))
1368  {
1369  SvxFrameDirection nDir = static_cast<const SvxFrameDirectionItem*>(pItem)->GetValue();
1370  bIsRTLPara = SvxFrameDirection::Horizontal_RL_TB == nDir;
1371  }
1372 
1373  do {
1374  const sal_Int32 nNextAttr = std::min(aAttrIter.WhereNext(), nEnd);
1375 
1376  bool bTextAtr = aAttrIter.IsTextAttr( nCurrentPos );
1377  if( !bTextAtr )
1378  OutSwString(aStr, nCurrentPos, nNextAttr - nCurrentPos);
1379 
1380  // At the end of the line the attributes are extended over the CR.
1381  // exception: foot note at line end
1382  if( nNextAttr == nEnd && !bTextAtr )
1383  WriteCR(); // CR after it
1384 
1385  // output of character attributes
1386  aAttrIter.OutAttr( nCurrentPos ); // nCurrentPos - 1 ??
1387 
1388  if (bIsRTLPara)
1389  {
1390  // This is necessary to make word order correct in MS Word.
1391  // In theory we should do this for complex-script runs only,
1392  // but Outliner does not split runs like Writer core did.
1393  // Fortunately, both MS Word and Writer seems to tolerate
1394  // that we turn it on for non complex-script runs.
1395  AttrOutput().OutputItem(SfxInt16Item(RES_CHRATR_BIDIRTL, 1));
1396  }
1397 
1398  m_pChpPlc->AppendFkpEntry( Strm().Tell(),
1399  pO->size(), pO->data() );
1400  pO->clear();
1401 
1402  // exception: foot note at line end
1403  if( nNextAttr == nEnd && bTextAtr )
1404  WriteCR(); // CR after it
1405  nCurrentPos = nNextAttr;
1406  aAttrIter.NextPos();
1407  }
1408  while( nCurrentPos < nEnd );
1409 
1410  OSL_ENSURE( pO->empty(), " pO is not empty at start of line" );
1411 
1412  pO->push_back( bNul ); // Style # as short
1413  pO->push_back( bNul );
1414 
1415  aAttrIter.OutParaAttr(false);
1416 
1417  sal_uLong nPos = Strm().Tell();
1418  m_pPapPlc->AppendFkpEntry( Strm().Tell(),
1419  pO->size(), pO->data() );
1420  pO->clear();
1421  m_pChpPlc->AppendFkpEntry( nPos );
1422  }
1423 
1424  bAnyWrite = 0 != nPara;
1425  if( !bAnyWrite )
1426  WriteStringAsPara( OUString() );
1427 }
1428 
1429 void WinwordAnchoring::WriteData( EscherEx& rEx ) const
1430 {
1431  //Toplevel groups get their winword extra data attached, and sub elements
1432  //use the defaults
1433  if (rEx.GetGroupLevel() > 1)
1434  return;
1435 
1436  SvStream& rSt = rEx.GetStream();
1437  //The last argument denotes the number of sub properties in this atom
1438  if (mbInline)
1439  {
1440  rEx.AddAtom(18, DFF_msofbtUDefProp, 3, 3); //Prop id is 0xF122
1441  rSt.WriteUInt16( 0x0390 ).WriteUInt32( 3 );
1442  rSt.WriteUInt16( 0x0392 ).WriteUInt32( 3 );
1443  //This sub property is required to be in the dummy inline frame as
1444  //well
1445  rSt.WriteUInt16( 0x053F ).WriteUInt32( nInlineHack );
1446  }
1447  else
1448  {
1449  rEx.AddAtom(24, DFF_msofbtUDefProp, 3, 4 ); //Prop id is 0xF122
1450  rSt.WriteUInt16( 0x038F ).WriteUInt32( mnXAlign );
1451  rSt.WriteUInt16( 0x0390 ).WriteUInt32( mnXRelTo );
1452  rSt.WriteUInt16( 0x0391 ).WriteUInt32( mnYAlign );
1453  rSt.WriteUInt16( 0x0392 ).WriteUInt32( mnYRelTo );
1454  }
1455 }
1456 
1457 void WW8Export::CreateEscher()
1458 {
1459  SfxItemState eBackSet = m_rDoc.GetPageDesc(0).GetMaster().
1460  GetItemState(RES_BACKGROUND);
1461  if (m_pHFSdrObjs->size() || m_pSdrObjs->size() || SfxItemState::SET == eBackSet)
1462  {
1463  OSL_ENSURE( !m_pEscher, "Who did not deleted the pointer?" );
1464  SvMemoryStream* pEscherStrm = new SvMemoryStream;
1465  pEscherStrm->SetEndian(SvStreamEndian::LITTLE);
1466  m_pEscher = new SwEscherEx(pEscherStrm, *this);
1467  }
1468 }
1469 
1470 void WW8Export::WriteEscher()
1471 {
1472  if (m_pEscher)
1473  {
1474  sal_uLong nStart = pTableStrm->Tell();
1475 
1476  m_pEscher->WritePictures();
1477  m_pEscher->FinishEscher();
1478 
1479  pFib->m_fcDggInfo = nStart;
1480  pFib->m_lcbDggInfo = pTableStrm->Tell() - nStart;
1481  delete m_pEscher;
1482  m_pEscher = nullptr;
1483  }
1484 }
1485 
1486 void SwEscherEx::WritePictures()
1487 {
1488  if( SvStream* pPicStrm = static_cast< SwEscherExGlobal& >( *mxGlobal ).GetPictureStream() )
1489  {
1490  // set the blip - entries to the correct stream pos
1491  sal_Int32 nEndPos = rWrt.Strm().Tell();
1492  mxGlobal->SetNewBlipStreamOffset( nEndPos );
1493 
1494  pPicStrm->Seek( 0 );
1495  rWrt.Strm().WriteStream( *pPicStrm );
1496  }
1497  Flush();
1498 }
1499 
1500 // Output- Routines for Escher Export
1501 
1502 SwEscherExGlobal::SwEscherExGlobal()
1503 {
1504 }
1505 
1506 SwEscherExGlobal::~SwEscherExGlobal()
1507 {
1508 }
1509 
1510 SvStream* SwEscherExGlobal::ImplQueryPictureStream()
1511 {
1512  // this function will be called exactly once
1513  mxPicStrm = std::make_shared<SvMemoryStream>();
1514  mxPicStrm->SetEndian(SvStreamEndian::LITTLE);
1515  return mxPicStrm.get();
1516 }
1517 
1518 SwBasicEscherEx::SwBasicEscherEx(SvStream* pStrm, WW8Export& rWW8Wrt)
1519  : EscherEx( std::make_shared<SwEscherExGlobal>(), pStrm), rWrt(rWW8Wrt), pEscherStrm(pStrm)
1520 {
1521  Init();
1522 }
1523 
1524 SwBasicEscherEx::~SwBasicEscherEx()
1525 {
1526 }
1527 
1528 void SwBasicEscherEx::WriteFrameExtraData(const SwFrameFormat&)
1529 {
1530  AddAtom(4, ESCHER_ClientAnchor);
1531  GetStream().WriteUInt32( 0x80000000 );
1532 }
1533 
1534 void SwBasicEscherEx::WriteEmptyFlyFrame(const SwFrameFormat& rFormat, sal_uInt32 nShapeId)
1535 {
1536  OpenContainer(ESCHER_SpContainer);
1537  AddShape(ESCHER_ShpInst_PictureFrame, ShapeFlag::HaveAnchor | ShapeFlag::HaveShapeProperty, nShapeId);
1538  // store anchor attribute
1539  WriteFrameExtraData(rFormat);
1540 
1541  AddAtom(6, DFF_msofbtUDefProp, 3, 1); //Prop id is 0xF122
1542  GetStream().WriteUInt16( 0x053F ).WriteUInt32( nInlineHack );
1543 
1544  CloseContainer(); // ESCHER_SpContainer
1545 }
1546 
1547 static ShapeFlag AddMirrorFlags(ShapeFlag nFlags, const SwMirrorGrf &rMirror)
1548 {
1549  switch (rMirror.GetValue())
1550  {
1551  default:
1552  case MirrorGraph::Dont:
1553  break;
1554  case MirrorGraph::Vertical:
1555  nFlags |= ShapeFlag::FlipH;
1556  break;
1557  case MirrorGraph::Horizontal:
1558  nFlags |= ShapeFlag::FlipV;
1559  break;
1560  case MirrorGraph::Both:
1561  nFlags |= ShapeFlag::FlipH | ShapeFlag::FlipV;
1562  break;
1563 
1564  }
1565  return nFlags;
1566 }
1567 //For i120928,this function is added to export graphic of bullet
1568 void SwBasicEscherEx::WriteGrfBullet(const Graphic& rGrf)
1569 {
1570  OpenContainer( ESCHER_SpContainer );
1571  AddShape(ESCHER_ShpInst_PictureFrame, ShapeFlag::HaveAnchor | ShapeFlag::HaveShapeProperty, 0x401);
1572  EscherPropertyContainer aPropOpt;
1573  GraphicObject aGraphicObject( rGrf );
1574  OString aUniqueId = aGraphicObject.GetUniqueID();
1575  if ( !aUniqueId.isEmpty() )
1576  {
1577  sal_uInt32 nBlibId = mxGlobal->GetBlibID( *(mxGlobal->QueryPictureStream()), aGraphicObject );
1578  if (nBlibId)
1579  aPropOpt.AddOpt(ESCHER_Prop_pib, nBlibId, true);
1580  }
1581  aPropOpt.AddOpt( ESCHER_Prop_pibFlags, ESCHER_BlipFlagDefault );
1582  aPropOpt.AddOpt( ESCHER_Prop_dyTextTop, DrawModelToEmu(0));
1583  aPropOpt.AddOpt( ESCHER_Prop_dyTextBottom, DrawModelToEmu(0));
1584  aPropOpt.AddOpt( ESCHER_Prop_dxTextLeft, DrawModelToEmu(0));
1585  aPropOpt.AddOpt( ESCHER_Prop_dxTextRight, DrawModelToEmu(0));
1586  aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x80000 );
1587  aPropOpt.AddOpt( ESCHER_Prop_dyTextTop, 0 );
1588  aPropOpt.AddOpt( ESCHER_Prop_dyTextBottom, 0 );
1589  aPropOpt.AddOpt( ESCHER_Prop_dxTextLeft, 0 );
1590  aPropOpt.AddOpt( ESCHER_Prop_dxTextRight, 0 );
1591  const Color aTmpColor( COL_WHITE );
1592  std::shared_ptr<SvxBrushItem> aBrush(std::make_shared<SvxBrushItem>(aTmpColor, RES_BACKGROUND));
1593  const SvxBrushItem* pRet = rWrt.GetCurrentPageBgBrush();
1594  if (pRet && (pRet->GetGraphic() ||( pRet->GetColor() != COL_TRANSPARENT)))
1595  aBrush.reset(pRet->Clone());
1596  WriteBrushAttr(*aBrush, aPropOpt);
1597 
1598  aPropOpt.AddOpt( ESCHER_Prop_pictureActive, 0 );
1599  aPropOpt.Commit( GetStream() );
1600  AddAtom(4, ESCHER_ClientAnchor);
1601  GetStream().WriteUInt32( 0x80000000 );
1602  CloseContainer();
1603 }
1604 
1605 sal_Int32 SwBasicEscherEx::WriteGrfFlyFrame(const SwFrameFormat& rFormat, sal_uInt32 nShapeId)
1606 {
1607  sal_Int32 nBorderThick=0;
1608  SwNoTextNode *pNd = GetNoTextNodeFromSwFrameFormat(rFormat);
1609  SwGrfNode *pGrfNd = pNd ? pNd->GetGrfNode() : nullptr;
1610  OSL_ENSURE(pGrfNd, "No SwGrfNode ?, suspicious");
1611  if (!pGrfNd)
1612  return nBorderThick;
1613 
1614  OpenContainer( ESCHER_SpContainer );
1615 
1616  const SwMirrorGrf &rMirror = pGrfNd->GetSwAttrSet().GetMirrorGrf();
1617  AddShape(ESCHER_ShpInst_PictureFrame,
1618  AddMirrorFlags(ShapeFlag::HaveAnchor | ShapeFlag::HaveShapeProperty, rMirror),
1619  nShapeId);
1620 
1621  EscherPropertyContainer aPropOpt;
1622 
1623  sal_uInt32 nFlags = ESCHER_BlipFlagDefault;
1624 
1625  if (pGrfNd->IsLinkedFile())
1626  {
1627  OUString sURL;
1628  pGrfNd->GetFileFilterNms( &sURL, nullptr );
1629 
1630  ww::bytes aBuf;
1631  SwWW8Writer::InsAsString16( aBuf, sURL );
1632  SwWW8Writer::InsUInt16( aBuf, 0 );
1633 
1634  aPropOpt.AddOpt(ESCHER_Prop_pibName, true, aBuf.size(), aBuf);
1635  nFlags = ESCHER_BlipFlagLinkToFile | ESCHER_BlipFlagURL |
1636  ESCHER_BlipFlagDoNotSave;
1637  }
1638  else
1639  {
1640  const Graphic& aGraphic(pGrfNd->GetGrf());
1641  GraphicObject aGraphicObject( aGraphic );
1642  OString aUniqueId = aGraphicObject.GetUniqueID();
1643 
1644  if (!aUniqueId.isEmpty())
1645  {
1646  sal_uInt32 nBlibId = mxGlobal->GetBlibID( *QueryPictureStream(), aGraphicObject);
1647  if (nBlibId)
1648  aPropOpt.AddOpt(ESCHER_Prop_pib, nBlibId, true);
1649  }
1650  }
1651 
1652  aPropOpt.AddOpt( ESCHER_Prop_pibFlags, nFlags );
1653  nBorderThick = WriteFlyFrameAttr(rFormat,mso_sptPictureFrame,aPropOpt);
1654  WriteGrfAttr(*pGrfNd, rFormat, aPropOpt);
1655 
1656  aPropOpt.Commit( GetStream() );
1657 
1658  // store anchor attribute
1659  WriteFrameExtraData( rFormat );
1660 
1661  CloseContainer(); // ESCHER_SpContainer
1662  return nBorderThick;
1663 }
1664 
1665 void SwBasicEscherEx::WriteGrfAttr(const SwNoTextNode& rNd, const SwFrameFormat& rFormat,
1666  EscherPropertyContainer& rPropOpt)
1667 {
1668  const SfxPoolItem* pItem;
1669  GraphicDrawMode nMode = GraphicDrawMode::Standard;
1670  sal_Int32 nContrast = 0;
1671  sal_Int16 nBrightness = 0;
1672 
1673  if (SfxItemState::SET == rNd.GetSwAttrSet().GetItemState(RES_GRFATR_CONTRAST,
1674  true, &pItem))
1675  {
1676  nContrast = static_cast<const SfxInt16Item*>(pItem)->GetValue();
1677  }
1678 
1679  if (SfxItemState::SET == rNd.GetSwAttrSet().GetItemState(RES_GRFATR_LUMINANCE,
1680  true, &pItem))
1681  {
1682  nBrightness = static_cast<const SfxInt16Item*>(pItem)->GetValue();
1683  }
1684 
1685  if (SfxItemState::SET == rNd.GetSwAttrSet().GetItemState(RES_GRFATR_DRAWMODE,
1686  true, &pItem))
1687  {
1688  nMode = static_cast<GraphicDrawMode>(static_cast<const SfxEnumItemInterface*>(pItem)->GetEnumValue());
1689  if (nMode == GraphicDrawMode::Watermark)
1690  {
1691  /*
1692  There is no real watermark mode in word, we must use standard
1693  mode and modify our ones by 70% extra brightness and 70% less
1694  contrast. This means that unmodified default OOo watermark
1695  will turn back into watermark, and modified OOo watermark will
1696  change into a close visual representation in standardmode
1697  */
1698  nBrightness += 70;
1699  if (nBrightness > 100)
1700  nBrightness = 100;
1701  nContrast -= 70;
1702  if (nContrast < -100)
1703  nContrast = -100;
1704  nMode = GraphicDrawMode::Standard;
1705  }
1706  }
1707 
1708  sal_uInt32 nPictureMode;
1709  if (nMode == GraphicDrawMode::Greys)
1710  nPictureMode = 0x40004;
1711  else if (nMode == GraphicDrawMode::Mono)
1712  nPictureMode = 0x60006;
1713  else
1714  nPictureMode = 0;
1715  rPropOpt.AddOpt( ESCHER_Prop_pictureActive, nPictureMode );
1716 
1717  if (nContrast != 0)
1718  {
1719  nContrast+=100;
1720  if (nContrast == 100)
1721  nContrast = 0x10000;
1722  else if (nContrast < 100)
1723  {
1724  nContrast *= 0x10000;
1725  nContrast /= 100;
1726  }
1727  else if (nContrast < 200)
1728  nContrast = (100 * 0x10000) / (200-nContrast);
1729  else
1730  nContrast = 0x7fffffff;
1731  rPropOpt.AddOpt( ESCHER_Prop_pictureContrast, nContrast);
1732  }
1733 
1734  if (nBrightness != 0)
1735  rPropOpt.AddOpt( ESCHER_Prop_pictureBrightness, nBrightness * 327 );
1736 
1737  sal_Int32 nCropL = 0;
1738  sal_Int32 nCropR = 0;
1739  sal_Int32 nCropT = 0;
1740  sal_Int32 nCropB = 0;
1741  if (SfxItemState::SET == rNd.GetSwAttrSet().GetItemState(RES_GRFATR_CROPGRF,
1742  true, &pItem))
1743  {
1744  const SwCropGrf& rCrop = *static_cast<const SwCropGrf*>(pItem);
1745  nCropL += rCrop.GetLeft();
1746  nCropR += rCrop.GetRight();
1747  nCropT += rCrop.GetTop();
1748  nCropB += rCrop.GetBottom();
1749  }
1750 
1751  // simulate border padding as a negative crop.
1752  if (SfxItemState::SET == rFormat.GetItemState(RES_BOX, false, &pItem))
1753  {
1754  const SvxBoxItem& rBox = *static_cast<const SvxBoxItem*>(pItem);
1755  nCropL -= rBox.GetDistance( SvxBoxItemLine::LEFT );
1756  nCropR -= rBox.GetDistance( SvxBoxItemLine::RIGHT );
1757  nCropT -= rBox.GetDistance( SvxBoxItemLine::TOP );
1758  nCropB -= rBox.GetDistance( SvxBoxItemLine::BOTTOM );
1759  }
1760 
1761  const Size aSz( rNd.GetTwipSize() );
1762  if( 0 != nCropL )
1763  rPropOpt.AddOpt( ESCHER_Prop_cropFromLeft, ToFract16( nCropL, aSz.Width()) );
1764  if( 0 != nCropR )
1765  rPropOpt.AddOpt( ESCHER_Prop_cropFromRight, ToFract16( nCropR, aSz.Width()));
1766  if( 0 != nCropT )
1767  rPropOpt.AddOpt( ESCHER_Prop_cropFromTop, ToFract16( nCropT, aSz.Height()));
1768  if( 0 != nCropB )
1769  rPropOpt.AddOpt( ESCHER_Prop_cropFromBottom, ToFract16( nCropB, aSz.Height()));
1770 }
1771 
1772 void SwBasicEscherEx::SetPicId(const SdrObject &, sal_uInt32,
1773  EscherPropertyContainer &)
1774 {
1775 }
1776 
1777 void SwEscherEx::SetPicId(const SdrObject &rSdrObj, sal_uInt32 nShapeId,
1778  EscherPropertyContainer &rPropOpt)
1779 {
1780  pTextBxs->Append(rSdrObj, nShapeId);
1781  sal_uInt32 nPicId = pTextBxs->Count();
1782  nPicId *= 0x10000;
1783  rPropOpt.AddOpt( ESCHER_Prop_pictureId, nPicId );
1784 }
1785 
1786 sal_Int32 SwBasicEscherEx::WriteOLEFlyFrame(const SwFrameFormat& rFormat, sal_uInt32 nShapeId)
1787 {
1788  sal_Int32 nBorderThick = 0;
1789  if (const SdrObject* pSdrObj = rFormat.FindRealSdrObject())
1790  {
1791  SwNodeIndex aIdx(*rFormat.GetContent().GetContentIdx(), 1);
1792  SwOLENode& rOLENd = *aIdx.GetNode().GetOLENode();
1793  sal_Int64 nAspect = rOLENd.GetAspect();
1794 
1795  uno::Reference < embed::XEmbeddedObject > xObj(rOLENd.GetOLEObj().GetOleRef());
1796 
1797  // the rectangle is used to transport the size of the object
1798  // the left, top corner is set to ( 0, 0 ) by default constructor,
1799  // if the width and height are set correctly bRectIsSet should be set to true
1800  awt::Rectangle aRect;
1801  bool bRectIsSet = false;
1802 
1803  // TODO/LATER: should the icon size be stored in case of iconified object?
1804  if ( xObj.is() && nAspect != embed::Aspects::MSOLE_ICON )
1805  {
1806  try
1807  {
1808  awt::Size aSize = xObj->getVisualAreaSize( nAspect );
1809  aRect.Width = aSize.Width;
1810  aRect.Height = aSize.Height;
1811  bRectIsSet = true;
1812  }
1813  catch( const uno::Exception& )
1814  {}
1815  }
1816 
1817  /*
1818  #i5970#
1819  Export floating ole2 .doc ver 8+ wmf ole2 previews as emf previews
1820  instead ==> allows unicode text to be preserved
1821  */
1822 #ifdef OLE_PREVIEW_AS_EMF
1823  const Graphic* pGraphic = rOLENd.GetGraphic();
1824 #endif
1825  OpenContainer(ESCHER_SpContainer);
1826 
1827  EscherPropertyContainer aPropOpt;
1828  const SwMirrorGrf &rMirror = rOLENd.GetSwAttrSet().GetMirrorGrf();
1829  WriteOLEPicture(aPropOpt,
1830  AddMirrorFlags(ShapeFlag::HaveAnchor | ShapeFlag::HaveShapeProperty | ShapeFlag::OLEShape, rMirror),
1831  pGraphic ? *pGraphic : Graphic(), *pSdrObj, nShapeId, bRectIsSet ? &aRect : nullptr );
1832 
1833  nBorderThick = WriteFlyFrameAttr(rFormat, mso_sptPictureFrame, aPropOpt);
1834  WriteGrfAttr(rOLENd, rFormat, aPropOpt);
1835  aPropOpt.Commit(GetStream());
1836 
1837  // store anchor attribute
1838  WriteFrameExtraData( rFormat );
1839 
1840  CloseContainer(); // ESCHER_SpContainer
1841  }
1842  return nBorderThick;
1843 }
1844 
1845 void SwBasicEscherEx::WriteBrushAttr(const SvxBrushItem &rBrush,
1846  EscherPropertyContainer& rPropOpt)
1847 {
1848  bool bSetOpacity = false;
1849  sal_uInt32 nOpaque = 0;
1850  if (const GraphicObject *pGraphicObject = rBrush.GetGraphicObject())
1851  {
1852  OString aUniqueId = pGraphicObject->GetUniqueID();
1853  if (!aUniqueId.isEmpty())
1854  {
1855  sal_uInt32 nBlibId = mxGlobal->GetBlibID(*QueryPictureStream(), *pGraphicObject);
1856  if (nBlibId)
1857  rPropOpt.AddOpt(ESCHER_Prop_fillBlip,nBlibId,true);
1858  }
1859 
1860  nOpaque = 255 - pGraphicObject->GetAttr().GetAlpha();
1861  if (0 != nOpaque)
1862  bSetOpacity = true;
1863 
1864  rPropOpt.AddOpt( ESCHER_Prop_fillType, ESCHER_FillPicture );
1865  rPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x140014 );
1866  rPropOpt.AddOpt( ESCHER_Prop_fillBackColor, 0 );
1867  }
1868  else
1869  {
1870  sal_uInt32 nFillColor = GetColor(rBrush.GetColor());
1871  rPropOpt.AddOpt( ESCHER_Prop_fillColor, nFillColor );
1872  rPropOpt.AddOpt( ESCHER_Prop_fillBackColor, nFillColor ^ 0xffffff );
1873  rPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x100010 );
1874 
1875  nOpaque = 255 - rBrush.GetColor().GetAlpha();
1876  if (0 != nOpaque)
1877  bSetOpacity = true;
1878  }
1879 
1880  if (bSetOpacity)
1881  {
1882  nOpaque = (nOpaque * 100) / 0xFE;
1883  nOpaque = ((100 - nOpaque) << 16) / 100;
1884  rPropOpt.AddOpt(ESCHER_Prop_fillOpacity, nOpaque);
1885  }
1886 }
1887 
1888 sal_Int32 SwBasicEscherEx::WriteFlyFrameAttr(const SwFrameFormat& rFormat,
1889  MSO_SPT eShapeType, EscherPropertyContainer& rPropOpt)
1890 {
1891  sal_Int32 nLineWidth=0;
1892  const SfxPoolItem* pItem;
1893  bool bFirstLine = true;
1894  if (SfxItemState::SET == rFormat.GetItemState(RES_BOX, true, &pItem))
1895  {
1896  static const o3tl::enumarray<SvxBoxItemLine, sal_uInt16> aExhperProp =
1897  {
1898  ESCHER_Prop_dyTextTop, ESCHER_Prop_dyTextBottom,
1899  ESCHER_Prop_dxTextLeft, ESCHER_Prop_dxTextRight
1900  };
1901  const SvxBorderLine* pLine;
1902 
1903  for( SvxBoxItemLine n : o3tl::enumrange<SvxBoxItemLine>() )
1904  {
1905  pLine = static_cast<const SvxBoxItem*>(pItem)->GetLine( n );
1906  if( nullptr != pLine )
1907  {
1908  if( bFirstLine )
1909  {
1910  sal_uInt32 nLineColor = GetColor(pLine->GetColor());
1911  rPropOpt.AddOpt( ESCHER_Prop_lineColor, nLineColor );
1912  rPropOpt.AddOpt( ESCHER_Prop_lineBackColor,
1913  nLineColor ^ 0xffffff );
1914 
1915  MSO_LineStyle eStyle;
1916  if( pLine->isDouble() )
1917  {
1918  // double line
1919  nLineWidth = pLine->GetWidth();
1920  if( pLine->GetInWidth() == pLine->GetOutWidth() )
1921  eStyle = mso_lineDouble;
1922  else if( pLine->GetInWidth() < pLine->GetOutWidth() )
1923  eStyle = mso_lineThickThin;
1924  else
1925  eStyle = mso_lineThinThick;
1926  }
1927  else
1928  {
1929  // simple line
1930  eStyle = mso_lineSimple;
1931  nLineWidth = pLine->GetWidth();
1932  }
1933 
1934  rPropOpt.AddOpt( ESCHER_Prop_lineStyle, eStyle );
1935  rPropOpt.AddOpt( ESCHER_Prop_lineWidth,
1936  DrawModelToEmu( nLineWidth ));
1937 
1938  MSO_LineDashing eDashing = mso_lineSolid;
1939  switch (pLine->GetBorderLineStyle())
1940  {
1941  case SvxBorderLineStyle::DASHED:
1942  eDashing = mso_lineDashGEL;
1943  break;
1944  case SvxBorderLineStyle::DOTTED:
1945  eDashing = mso_lineDotGEL;
1946  break;
1947  case SvxBorderLineStyle::SOLID:
1948  default:
1949  break;
1950  }
1951  rPropOpt.AddOpt( ESCHER_Prop_lineDashing, eDashing );
1952  rPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x8000E );
1953 
1954  //Use import logic to determine how much of border will go
1955  //outside graphic
1956  nLineWidth = SwMSDffManager::GetEscherLineMatch(
1957  eStyle,eShapeType,nLineWidth);
1958  bFirstLine = false;
1959  }
1960  rPropOpt.AddOpt( aExhperProp[ n ], DrawModelToEmu(
1961  static_cast<const SvxBoxItem*>(pItem)->GetDistance( n ) ));
1962  }
1963  else
1964  rPropOpt.AddOpt( aExhperProp[ n ], DrawModelToEmu(static_cast<const SvxBoxItem*>(pItem)->GetDistance( n )) );
1965  }
1966  }
1967  else
1968  {
1969  rPropOpt.AddOpt( ESCHER_Prop_dyTextTop, 0 );
1970  rPropOpt.AddOpt( ESCHER_Prop_dyTextBottom, 0 );
1971  rPropOpt.AddOpt( ESCHER_Prop_dxTextLeft, 0 );
1972  rPropOpt.AddOpt( ESCHER_Prop_dxTextRight, 0 );
1973  }
1974 
1975  if( bFirstLine ) // no valid line found
1976  {
1977  rPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x80000 );
1978  }
1979  const SwAttrSet& rAttrSet = rFormat.GetAttrSet();
1980  if (SfxItemState::SET == rAttrSet.GetItemState(RES_BOX, false, &pItem))
1981  {
1982  const SvxBoxItem* pBox = static_cast<const SvxBoxItem*>(pItem);
1983  if( pBox )
1984  {
1985  const SfxPoolItem* pShadItem;
1986  if (SfxItemState::SET
1987  == rAttrSet.GetItemState(RES_SHADOW, true, &pShadItem))
1988  {
1989  const SvxShadowItem* pSI = static_cast<const SvxShadowItem*>(pShadItem);
1990 
1991  constexpr sal_uInt32 nShadowType = 131074; // shadow type of ms word. need to set the default value.
1992 
1993  Color nColor = pSI->GetColor();
1994  sal_Int32 nOffX
1995  = o3tl::convert(pSI->GetWidth(), o3tl::Length::twip, o3tl::Length::emu);
1996  sal_Int32 nOffY
1997  = o3tl::convert(pSI->GetWidth(), o3tl::Length::twip, o3tl::Length::emu);
1998 
1999  SvxShadowLocation eLocation = pSI->GetLocation();
2000  if( (eLocation!=SvxShadowLocation::NONE) && (pSI->GetWidth()!=0) )
2001  {
2002  switch( eLocation )
2003  {
2004  case SvxShadowLocation::TopLeft:
2005  {
2006  nOffX = -nOffX;
2007  nOffY = -nOffY;
2008  }
2009  break;
2010  case SvxShadowLocation::TopRight:
2011  {
2012  nOffY = -nOffY;
2013  }
2014  break;
2015  case SvxShadowLocation::BottomLeft:
2016  {
2017  nOffX = -nOffX;
2018  }
2019  break;
2020  case SvxShadowLocation::BottomRight:
2021  break;
2022  default:
2023  break;
2024  }
2025 
2026  rPropOpt.AddOpt( DFF_Prop_shadowColor, wwUtility::RGBToBGR(nColor));
2027  rPropOpt.AddOpt( DFF_Prop_shadowOffsetX, nOffX );
2028  rPropOpt.AddOpt( DFF_Prop_shadowOffsetY, nOffY );
2029  rPropOpt.AddOpt( DFF_Prop_fshadowObscured, nShadowType );
2030  }
2031  }
2032  }
2033  }
2034 
2035  // SwWW8ImplReader::Read_GrafLayer() imports these as opaque
2036  // unconditionally, so if both are true, don't export the property.
2037  const bool bIsInHeader = sw::IsFlyFrameFormatInHeader(rFormat);
2038  const bool bIsThrough = rFormat.GetSurround().GetValue() == css::text::WrapTextMode_THROUGH;
2039 
2040  // Anything (like a transparent image) that allows text to wrap through should not force a non-transparent background,
2041  // and neither should the commonly seen backgrounds anchored in headers.
2042  if (bIsInHeader || bIsThrough)
2043  {
2044  std::unique_ptr<SvxBrushItem> aBrush(rFormat.makeBackgroundBrushItem());
2045 
2046  if(aBrush)
2047  {
2048  WriteBrushAttr(*aBrush, rPropOpt);
2049  }
2050  }
2051  else
2052  {
2053  // for unknown reasons, force exporting a non-transparent background on fly frames.
2054  std::shared_ptr<SvxBrushItem> aBrush(rWrt.TrueFrameBgBrush(rFormat));
2055 
2056  if(aBrush)
2057  {
2058  WriteBrushAttr(*aBrush, rPropOpt);
2059  }
2060  }
2061 
2062  const SdrObject* pObj = rFormat.FindRealSdrObject();
2063 
2064  if( pObj && (pObj->GetLayer() == GetHellLayerId() ||
2065  pObj->GetLayer() == GetInvisibleHellId() ) && !(bIsInHeader && bIsThrough))
2066  {
2067  rPropOpt.AddOpt( ESCHER_Prop_fPrint, 0x200020 );
2068  }
2069 
2070  PreWriteHyperlinkWithinFly(rFormat,rPropOpt);
2071 
2072  return nLineWidth;
2073 }
2074 
2075 sal_Int32 SwEscherEx::WriteFlyFrameAttr(const SwFrameFormat& rFormat, MSO_SPT eShapeType,
2076  EscherPropertyContainer& rPropOpt)
2077 {
2078  sal_Int32 nLineWidth = SwBasicEscherEx::WriteFlyFrameAttr(rFormat, eShapeType,
2079  rPropOpt);
2080 
2081  /*
2082  These are not in SwBasicEscherEx::WriteFlyFrameAttr because inline objs
2083  can't do it in word and it hacks it in by stretching the graphic that
2084  way, perhaps we should actually draw in this space into the graphic we
2085  are exporting!
2086  */
2087  const SfxPoolItem* pItem;
2088  if (SfxItemState::SET == rFormat.GetItemState(RES_LR_SPACE, true, &pItem))
2089  {
2090  rPropOpt.AddOpt( ESCHER_Prop_dxWrapDistLeft,
2091  DrawModelToEmu( static_cast<const SvxLRSpaceItem*>(pItem)->GetLeft() ) );
2092  rPropOpt.AddOpt( ESCHER_Prop_dxWrapDistRight,
2093  DrawModelToEmu( static_cast<const SvxLRSpaceItem*>(pItem)->GetRight() ) );
2094  }
2095  else
2096  {
2097  rPropOpt.AddOpt( ESCHER_Prop_dxWrapDistLeft, 0 );
2098  rPropOpt.AddOpt( ESCHER_Prop_dxWrapDistRight, 0 );
2099  }
2100 
2101  if (SfxItemState::SET == rFormat.GetItemState(RES_UL_SPACE, true, &pItem))
2102  {
2103  rPropOpt.AddOpt( ESCHER_Prop_dyWrapDistTop,
2104  DrawModelToEmu( static_cast<const SvxULSpaceItem*>(pItem)->GetUpper() ) );
2105  rPropOpt.AddOpt( ESCHER_Prop_dyWrapDistBottom,
2106  DrawModelToEmu( static_cast<const SvxULSpaceItem*>(pItem)->GetLower() ) );
2107  }
2108 
2109  if (rFormat.GetSurround().IsContour())
2110  {
2111  if (const SwNoTextNode *pNd = GetNoTextNodeFromSwFrameFormat(rFormat))
2112  {
2113  const tools::PolyPolygon *pPolyPoly = pNd->HasContour();
2114  if (pPolyPoly && pPolyPoly->Count())
2115  {
2116  tools::Polygon aPoly = CorrectWordWrapPolygonForExport(*pPolyPoly, pNd, /*bCorrectCrop=*/false);
2117  SvMemoryStream aPolyDump;
2118  aPolyDump.SetEndian(SvStreamEndian::LITTLE);
2119 
2120  sal_uInt16 nLen = aPoly.GetSize();
2121  aPolyDump.WriteUInt16( nLen );
2122  aPolyDump.WriteUInt16( nLen );
2123  aPolyDump.WriteUInt16( 8 );
2124  for (sal_uInt16 nI = 0; nI < nLen; ++nI)
2125  {
2126  aPolyDump.WriteUInt32( aPoly[nI].X() );
2127  aPolyDump.WriteUInt32( aPoly[nI].Y() );
2128  }
2129 
2130  rPropOpt.AddOpt(DFF_Prop_pWrapPolygonVertices, false, 0, aPolyDump);
2131  }
2132  }
2133  }
2134 
2135  PreWriteHyperlinkWithinFly(rFormat,rPropOpt);
2136 
2137  return nLineWidth;
2138 }
2139 
2140 void SwBasicEscherEx::Init()
2141 {
2142  MapUnit eMap = MapUnit::MapTwip;
2143  if (SwDrawModel *pModel = rWrt.m_rDoc.getIDocumentDrawModelAccess().GetDrawModel())
2144  {
2145  // PPT works only with units of 576DPI
2146  // WW however is using twips, i.e 1440DPI.
2147  eMap = pModel->GetScaleUnit();
2148  }
2149 
2150  // MS-DFF-Properties mostly are in EMU (English Metric Units)
2151  Fraction aFact = conversionFract(o3tl::Length::mm100, o3tl::Length::emu);
2152  aFact /= GetMapFactor(MapUnit::Map100thMM, eMap).X();
2153  mnEmuMul = aFact.GetNumerator();
2154  mnEmuDiv = aFact.GetDenominator();
2155 
2156  SetHellLayerId(rWrt.m_rDoc.getIDocumentDrawModelAccess().GetHellId());
2157 }
2158 
2159 sal_Int32 SwBasicEscherEx::ToFract16(sal_Int32 nVal, sal_uInt32 nMax)
2160 {
2161  if (nMax)
2162  {
2163  if (nVal >= 0)
2164  {
2165  sal_Int32 nMSVal = (nVal / 65536) * nMax;
2166  nMSVal += (nVal * 65536) / nMax;
2167  return nMSVal;
2168  } else {
2169  // negative fraction does not have "-0", fractional part is always
2170  // positive: -0.4 represented as -1 + 0.6
2171  sal_Int32 const nDiv = (nVal / sal_Int32(nMax)) - 1;
2172  sal_uInt32 nMSVal = (sal_uInt32(nDiv) << 16) & 0xffff0000;
2173  nMSVal += (nVal * 65536) / sal_Int32(nMax) + (-nDiv * 65536);
2174  return nMSVal;
2175  }
2176  }
2177  return 0;
2178 }
2179 
2180 SdrLayerID SwBasicEscherEx::GetInvisibleHellId() const
2181 {
2182  return rWrt.m_rDoc.getIDocumentDrawModelAccess().GetInvisibleHellId();
2183 }
2184 
2185 void SwBasicEscherEx::WritePictures()
2186 {
2187  if( SvStream* pPicStrm = static_cast< SwEscherExGlobal& >( *mxGlobal ).GetPictureStream() )
2188  {
2189  // set the blip - entries to the correct stream pos
2190  sal_Int32 nEndPos = pPicStrm->Tell();
2191  mxGlobal->WriteBlibStoreEntry(*pEscherStrm, 1, nEndPos);
2192 
2193  pPicStrm->Seek(0);
2194  pEscherStrm->WriteStream( *pPicStrm );
2195  }
2196 }
2197 
2198 SwEscherEx::SwEscherEx(SvStream* pStrm, WW8Export& rWW8Wrt)
2199  : SwBasicEscherEx(pStrm, rWW8Wrt),
2200  pTextBxs(nullptr)
2201 {
2202  aHostData.SetClientData(&aWinwordAnchoring);
2203  OpenContainer( ESCHER_DggContainer );
2204 
2205  sal_uInt16 nColorCount = 4;
2206  pStrm ->WriteUInt16( nColorCount << 4 ) // instance
2207  .WriteUInt16( ESCHER_SplitMenuColors ) // record type
2208  .WriteUInt32( nColorCount * 4 ) // size
2209  .WriteUInt32( 0x08000004 )
2210  .WriteUInt32( 0x08000001 )
2211  .WriteUInt32( 0x08000002 )
2212  .WriteUInt32( 0x100000f7 );
2213 
2214  CloseContainer(); // ESCHER_DggContainer
2215 
2216  sal_uInt8 i = 2; // for header/footer and the other
2217  PlcDrawObj *pSdrObjs = rWrt.m_pHFSdrObjs.get();
2218  pTextBxs = rWrt.m_pHFTextBxs.get();
2219 
2220  // if no header/footer -> skip over
2221  if (!pSdrObjs->size())
2222  {
2223  --i;
2224  pSdrObjs = rWrt.m_pSdrObjs.get();
2225  pTextBxs = rWrt.m_pTextBxs.get();
2226  }
2227 
2228  for( ; i--; pSdrObjs = rWrt.m_pSdrObjs.get(), pTextBxs = rWrt.m_pTextBxs.get() )
2229  {
2230  // "dummy char" (or any Count ?) - why? Only Microsoft knows it.
2231  GetStream().WriteChar( i );
2232 
2233  OpenContainer( ESCHER_DgContainer );
2234 
2235  EnterGroup();
2236 
2237  sal_uLong nSecondShapeId = pSdrObjs == rWrt.m_pSdrObjs.get() ? GenerateShapeId() : 0;
2238 
2239  // write now all Writer-/DrawObjects
2240  DrawObjPointerVector aSorted;
2241  MakeZOrderArrAndFollowIds(pSdrObjs->GetObjArr(), aSorted);
2242 
2243  sal_uInt32 nShapeId=0;
2244  for (auto& pObj : aSorted)
2245  {
2246  sal_Int32 nBorderThick=0;
2247  OSL_ENSURE(pObj, "impossible");
2248  if (!pObj)
2249  continue;
2250  const ww8::Frame &rFrame = pObj->maContent;
2251  const SwFrameFormat& rFormat = rFrame.GetFrameFormat();
2252 
2253  switch (rFrame.GetWriterType())
2254  {
2255  case ww8::Frame::eTextBox:
2256  case ww8::Frame::eOle:
2257  case ww8::Frame::eGraphic:
2258  nBorderThick = WriteFlyFrame(*pObj, nShapeId, aSorted);
2259  break;
2260  case ww8::Frame::eFormControl:
2261  nShapeId = GenerateShapeId();
2262  WriteOCXControl(rFormat, nShapeId);
2263  break;
2264  case ww8::Frame::eDrawing:
2265  {
2266  aWinwordAnchoring.SetAnchoring(rFormat);
2267  const SdrObject* pSdrObj = rFormat.FindRealSdrObject();
2268  if (pSdrObj)
2269  {
2270  nShapeId = AddSdrObject(*pSdrObj);
2271  }
2272 #if OSL_DEBUG_LEVEL > 0
2273  else
2274  OSL_ENSURE( false, "Where is the SDR-Object?" );
2275 #endif
2276  }
2277  break;
2278  default:
2279  break;
2280  }
2281 
2282  if( !nShapeId )
2283  {
2284  nShapeId = AddDummyShape();
2285  }
2286 
2287  pObj->SetShapeDetails(nShapeId, nBorderThick);
2288  }
2289 
2290  EndSdrObjectPage(); // ???? Bugfix for 74724
2291 
2292  if( nSecondShapeId )
2293  {
2294  OpenContainer( ESCHER_SpContainer );
2295 
2296  AddShape( ESCHER_ShpInst_Rectangle,
2297  ShapeFlag::HaveAnchor | ShapeFlag::HaveShapeProperty | ShapeFlag::Background,
2298  nSecondShapeId );
2299 
2300  EscherPropertyContainer aPropOpt;
2301  const SwFrameFormat &rFormat = rWrt.m_rDoc.GetPageDesc(0).GetMaster();
2302  const SfxPoolItem* pItem = nullptr;
2303  SfxItemState eState = rFormat.GetItemState(RES_BACKGROUND, true,
2304  &pItem);
2305  if (SfxItemState::SET == eState && pItem)
2306  {
2307  const SvxBrushItem* pBrush = static_cast<const SvxBrushItem*>(pItem);
2308  WriteBrushAttr(*pBrush, aPropOpt);
2309 
2310  SvxGraphicPosition ePos = pBrush->GetGraphicPos();
2311  if( ePos != GPOS_NONE && ePos != GPOS_AREA )
2312  {
2313  /* #i56806# 0x033F parameter specifies a 32-bit field of shape boolean properties.
2314  0x10001 means fBackground and fUsefBackground flag are true thus background
2315  picture will be shown as "tiled" fill.*/
2316  aPropOpt.AddOpt( ESCHER_Prop_fBackground, 0x10001 );
2317  }
2318  }
2319  aPropOpt.AddOpt( ESCHER_Prop_lineColor, 0x8000001 );
2320  aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x00080008 );
2321  aPropOpt.AddOpt( ESCHER_Prop_shadowColor, 0x8000002 );
2322  aPropOpt.AddOpt( ESCHER_Prop_lineWidth, 0 );
2323 
2324  aPropOpt.Commit( *pStrm );
2325 
2326  AddAtom( 4, ESCHER_ClientData );
2327  GetStream().WriteInt32( 1 );
2328 
2329  CloseContainer(); // ESCHER_SpContainer
2330  }
2331  CloseContainer(); // ESCHER_DgContainer
2332  }
2333 }
2334 
2335 SwEscherEx::~SwEscherEx()
2336 {
2337 }
2338 
2339 void SwEscherEx::FinishEscher()
2340 {
2341  pEscherStrm->Seek(0);
2342  rWrt.pTableStrm->WriteStream( *pEscherStrm );
2343  delete pEscherStrm;
2344  pEscherStrm = nullptr;
2345 }
2346 
2347 
2348 namespace
2349 {
2350  template<typename OrientType>
2351  void lcl_SetRelationOrient(OrientType& rOrient, const sw::WW8AnchorConv eConv, const std::function<void()>& fDefault)
2352  {
2353  switch(eConv)
2354  {
2355  case sw::WW8AnchorConv::RELTOTABLECELL:
2356  // #i33818#
2357  rOrient.SetRelationOrient(text::RelOrientation::PAGE_PRINT_AREA);
2358  break;
2359  case sw::WW8AnchorConv::CONV2PG:
2360  rOrient.SetRelationOrient(text::RelOrientation::PAGE_FRAME);
2361  break;
2362  case sw::WW8AnchorConv::CONV2COL_OR_PARA:
2363  rOrient.SetRelationOrient(text::RelOrientation::FRAME);
2364  break;
2365  case sw::WW8AnchorConv::CONV2CHAR:
2366  rOrient.SetRelationOrient(text::RelOrientation::CHAR);
2367  break;
2368  case sw::WW8AnchorConv::CONV2LINE:
2369  rOrient.SetRelationOrient(text::RelOrientation::TEXT_LINE);
2370  break;
2371  default:
2372  fDefault();
2373  }
2374  }
2375 }
2401 bool WinwordAnchoring::ConvertPosition( SwFormatHoriOrient& _iorHoriOri,
2402  SwFormatVertOrient& _iorVertOri,
2403  const SwFrameFormat& _rFrameFormat )
2404 {
2405  const RndStdIds eAnchor = _rFrameFormat.GetAnchor().GetAnchorId();
2406 
2407  if ( (RndStdIds::FLY_AS_CHAR == eAnchor) || (RndStdIds::FLY_AT_FLY == eAnchor) )
2408  {
2409  // no conversion for as-character or at frame anchored objects
2410  return false;
2411  }
2412 
2413  // determine value of attribute 'Follow text flow', because positions aligned
2414  // at page areas have to be converted, if it's set.
2415  const bool bFollowTextFlow = _rFrameFormat.GetFollowTextFlow().GetValue();
2416 
2417  // check, if horizontal and vertical position have to be converted due to
2418  // the fact, that the object is anchored at a paragraph, which has a "column
2419  // break before" attribute
2420  bool bConvDueToAnchoredAtColBreakPara( false );
2421  if ( ( (eAnchor == RndStdIds::FLY_AT_PARA) || (eAnchor == RndStdIds::FLY_AT_CHAR) ) &&
2422  _rFrameFormat.GetAnchor().GetContentAnchor() &&
2423  _rFrameFormat.GetAnchor().GetContentAnchor()->nNode.GetNode().IsTextNode() )
2424  {
2425  SwTextNode& rAnchorTextNode =
2426  dynamic_cast<SwTextNode&>(_rFrameFormat.GetAnchor().GetContentAnchor()->nNode.GetNode());
2427  const SvxFormatBreakItem& rBreak = ItemGet<SvxFormatBreakItem>(rAnchorTextNode, RES_BREAK);
2428  if (rBreak.GetBreak() == SvxBreak::ColumnBefore)
2429  {
2430  bConvDueToAnchoredAtColBreakPara = true;
2431  }
2432  }
2433 
2434  sw::WW8AnchorConv eHoriConv(sw::WW8AnchorConv::NO_CONV);
2435  sw::WW8AnchorConv eVertConv(sw::WW8AnchorConv::NO_CONV);
2436  // convert horizontal position, if needed
2437  {
2438 
2439  // determine, if conversion has to be performed due to the position orientation
2440  bool bConvDueToOrientation( false );
2441  {
2442  const sal_Int16 eHOri = _iorHoriOri.GetHoriOrient();
2443  bConvDueToOrientation = eHOri == text::HoriOrientation::LEFT || eHOri == text::HoriOrientation::RIGHT ||
2444  eHOri == text::HoriOrientation::INSIDE || eHOri == text::HoriOrientation::OUTSIDE ||
2445  ( eHOri != text::HoriOrientation::CENTER && _iorHoriOri.IsPosToggle() );
2446  }
2447 
2448  // determine conversion type due to the position relation
2449  if ( bConvDueToAnchoredAtColBreakPara )
2450  {
2451  eHoriConv = sw::WW8AnchorConv::CONV2PG;
2452  }
2453  else if ( _iorHoriOri.IsPosToggle()
2454  && _iorHoriOri.GetHoriOrient() == text::HoriOrientation::RIGHT )
2455  {
2456  eHoriConv = sw::WW8AnchorConv::NO_CONV;
2457  _iorHoriOri.SetHoriOrient( text::HoriOrientation::OUTSIDE );
2458  }
2459  else
2460  {
2461  switch ( _iorHoriOri.GetRelationOrient() )
2462  {
2463  case text::RelOrientation::PAGE_FRAME:
2464  case text::RelOrientation::PAGE_PRINT_AREA:
2465  {
2466  if ( bConvDueToOrientation || bFollowTextFlow )
2467  eHoriConv = sw::WW8AnchorConv::CONV2PG;
2468  }
2469  break;
2470  case text::RelOrientation::PAGE_LEFT:
2471  case text::RelOrientation::PAGE_RIGHT:
2472  {
2473  // relation not supported by WW8. Thus, conversion always needed.
2474  eHoriConv = sw::WW8AnchorConv::CONV2PG;
2475  }
2476  break;
2477  case text::RelOrientation::FRAME:
2478  {
2479  if ( bConvDueToOrientation )
2480  eHoriConv = sw::WW8AnchorConv::CONV2COL_OR_PARA;
2481  }
2482  break;
2483  case text::RelOrientation::PRINT_AREA:
2484  case text::RelOrientation::FRAME_LEFT:
2485  case text::RelOrientation::FRAME_RIGHT:
2486  {
2487  // relation not supported by WW8. Thus, conversion always needed.
2488  eHoriConv = sw::WW8AnchorConv::CONV2COL_OR_PARA;
2489  }
2490  break;
2491  case text::RelOrientation::CHAR:
2492  {
2493  if ( bConvDueToOrientation )
2494  eHoriConv = sw::WW8AnchorConv::CONV2CHAR;
2495  }
2496  break;
2497  default:
2498  OSL_FAIL( "<WinwordAnchoring::ConvertPosition(..)> - unknown horizontal relation" );
2499  }
2500  }
2501  }
2502 
2503  // convert vertical position, if needed
2504  {
2505 
2506  // determine, if conversion has to be performed due to the position orientation
2507  bool bConvDueToOrientation( false );
2508  {
2509  const sal_Int16 eVOri = _iorVertOri.GetVertOrient();
2510  bConvDueToOrientation = ( eVOri == text::VertOrientation::TOP ||
2511  eVOri == text::VertOrientation::BOTTOM ||
2512  eVOri == text::VertOrientation::CHAR_TOP ||
2513  eVOri == text::VertOrientation::CHAR_BOTTOM ||
2514  eVOri == text::VertOrientation::CHAR_CENTER ||
2515  eVOri == text::VertOrientation::LINE_TOP ||
2516  eVOri == text::VertOrientation::LINE_BOTTOM ||
2517  eVOri == text::VertOrientation::LINE_CENTER );
2518  }
2519 
2520  // determine conversion type due to the position relation
2521  if ( bConvDueToAnchoredAtColBreakPara )
2522  {
2523  eVertConv = sw::WW8AnchorConv::CONV2PG;
2524  }
2525  else
2526  {
2527  switch ( _iorVertOri.GetRelationOrient() )
2528  {
2529  case text::RelOrientation::PAGE_FRAME:
2530  case text::RelOrientation::PAGE_PRINT_AREA:
2531  {
2532  if ( bConvDueToOrientation || bFollowTextFlow )
2533  eVertConv = sw::WW8AnchorConv::CONV2PG;
2534  }
2535  break;
2536  case text::RelOrientation::FRAME:
2537  {
2538  if ( bConvDueToOrientation ||
2539  _iorVertOri.GetVertOrient() == text::VertOrientation::CENTER )
2540  {
2541  eVertConv = sw::WW8AnchorConv::CONV2COL_OR_PARA;
2542  }
2543  }
2544  break;
2545  case text::RelOrientation::PRINT_AREA:
2546  {
2547  // relation not supported by WW8. Thus, conversion always needed.
2548  eVertConv = sw::WW8AnchorConv::CONV2COL_OR_PARA;
2549  }
2550  break;
2551  case text::RelOrientation::CHAR:
2552  {
2553  // relation not supported by WW8. Thus, conversion always needed.
2554  eVertConv = sw::WW8AnchorConv::CONV2COL_OR_PARA;
2555  }
2556  break;
2557  case text::RelOrientation::TEXT_LINE:
2558  {
2559  if ( bConvDueToOrientation ||
2560  _iorVertOri.GetVertOrient() == text::VertOrientation::NONE )
2561  {
2562  eVertConv = sw::WW8AnchorConv::CONV2LINE;
2563  }
2564  }
2565  break;
2566  case text::RelOrientation::PAGE_LEFT:
2567  case text::RelOrientation::PAGE_RIGHT:
2568  case text::RelOrientation::FRAME_LEFT:
2569  case text::RelOrientation::FRAME_RIGHT:
2570  default:
2571  OSL_FAIL( "<WinwordAnchoring::ConvertPosition(..)> - unknown vertical relation" );
2572  }
2573  }
2574 
2575  }
2576  if (eVertConv != sw::WW8AnchorConv::NO_CONV || eHoriConv != sw::WW8AnchorConv::NO_CONV)
2577  {
2578  sw::WW8AnchorConvResult aResult(eHoriConv, eVertConv);
2579  _rFrameFormat.CallSwClientNotify(sw::WW8AnchorConvHint(aResult));
2580  if(!aResult.m_bConverted)
2581  return false;
2582  if (eHoriConv != sw::WW8AnchorConv::NO_CONV)
2583  {
2584  lcl_SetRelationOrient(_iorHoriOri, eHoriConv, [&_iorHoriOri]() {_iorHoriOri.SetHoriOrient(text::HoriOrientation::NONE);} );
2585  _iorHoriOri.SetPos(aResult.m_aPos.X());
2586  }
2587  if (eVertConv != sw::WW8AnchorConv::NO_CONV)
2588  {
2589  lcl_SetRelationOrient(_iorVertOri, eVertConv, [&_iorVertOri]() {_iorVertOri.SetVertOrient(text::VertOrientation::NONE);} );
2590  _iorVertOri.SetPos(aResult.m_aPos.Y());
2591  }
2592  return true;
2593  }
2594  return false;
2595 }
2596 
2597 void WinwordAnchoring::SetAnchoring(const SwFrameFormat& rFormat)
2598 {
2599  const RndStdIds eAnchor = rFormat.GetAnchor().GetAnchorId();
2600  mbInline = (eAnchor == RndStdIds::FLY_AS_CHAR);
2601 
2602  SwFormatHoriOrient rHoriOri = rFormat.GetHoriOrient();
2603  SwFormatVertOrient rVertOri = rFormat.GetVertOrient();
2604 
2605  // #i30669# - convert the positioning attributes.
2606  // Most positions are converted, if layout information exists.
2607  const bool bPosConverted = ConvertPosition( rHoriOri, rVertOri, rFormat );
2608 
2609  const sal_Int16 eHOri = rHoriOri.GetHoriOrient();
2610  const sal_Int16 eVOri = rVertOri.GetVertOrient(); // #i22673#
2611 
2612  const sal_Int16 eHRel = rHoriOri.GetRelationOrient();
2613  const sal_Int16 eVRel = rVertOri.GetRelationOrient();
2614 
2615  // horizontal Adjustment
2616  switch (eHOri)
2617  {
2618  default:
2619  case text::HoriOrientation::NONE:
2620  mnXAlign = 0;
2621  break;
2622  case text::HoriOrientation::LEFT:
2623  mnXAlign = 1;
2624  break;
2625  case text::HoriOrientation::CENTER:
2626  mnXAlign = 2;
2627  break;
2628  case text::HoriOrientation::RIGHT:
2629  mnXAlign = 3;
2630  break;
2631  case text::HoriOrientation::INSIDE:
2632  mnXAlign = 4;
2633  break;
2634  case text::HoriOrientation::OUTSIDE:
2635  mnXAlign = 5;
2636  break;
2637  }
2638 
2639  // vertical Adjustment
2640  // #i22673#
2641  // When adjustment is vertically relative to line or to char
2642  // bottom becomes top and vice versa
2643  const bool bVertSwap = !bPosConverted &&
2644  ( (eVRel == text::RelOrientation::CHAR) ||
2645  (eVRel == text::RelOrientation::TEXT_LINE) );
2646  switch (eVOri)
2647  {
2648  default:
2649  case text::VertOrientation::NONE:
2650  mnYAlign = 0;
2651  break;
2652  case text::VertOrientation::TOP:
2653  case text::VertOrientation::LINE_TOP:
2654  case text::VertOrientation::CHAR_TOP:
2655  mnYAlign = bVertSwap ? 3 : 1;
2656  break;
2657  case text::VertOrientation::CENTER:
2658  case text::VertOrientation::LINE_CENTER:
2659  mnYAlign = 2;
2660  break;
2661  case text::VertOrientation::BOTTOM:
2662  case text::VertOrientation::LINE_BOTTOM:
2663  case text::VertOrientation::CHAR_BOTTOM:
2664  mnYAlign = bVertSwap ? 1 : 3;
2665  break;
2666  }
2667 
2668  // Adjustment is horizontally relative to...
2669  switch (eHRel)
2670  {
2671  case text::RelOrientation::PAGE_PRINT_AREA:
2672  mnXRelTo = 0;
2673  break;
2674  case text::RelOrientation::PAGE_FRAME:
2675  case text::RelOrientation::PAGE_LEFT: //:-(
2676  case text::RelOrientation::PAGE_RIGHT: //:-(
2677  mnXRelTo = 1;
2678  break;
2679  case text::RelOrientation::FRAME:
2680  case text::RelOrientation::FRAME_LEFT: //:-(
2681  case text::RelOrientation::FRAME_RIGHT: //:-(
2682  if (eAnchor == RndStdIds::FLY_AT_PAGE)
2683  mnXRelTo = 1;
2684  else
2685  mnXRelTo = 2;
2686  break;
2687  case text::RelOrientation::PRINT_AREA:
2688  if (eAnchor == RndStdIds::FLY_AT_PAGE)
2689  mnXRelTo = 0;
2690  else
2691  mnXRelTo = 2;
2692  break;
2693  case text::RelOrientation::CHAR:
2694  mnXRelTo = 3;
2695  break;
2696  case text::RelOrientation::TEXT_LINE:
2697  break;
2698  }
2699 
2700  // Adjustment is vertically relative to...
2701  switch (eVRel)
2702  {
2703  case text::RelOrientation::PAGE_PRINT_AREA:
2704  mnYRelTo = 0;
2705  break;
2706  case text::RelOrientation::PAGE_FRAME:
2707  mnYRelTo = 1;
2708  break;
2709  case text::RelOrientation::PRINT_AREA:
2710  if (eAnchor == RndStdIds::FLY_AT_PAGE)
2711  mnYRelTo = 0;
2712  else
2713  mnYRelTo = 2;
2714  break;
2715  case text::RelOrientation::FRAME:
2716  if (eAnchor == RndStdIds::FLY_AT_PAGE)
2717  mnYRelTo = 1;
2718  else
2719  mnYRelTo = 2;
2720  break;
2721  case text::RelOrientation::CHAR:
2722  case text::RelOrientation::TEXT_LINE: // #i22673# - vertical alignment at top of line
2723  case text::RelOrientation::PAGE_LEFT: //nonsense
2724  case text::RelOrientation::PAGE_RIGHT: //nonsense
2725  case text::RelOrientation::FRAME_LEFT: //nonsense
2726  case text::RelOrientation::FRAME_RIGHT: //nonsense
2727  mnYRelTo = 3;
2728  break;
2729  }
2730 }
2731 
2732 void SwEscherEx::WriteFrameExtraData( const SwFrameFormat& rFormat )
2733 {
2734  aWinwordAnchoring.SetAnchoring(rFormat);
2735  aWinwordAnchoring.WriteData(*this);
2736 
2737  AddAtom(4, ESCHER_ClientAnchor);
2738  GetStream().WriteInt32( 0 );
2739 
2740  AddAtom(4, ESCHER_ClientData);
2741  GetStream().WriteInt32( 1 );
2742 }
2743 
2744 sal_Int32 SwEscherEx::WriteFlyFrame(const DrawObj &rObj, sal_uInt32 &rShapeId,
2745  DrawObjPointerVector &rPVec)
2746 {
2747  const SwFrameFormat &rFormat = rObj.maContent.GetFrameFormat();
2748 
2749  // check for textflyframe and if it is the first in a Chain
2750  sal_Int32 nBorderThick = 0;
2751  const SwNodeIndex* pNdIdx = rFormat.GetContent().GetContentIdx();
2752  if( pNdIdx )
2753  {
2754  SwNodeIndex aIdx( *pNdIdx, 1 );
2755  switch( aIdx.GetNode().GetNodeType() )
2756  {
2757  case SwNodeType::Grf:
2758  rShapeId = GenerateShapeId();
2759  nBorderThick = WriteGrfFlyFrame( rFormat, rShapeId );
2760  break;
2761  case SwNodeType::Ole:
2762  rShapeId = GenerateShapeId();
2763  nBorderThick = WriteOLEFlyFrame( rFormat, rShapeId );
2764  break;
2765  default:
2766  if (const SdrObject* pObj = rFormat.FindRealSdrObject())
2767  {
2768  // check for the first in a Chain
2769  sal_uInt32 nTextId;
2770  sal_uInt16 nOff = 0;
2771  const SwFrameFormat* pFormat = &rFormat, *pPrev;
2772  while( nullptr != ( pPrev = pFormat->GetChain().GetPrev() ))
2773  {
2774  ++nOff;
2775  pFormat = pPrev;
2776  }
2777 
2778  rShapeId = GetFlyShapeId(rFormat, rObj.mnHdFtIndex, rPVec);
2779  if( !nOff )
2780  {
2781  nTextId = pTextBxs->GetPos( pObj );
2782  if( USHRT_MAX == nTextId )
2783  {
2784  pTextBxs->Append( *pObj, rShapeId );
2785  nTextId = pTextBxs->Count();
2786  }
2787  else
2788  ++nTextId;
2789  }
2790  else
2791  {
2792  const SdrObject* pPrevObj = pFormat->FindRealSdrObject();
2793  nTextId = pTextBxs->GetPos( pPrevObj );
2794  if( USHRT_MAX == nTextId )
2795  {
2796  sal_uInt32 nPrevShapeId =
2797  GetFlyShapeId(*pFormat, rObj.mnHdFtIndex, rPVec);
2798  pTextBxs->Append( *pPrevObj, nPrevShapeId );
2799  nTextId = pTextBxs->Count();
2800  }
2801  else
2802  ++nTextId;
2803  }
2804  nTextId *= 0x10000;
2805  nTextId += nOff;
2806 
2807  nBorderThick = WriteTextFlyFrame(rObj, rShapeId, nTextId, rPVec);
2808  }
2809 
2810  //In browse mode the sdr object doesn't always exist. For example, the
2811  //object is in the hidden header/footer. We save the fmt directly
2812  //in such cases; we copy most of the logic from the block above
2813  const bool bBrowseMode = rFormat.getIDocumentSettingAccess().get(DocumentSettingId::BROWSE_MODE);
2814  if( bBrowseMode && rFormat.GetDoc())
2815  {
2816  if( !rFormat.GetChain().GetPrev() )//obj in header/footer?
2817  {
2818  rShapeId = GetFlyShapeId(rFormat, rObj.mnHdFtIndex, rPVec);
2819  pTextBxs->Append( &rFormat, rShapeId );
2820  sal_uInt32 nTextId = pTextBxs->Count();
2821 
2822  nTextId *= 0x10000;
2823  nBorderThick = WriteTextFlyFrame(rObj, rShapeId, nTextId, rPVec);
2824  }
2825  }
2826 
2827  }
2828  }
2829  return nBorderThick;
2830 }
2831 
2832 static sal_uInt16 FindPos(const SwFrameFormat &rFormat, unsigned int nHdFtIndex,
2833  DrawObjPointerVector &rPVec)
2834 {
2835  auto aIter = std::find_if(rPVec.begin(), rPVec.end(),
2836  [&rFormat, nHdFtIndex](const DrawObj* pObj) {
2837  OSL_ENSURE(pObj, "Impossible");
2838  return pObj &&
2839  nHdFtIndex == pObj->mnHdFtIndex &&
2840  &rFormat == (&pObj->maContent.GetFrameFormat());
2841  });
2842  if (aIter != rPVec.end())
2843  return static_cast< sal_uInt16 >(aIter - rPVec.begin());
2844  return USHRT_MAX;
2845 }
2846 
2847 sal_Int32 SwEscherEx::WriteTextFlyFrame(const DrawObj &rObj, sal_uInt32 nShapeId,
2848  sal_uInt32 nTextBox, DrawObjPointerVector &rPVec)
2849 {
2850  const SwFrameFormat &rFormat = rObj.maContent.GetFrameFormat();
2851  SvxFrameDirection nDirection = rObj.mnDirection;
2852 
2853  sal_Int32 nBorderThick=0;
2854  OpenContainer( ESCHER_SpContainer );
2855 
2856  AddShape( ESCHER_ShpInst_TextBox, ShapeFlag::HaveAnchor | ShapeFlag::HaveShapeProperty, nShapeId );
2857  EscherPropertyContainer aPropOpt;
2858  aPropOpt.AddOpt(ESCHER_Prop_lTxid, nTextBox);
2859  if (const SwFrameFormat *pNext = rFormat.GetChain().GetNext())
2860  {
2861  sal_uInt16 nPos = FindPos(*pNext, rObj.mnHdFtIndex, rPVec);
2862  if (USHRT_MAX != nPos && aFollowShpIds[nPos])
2863  aPropOpt.AddOpt(ESCHER_Prop_hspNext, aFollowShpIds[nPos]);
2864  }
2865  nBorderThick = WriteFlyFrameAttr( rFormat, mso_sptTextBox, aPropOpt );
2866 
2867  MSO_TextFlow nFlow;
2868 
2869  switch (nDirection)
2870  {
2871  default:
2872  OSL_ENSURE(false, "unknown direction type");
2873  [[fallthrough]];
2874  case SvxFrameDirection::Horizontal_LR_TB:
2875  nFlow=mso_txflHorzN;
2876  break;
2877  case SvxFrameDirection::Horizontal_RL_TB:
2878  nFlow=mso_txflHorzN;
2879  break;
2880  case SvxFrameDirection::Vertical_LR_TB: //not really possible in word
2881  case SvxFrameDirection::Vertical_RL_TB:
2882  nFlow=mso_txflTtoBA;
2883  break;
2884  case SvxFrameDirection::Vertical_LR_BT:
2885  nFlow = mso_txflBtoT;
2886  break;
2887  }
2888  aPropOpt.AddOpt( ESCHER_Prop_txflTextFlow, nFlow );
2889 
2890  aPropOpt.Commit( GetStream() );
2891 
2892  // store anchor attribute
2893  WriteFrameExtraData( rFormat );
2894 
2895  AddAtom( 4, ESCHER_ClientTextbox ); GetStream().WriteUInt32( nTextBox );
2896 
2897  CloseContainer(); // ESCHER_SpContainer
2898  return nBorderThick;
2899 }
2900 
2901 void SwBasicEscherEx::WriteOLEPicture(EscherPropertyContainer &rPropOpt,
2902  ShapeFlag nShapeFlags, const Graphic &rGraphic, const SdrObject &rObj,
2903  sal_uInt32 nShapeId, const awt::Rectangle* pVisArea )
2904 {
2905  //nShapeFlags == 0xA00 + flips and ole active
2906  AddShape(ESCHER_ShpInst_PictureFrame, nShapeFlags, nShapeId);
2907 
2908  GraphicObject aGraphicObject(rGraphic);
2909  OString aId = aGraphicObject.GetUniqueID();
2910  if (!aId.isEmpty())
2911  {
2912  // SJ: the third parameter (pVisArea) should be set...
2913  sal_uInt32 nBlibId = mxGlobal->GetBlibID( *QueryPictureStream(), aGraphicObject, pVisArea);
2914  if (nBlibId)
2915  rPropOpt.AddOpt(ESCHER_Prop_pib, nBlibId, true);
2916  }
2917 
2918  SetPicId(rObj, nShapeId, rPropOpt);
2919  rPropOpt.AddOpt( ESCHER_Prop_pictureActive, 0x10000 );
2920 }
2921 
2922 void SwEscherEx::WriteOCXControl( const SwFrameFormat& rFormat, sal_uInt32 nShapeId )
2923 {
2924  const SdrObject* pSdrObj = rFormat.FindRealSdrObject();
2925  if (!pSdrObj)
2926  return;
2927 
2928  OpenContainer( ESCHER_SpContainer );
2929 
2930  SwDrawModel *pModel = rWrt.m_rDoc.getIDocumentDrawModelAccess().GetDrawModel();
2931  OutputDevice *pDevice = Application::GetDefaultDevice();
2932  OSL_ENSURE(pModel && pDevice, "no model or device");
2933 
2934  // #i71538# use complete SdrViews
2935  // SdrExchangeView aExchange(pModel, pDevice);
2936  SdrView aExchange(*pModel, pDevice);
2937  const Graphic aGraphic(SdrExchangeView::GetObjGraphic(*pSdrObj));
2938  EscherPropertyContainer aPropOpt;
2939  WriteOLEPicture(aPropOpt,
2940  ShapeFlag::HaveAnchor | ShapeFlag::HaveShapeProperty | ShapeFlag::OLEShape, aGraphic,
2941  *pSdrObj, nShapeId, nullptr );
2942 
2943  WriteFlyFrameAttr( rFormat, mso_sptPictureFrame , aPropOpt );
2944  aPropOpt.Commit( GetStream() );
2945 
2946  // store anchor attribute
2947  WriteFrameExtraData( rFormat );
2948 
2949  CloseContainer(); // ESCHER_SpContainer
2950 
2951 }
2952 
2953 void SwEscherEx::MakeZOrderArrAndFollowIds(
2954  std::vector<DrawObj>& rSrcArr, DrawObjPointerVector&rDstArr)
2955 {
2956  ::lcl_makeZOrderArray(rWrt, rSrcArr, rDstArr);
2957 
2958  //Now set up the follow IDs
2959  aFollowShpIds.clear();
2960 
2961  for (DrawObj* p : rDstArr)
2962  {
2963  const SwFrameFormat &rFormat = p->maContent.GetFrameFormat();
2964  bool bNeedsShapeId = false;
2965 
2966  if (RES_FLYFRMFMT == rFormat.Which())
2967  {
2968  const SwFormatChain &rChain = rFormat.GetChain();
2969  if (rChain.GetPrev() || rChain.GetNext())
2970  bNeedsShapeId = true;
2971  }
2972 
2973  sal_uLong nShapeId = bNeedsShapeId ? GenerateShapeId() : 0;
2974 
2975  aFollowShpIds.push_back(nShapeId);
2976  }
2977 }
2978 
2979 sal_uInt32 SwEscherEx::GetFlyShapeId(const SwFrameFormat& rFormat,
2980  unsigned int nHdFtIndex, DrawObjPointerVector &rpVec)
2981 {
2982  sal_uInt16 nPos = FindPos(rFormat, nHdFtIndex, rpVec);
2983  sal_uInt32 nShapeId;
2984  if (USHRT_MAX != nPos)
2985  {
2986  nShapeId = aFollowShpIds[nPos];
2987  if (0 == nShapeId)
2988  {
2989  nShapeId = GenerateShapeId();
2990  aFollowShpIds[ nPos ] = nShapeId;
2991  }
2992  }
2993  else
2994  nShapeId = GenerateShapeId();
2995  return nShapeId;
2996 }
2997 
2998 sal_uInt32 SwEscherEx::QueryTextID(
2999  const uno::Reference< drawing::XShape>& xXShapeRef, sal_uInt32 nShapeId )
3000 {
3001  sal_uInt32 nId = 0;
3002  if (SdrObject* pObj = GetSdrObjectFromXShape(xXShapeRef))
3003  {
3004  pTextBxs->Append( *pObj, nShapeId );
3005  nId = pTextBxs->Count();
3006  nId *= 0x10000;
3007  }
3008  return nId;
3009 }
3010 
3011 SwMSConvertControls::SwMSConvertControls( SfxObjectShell const *pDSh, SwPaM *pP ) : oox
3012 ::ole::MSConvertOCXControls( pDSh ? pDSh->GetModel() : nullptr ), pPaM( pP ), mnObjectId(0)
3013 {
3014 }
3015 
3016 
3017 // in transitioning away old filter for ole/ocx controls, ReadOCXStream has been made pure virtual in
3018 // filter/source/msocximex.cxx, so... we need an implementation here
3019 bool SwMSConvertControls::ReadOCXStream( tools::SvRef<SotStorage> const & rSrc1,
3020  css::uno::Reference< css::drawing::XShape > *pShapeRef,
3021  bool bFloatingCtrl )
3022 {
3023  uno::Reference< form::XFormComponent > xFComp;
3024  bool bRes = oox::ole::MSConvertOCXControls::ReadOCXStorage( rSrc1, xFComp );
3025  if ( bRes && xFComp.is() )
3026  {
3027  css::awt::Size aSz; // not used in import
3028  bRes = InsertControl( xFComp, aSz,pShapeRef,bFloatingCtrl);
3029  }
3030  return bRes;
3031 }
3032 
3033 void SwMSConvertControls::ExportControl(WW8Export &rWW8Wrt, const SdrUnoObj& rFormObj)
3034 {
3035  const uno::Reference< awt::XControlModel >& xControlModel =
3036  rFormObj.GetUnoControlModel();
3037 
3038  //Why oh lord do we use so many different units ?
3039  //I think I painted myself into a little bit of a
3040  //corner by trying to use the uno interface for
3041  //controls export
3042  tools::Rectangle aRect = rFormObj.GetLogicRect();
3043  aRect.SetPos(Point(0,0));
3044  awt::Size aSize;
3045  aSize.Width = convertTwipToMm100(aRect.Right());
3046  aSize.Height = convertTwipToMm100(aRect.Bottom());
3047 
3048  //Open the ObjectPool
3049  tools::SvRef<SotStorage> xObjPool = rWW8Wrt.GetWriter().GetStorage().OpenSotStorage(SL::aObjectPool);
3050 
3051  //Create a destination storage for the microsoft control
3052  sal_uInt32 nObjId = ++mnObjectId;
3053  OUString sStorageName = "_" + OUString::number( static_cast<sal_Int64>( nObjId ));
3054  tools::SvRef<SotStorage> xOleStg = xObjPool->OpenSotStorage(sStorageName);
3055 
3056  if (!xOleStg.is())
3057  return;
3058 
3059  OUString sUName;
3060  if (!WriteOCXStream( mxModel, xOleStg,xControlModel,aSize,sUName))
3061  return;
3062 
3063  sal_uInt8 aSpecOLE[] =
3064  {
3065  0x03, 0x6a, 0xFF, 0xFF, 0xFF, 0xFF, // sprmCPicLocation
3066  0x0a, 0x08, 1, // sprmCFOLE2
3067  0x55, 0x08, 1, // sprmCFSpec
3068  0x56, 0x08, 1 // sprmCFObj
3069  };
3070  //Set the obj id into the sprmCPicLocation
3071  sal_uInt8 *pData = aSpecOLE+2;
3072  Set_UInt32(pData,nObjId );
3073 
3074  OUString sField = FieldString(ww::eCONTROL) + "Forms." + sUName + ".1 \\s ";
3075 
3076  rWW8Wrt.OutputField(nullptr, ww::eCONTROL, sField,
3077  FieldFlags::Start|FieldFlags::CmdStart|FieldFlags::CmdEnd);
3078 
3079  rWW8Wrt.m_pChpPlc->AppendFkpEntry(rWW8Wrt.Strm().Tell(),sizeof(aSpecOLE),
3080  aSpecOLE);
3081  rWW8Wrt.WriteChar( 0x1 );
3082  rWW8Wrt.OutputField(nullptr, ww::eCONTROL, OUString(), FieldFlags::End | FieldFlags::Close);
3083 }
3084 
3085 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
mso_lineSolid
mso_lineSolid
sw::proofreadingiterator::get
css::uno::Reference< css::linguistic2::XProofreadingIterator > get(css::uno::Reference< css::uno::XComponentContext > const &context)
Definition: proofreadingiterator.cxx:38
tools::PolyPolygon::Count
sal_uInt16 Count() const
SfxBoolItem::GetValue
bool GetValue() const
MSWord_SdrAttrIter::nCurrentSwPos
sal_Int32 nCurrentSwPos
Definition: wrtww8.hxx:1461
tools::SvRef::is
bool is() const
ESCHER_DgContainer
#define ESCHER_DgContainer
MainTextPlcDrawObj::RegisterWithFib
virtual void RegisterWithFib(WW8Fib &rFib, sal_uInt32 nStart, sal_uInt32 nLen) const override
Definition: wrtw8esh.cxx:855
tools::Rectangle::SetPos
void SetPos(const Point &rPoint)
SwFormatSurround::IsContour
bool IsContour() const
Definition: fmtsrnd.hxx:53
SwBasicEscherEx::pEscherStrm
SvStream * pEscherStrm
Definition: escher.hxx:98
ww::eFORMDROPDOWN
eFORMDROPDOWN
WW8Export
Exporter of the binary Word file formats.
Definition: wrtww8.hxx:988
SwMSConvertControls::mnObjectId
sal_uInt32 mnObjectId
Definition: ww8par.hxx:747
MSWord_SdrAttrIter::OutAttr
void OutAttr(sal_Int32 nSwPos)
Definition: wrtw8esh.cxx:1118
MSWordExportBase::AttrOutput
virtual AttributeOutputBase & AttrOutput() const =0
Access to the attribute output class.
RES_CHRATR_BIDIRTL
constexpr TypedWhichId< SfxInt16Item > RES_CHRATR_BIDIRTL(44)
MSWord_SdrAttrIter::WhereNext
sal_Int32 WhereNext() const
Definition: wrtww8.hxx:1488
MSWordExportBase::m_pOutFormatNode
const sw::BroadcastingModify * m_pOutFormatNode
Definition: wrtww8.hxx:537
sw::util::GetNoTextNodeFromSwFrameFormat
SwNoTextNode * GetNoTextNodeFromSwFrameFormat(const SwFrameFormat &rFormat)
Get the SwNoTextNode associated with a SwFrameFormat if here is one.
Definition: writerhelper.cxx:578
SwOLENode::GetAspect
sal_Int64 GetAspect() const
Definition: ndole.hxx:136
sw::WW8AnchorConv
WW8AnchorConv
Definition: frmfmt.hxx:296
AddMirrorFlags
static ShapeFlag AddMirrorFlags(ShapeFlag nFlags, const SwMirrorGrf &rMirror)
Definition: wrtw8esh.cxx:1547
WW8Export::pO
std::unique_ptr< ww::bytes > pO
Buffer.
Definition: wrtww8.hxx:991
WW8Export::pTableStrm
SvStream * pTableStrm
Definition: wrtww8.hxx:993
SwTextFormatColl
Represents the style of a paragraph.
Definition: fmtcol.hxx:56
WW8Export::GetHdFtIndex
unsigned int GetHdFtIndex() const
Definition: wrtww8.hxx:1132
Color::GetAlpha
sal_uInt8 GetAlpha() const
WW8Export::OutSwString
void OutSwString(const OUString &, sal_Int32 nStt, sal_Int32 nLen)
Definition: wrtww8.cxx:1833
RTLGraphicsHack
bool RTLGraphicsHack(SwTwips &rLeft, SwTwips nWidth, sal_Int16 eHoriOri, sal_Int16 eHoriRel, SwTwips nPageLeft, SwTwips nPageRight, SwTwips nPageSize)
Definition: wrtw8esh.cxx:531
SvxGrfCrop::GetLeft
sal_Int32 GetLeft() const
MSWord_SdrAttrIter::OutEEField
void OutEEField(const SfxPoolItem &rHt)
Definition: wrtw8esh.cxx:1100
MSWordExportBase::m_pFieldHFTextBxs
std::unique_ptr< WW8_WrPlcField > m_pFieldHFTextBxs
Definition: wrtww8.hxx:530
WW8Export::pFib
std::unique_ptr< WW8Fib > pFib
File Information Block.
Definition: wrtww8.hxx:995
WW8Export::AttrOutput
virtual AttributeOutputBase & AttrOutput() const override
memory leak #i120098#, to hold the reference to unnamed SotStorage obj
Definition: wrtww8.cxx:3930
WW8Export::GetSdrOrdNum
sal_uInt32 GetSdrOrdNum(const SwFrameFormat &rFormat) const
Definition: wrtw8esh.cxx:951
ESCHER_Prop_dyWrapDistBottom
#define ESCHER_Prop_dyWrapDistBottom
EE_FEATURE_TAB
constexpr sal_uInt16 EE_FEATURE_TAB(EE_FEATURE_START+0)
mso_lineDouble
mso_lineDouble
SvStream::WriteUInt16
SvStream & WriteUInt16(sal_uInt16 nUInt16)
SwNode::GetOLENode
SwOLENode * GetOLENode()
Inline methods from Node.hxx.
Definition: ndole.hxx:161
WW8Export::WriteStringAsPara
void WriteStringAsPara(const OUString &rText)
Definition: wrtww8.cxx:1777
ESCHER_Prop_pictureId
#define ESCHER_Prop_pictureId
MSWord_SdrAttrIter::GetNodeCharSet
rtl_TextEncoding GetNodeCharSet() const
Definition: wrtww8.hxx:1490
ESCHER_Prop_pictureActive
#define ESCHER_Prop_pictureActive
ESCHER_Prop_dyTextTop
#define ESCHER_Prop_dyTextTop
SvStream::WriteInt32
SvStream & WriteInt32(sal_Int32 nInt32)
ESCHER_Prop_cropFromBottom
#define ESCHER_Prop_cropFromBottom
SwEscherEx::aFollowShpIds
std::vector< sal_uLong > aFollowShpIds
Definition: escher.hxx:143
SwEscherEx::pTextBxs
WW8_WrPlcTextBoxes * pTextBxs
Definition: escher.hxx:146
pData
std::unique_ptr< ContentProperties > pData
GetValue
std::string GetValue
tools::Rectangle::getWidth
tools::Long getWidth() const
OBJ_GRUP
OBJ_GRUP
MSWord_SdrAttrIter::pEditPool
const SfxItemPool * pEditPool
Definition: wrtww8.hxx:1456
SfxPoolItem::Clone
virtual SfxPoolItem * Clone(SfxItemPool *pPool=nullptr) const =0
MSWord_SdrAttrIter::OutParaAttr
void OutParaAttr(bool bCharAttr, const std::set< sal_uInt16 > *pWhichsToIgnore=nullptr)
Definition: wrtw8esh.cxx:1275
SwFrameFormats::find
const_iterator find(const value_type &x) const
Definition: docfmt.cxx:2067
ESCHER_Prop_pictureBrightness
#define ESCHER_Prop_pictureBrightness
SwFormat::GetVertOrient
const SwFormatVertOrient & GetVertOrient(bool=true) const
Definition: fmtornt.hxx:106
SwPosition::nNode
SwNodeIndex nNode
Definition: pam.hxx:37
SwEscherExGlobal::mxPicStrm
std::shared_ptr< SvStream > mxPicStrm
Definition: escher.hxx:89
GPOS_NONE
GPOS_NONE
SwFrameFormats::begin
const_iterator begin() const
Definition: frameformats.hxx:98
ESCHER_Prop_lineWidth
#define ESCHER_Prop_lineWidth
SwEscherEx::WriteOCXControl
void WriteOCXControl(const SwFrameFormat &rFormat, sal_uInt32 nShapeId)
Definition: wrtw8esh.cxx:2922
SvxFormatBreakItem::GetBreak
SvxBreak GetBreak() const
FindPos
static sal_uInt16 FindPos(const SwFrameFormat &rFormat, unsigned int nHdFtIndex, DrawObjPointerVector &rPVec)
Definition: wrtw8esh.cxx:2832
DrawObj::SetShapeDetails
void SetShapeDetails(sal_uInt32 nId, sal_Int32 nThick)
Definition: wrtw8esh.cxx:905
ww::bytes
std::vector< sal_uInt8 > bytes
Definition: types.hxx:29
SwNoTextNode::GetTwipSize
virtual Size GetTwipSize() const =0
SwFormatHoriOrient::GetPos
SwTwips GetPos() const
Definition: fmtornt.hxx:92
sal_uLong
sal_uIntPtr sal_uLong
tools::Long
long Long
COL_TRANSPARENT
constexpr::Color COL_TRANSPARENT(ColorTransparency, 0xFF, 0xFF, 0xFF, 0xFF)
SwFrameFormat::FindLayoutRect
SwRect FindLayoutRect(const bool bPrtArea=false, const Point *pPoint=nullptr) const
Definition: atrfrm.cxx:2749
RES_CHRATR_FONTSIZE
constexpr TypedWhichId< SvxFontHeightItem > RES_CHRATR_FONTSIZE(8)
OBJ_LINE
OBJ_LINE
MSWord_SdrAttrIter::SetCharSet
void SetCharSet(const EECharAttrib &rTextAttr, bool bStart)
Definition: wrtw8esh.cxx:1074
EscherPropertyContainer::Commit
void Commit(SvStream &rSt, sal_uInt16 nVersion=3, sal_uInt16 nRecType=ESCHER_OPT)
o3tl::convert
constexpr Point convert(const Point &rPoint, o3tl::Length eFrom, o3tl::Length eTo)
ESCHER_Prop_pib
#define ESCHER_Prop_pib
WW8Export::MiserableFormFieldExportHack
bool MiserableFormFieldExportHack(const SwFrameFormat &rFrameFormat)
Definition: wrtw8esh.cxx:354
n
sal_Int64 n
SwMSDffManager::GetEscherLineMatch
static sal_Int32 GetEscherLineMatch(MSO_LineStyle eStyle, MSO_SPT eShapeType, sal_Int32 &rThick)
Definition: ww8graf.cxx:1520
RES_FRMATR_END
constexpr sal_uInt16 RES_FRMATR_END(133)
EscherEx::AddSdrObject
sal_uInt32 AddSdrObject(const SdrObject &rObj, bool ooxmlExport=false)
SdrObjList::GetObjCount
size_t GetObjCount() const
MSWord_SdrAttrIter::nPara
sal_Int32 nPara
Definition: wrtww8.hxx:1460
SvxBrushItem::GetGraphicObject
const GraphicObject * GetGraphicObject(OUString const &referer=OUString()) const
MSWord_SdrAttrIter::pEditObj
const EditTextObject * pEditObj
Definition: wrtww8.hxx:1455
PlcDrawObj::~PlcDrawObj
virtual ~PlcDrawObj()
Definition: wrtw8esh.cxx:523
aBuf
aBuf
ESCHER_ClientAnchor
#define ESCHER_ClientAnchor
ESCHER_Prop_lineStyle
#define ESCHER_Prop_lineStyle
SwEscherEx::WriteFlyFrameAttr
virtual sal_Int32 WriteFlyFrameAttr(const SwFrameFormat &rFormat, MSO_SPT eShapeType, EscherPropertyContainer &rPropOpt) override
Definition: wrtw8esh.cxx:2075
ESCHER_Prop_cropFromLeft
#define ESCHER_Prop_cropFromLeft
EECharAttrib::pAttr
const SfxPoolItem * pAttr
nId
sal_Int16 nId
SvxBoxItem::GetDistance
sal_uInt16 GetDistance(SvxBoxItemLine nLine) const
MSWordExportBase::CollapseScriptsforWordOk
virtual bool CollapseScriptsforWordOk(sal_uInt16 nScript, sal_uInt16 nWhich)=0
Guess the script (asian/western).
SfxWhichIter::FirstWhich
sal_uInt16 FirstWhich()
SwGrfNode::IsLinkedFile
bool IsLinkedFile() const
Definition: ndgrf.hxx:164
mxModel
css::uno::Reference< css::frame::XModel2 > mxModel
SvStream::Seek
sal_uInt64 Seek(sal_uInt64 nPos)
HdFtPlcDrawObj::GetCpOffset
virtual WW8_CP GetCpOffset(const WW8Fib &rFib) const override
Definition: wrtw8esh.cxx:874
RES_BREAK
constexpr TypedWhichId< SvxFormatBreakItem > RES_BREAK(94)
SwNodeIndex::GetNode
SwNode & GetNode() const
Definition: ndindex.hxx:119
aId
OUString aId
SwWW8Writer::WriteString8
static void WriteString8(SvStream &rStrm, std::u16string_view rStr, bool bAddZero, rtl_TextEncoding eCodeSet)
Definition: wrtww8.cxx:1764
ESCHER_Prop_txflTextFlow
#define ESCHER_Prop_txflTextFlow
sw::WW8FFData::setResult
void setResult(sal_uInt8 nResult)
Definition: WW8FFData.hxx:72
SvxFrameDirection
SvxFrameDirection
INetURLObject::GetRelURL
static OUString GetRelURL(OUString const &rTheBaseURIRef, OUString const &rTheAbsURIRef, EncodeMechanism eEncodeMechanism=EncodeMechanism::WasEncoded, DecodeMechanism eDecodeMechanism=DecodeMechanism::ToIUri, rtl_TextEncoding eCharset=RTL_TEXTENCODING_UTF8, FSysStyle eStyle=FSysStyle::Detect)
SwDoc::GetTextDirection
SvxFrameDirection GetTextDirection(const SwPosition &rPos, const Point *pPt=nullptr) const
Definition: doclay.cxx:1611
SwBasicEscherEx::WriteOLEFlyFrame
sal_Int32 WriteOLEFlyFrame(const SwFrameFormat &rFormat, sal_uInt32 nShapeId)
Definition: wrtw8esh.cxx:1786
sw::WW8FFData::addListboxEntry
void addListboxEntry(const OUString &rEntry)
Definition: WW8FFData.cxx:63
RES_GRFATR_CONTRAST
constexpr TypedWhichId< SwContrastGrf > RES_GRFATR_CONTRAST(137)
WinwordAnchoring::SetAnchoring
void SetAnchoring(const SwFrameFormat &rFormat)
Definition: wrtw8esh.cxx:2597
WW8Export::Fc2Cp
WW8_CP Fc2Cp(sal_uLong nFc) const
Definition: wrtww8.hxx:1100
EscherEx::AddShape
virtual void AddShape(sal_uInt32 nShpInstance, ShapeFlag nFlagIds, sal_uInt32 nShapeID=0)
ww::eCONTROL
eCONTROL
SwRect
Of course Writer needs its own rectangles.
Definition: swrect.hxx:34
MSWordExportBase::m_pFieldTextBxs
std::unique_ptr< WW8_WrPlcField > m_pFieldTextBxs
Definition: wrtww8.hxx:529
Set_UInt32
void Set_UInt32(sal_uInt8 *&p, sal_uInt32 n)
Definition: ww8struc.hxx:53
make_shared
std::shared_ptr< T > make_shared(Args &&...args)
WW8Export::AppendFlyInFlys
void AppendFlyInFlys(const ww8::Frame &rFrameFormat, const Point &rNdTopLeft)
Definition: wrtw8esh.cxx:971
PlcDrawObj::GetObjArr
DrawObjVector & GetObjArr()
Definition: wrtww8.hxx:376
SdrObject::GetObjIdentifier
virtual SdrObjKind GetObjIdentifier() const
SvxBrushItem::Clone
virtual SvxBrushItem * Clone(SfxItemPool *pPool=nullptr) const override
MSWord_SdrAttrIter
Used to export formatted text associated to drawings.
Definition: wrtww8.hxx:1452
nInlineHack
const sal_uInt32 nInlineHack
Definition: escher.hxx:27
SdrTextObj::IsTextEditActive
bool IsTextEditActive() const
SwFormatVertOrient::GetRelationOrient
sal_Int16 GetRelationOrient() const
Definition: fmtornt.hxx:55
SwEscherEx::WriteFrameExtraData
virtual void WriteFrameExtraData(const SwFrameFormat &rFormat) override
Definition: wrtw8esh.cxx:2732
pObject
EmbeddedObjectRef * pObject
EscherEx::mxGlobal
std::shared_ptr< EscherExGlobal > mxGlobal
MSWordExportBase::GetCurItemSet
const SfxItemSet * GetCurItemSet() const
Getter for pISet.
Definition: wrtww8.hxx:729
ESCHER_ClientTextbox
#define ESCHER_ClientTextbox
ePos
css::chart::ChartAxisLabelPosition ePos
FieldString
OUString FieldString(ww::eField eIndex)
Definition: ww8atr.cxx:2680
WW8Export::TrueFrameBgBrush
std::shared_ptr< SvxBrushItem > TrueFrameBgBrush(const SwFrameFormat &rFlyFormat) const
Definition: wrtw8nds.cxx:1692
oox::ole::MSConvertOCXControls::ReadOCXStorage
bool ReadOCXStorage(tools::SvRef< SotStorage > const &rSrc1, css::uno::Reference< css::form::XFormComponent > &rxFormComp)
SwDoc::GetSpzFrameFormats
const SwFrameFormats * GetSpzFrameFormats() const
Definition: doc.hxx:744
oox::ole::MSConvertOCXControls::WriteOCXStream
static bool WriteOCXStream(const css::uno::Reference< css::frame::XModel > &rxModel, tools::SvRef< SotStorage > const &rSrc1, const css::uno::Reference< css::awt::XControlModel > &rControlModel, const css::awt::Size &rSize, OUString &rName)
RES_GRFATR_LUMINANCE
constexpr TypedWhichId< SwLuminanceGrf > RES_GRFATR_LUMINANCE(136)
SwInputField::GetHelp
const OUString & GetHelp() const
Definition: expfld.cxx:1409
EE_PARA_WRITINGDIR
constexpr TypedWhichId< SvxFrameDirectionItem > EE_PARA_WRITINGDIR(EE_PARA_START+0)
MainTextPlcDrawObj::GetCpOffset
virtual WW8_CP GetCpOffset(const WW8Fib &) const override
Definition: wrtw8esh.cxx:862
RES_FLYFRMFMT
constexpr TypedWhichId< SwFlyFrameFormat > RES_FLYFRMFMT(156)
SfxWhichIter::NextWhich
sal_uInt16 NextWhich()
SwEscherEx::SetPicId
virtual void SetPicId(const SdrObject &rSdrObj, sal_uInt32 nShapeId, EscherPropertyContainer &rPropOpt) override
Definition: wrtw8esh.cxx:1777
SwBasicEscherEx::SetPicId
virtual void SetPicId(const SdrObject &, sal_uInt32, EscherPropertyContainer &)
Definition: wrtw8esh.cxx:1772
SwDoc::getIDocumentDrawModelAccess
IDocumentDrawModelAccess const & getIDocumentDrawModelAccess() const
Definition: doc.cxx:155
EscherEx::GenerateShapeId
virtual sal_uInt32 GenerateShapeId()
MSWordExportBase::m_pHFSdrObjs
std::unique_ptr< HdFtPlcDrawObj > m_pHFSdrObjs
Definition: wrtww8.hxx:541
SdrObject::GetSnapRect
virtual const tools::Rectangle & GetSnapRect() const
convertTwipToMm100
constexpr auto convertTwipToMm100(N n)
Application::GetDefaultDevice
static OutputDevice * GetDefaultDevice()
WinwordAnchoring::ConvertPosition
static bool ConvertPosition(SwFormatHoriOrient &_iorHoriOri, SwFormatVertOrient &_iorVertOri, const SwFrameFormat &_rFrameFormat)
method to perform conversion of positioning attributes with the help of corresponding layout informat...
Definition: wrtw8esh.cxx:2401
tools::Rectangle::getHeight
tools::Long getHeight() const
mso_lineThickThin
mso_lineThickThin
mso_sptPictureFrame
mso_sptPictureFrame
m_rDoc
SwDoc & m_rDoc
Definition: docbm.cxx:1208
ESCHER_Prop_dxWrapDistLeft
#define ESCHER_Prop_dxWrapDistLeft
EscherEx::GetStream
SvStream & GetStream() const
MSWordExportBase::m_pEscher
SwEscherEx * m_pEscher
Definition: wrtww8.hxx:543
SwEscherEx::QueryTextID
virtual sal_uInt32 QueryTextID(const css::uno::Reference< css::drawing::XShape > &, sal_uInt32) override
Definition: wrtw8esh.cxx:2998
SfxItemIter::NextItem
const SfxPoolItem * NextItem()
SwFormat::makeBackgroundBrushItem
std::unique_ptr< SvxBrushItem > makeBackgroundBrushItem(bool=true) const
Definition: format.cxx:742
SvxBrushItem::GetGraphicPos
SvxGraphicPosition GetGraphicPos() const
PlcDrawObj::WritePlc
void WritePlc(WW8Export &rWrt) const
Definition: wrtw8esh.cxx:618
ESCHER_Prop_wzName
#define ESCHER_Prop_wzName
SwBasicEscherEx::WriteFlyFrameAttr
virtual sal_Int32 WriteFlyFrameAttr(const SwFrameFormat &rFormat, MSO_SPT eShapeType, EscherPropertyContainer &rPropOpt)
Definition: wrtw8esh.cxx:1888
MSO_LineDashing
MSO_LineDashing
SvxShadowItem::GetLocation
SvxShadowLocation GetLocation() const
SotStorage::OpenSotStorage
SotStorage * OpenSotStorage(const OUString &rEleName, StreamMode=StreamMode::STD_READWRITE, bool transacted=true)
WW8Export::OutputField
virtual void OutputField(const SwField *pField, ww::eField eFieldType, const OUString &rFieldCmd, FieldFlags nMode=FieldFlags::All) override
Write the field.
Definition: ww8atr.cxx:1810
RES_PARATR_BEGIN
constexpr sal_uInt16 RES_PARATR_BEGIN(RES_TXTATR_END)
SwFormatHoriOrient::SetHoriOrient
void SetHoriOrient(sal_Int16 eNew)
Definition: fmtornt.hxx:89
SwNode::GetNodeType
SwNodeType GetNodeType() const
Definition: node.hxx:145
tools::Rectangle::Left
tools::Long Left() const
MSWordAttrIter::m_rExport
MSWordExportBase & m_rExport
Definition: wrtww8.hxx:1442
MSO_SPT
MSO_SPT
EscherEx::Flush
void Flush(SvStream *pPicStreamMergeBSE=nullptr)
SdrExchangeView::GetObjGraphic
static Graphic GetObjGraphic(const SdrObject &rSdrObject)
GraphicObject::GetUniqueID
OString GetUniqueID() const
INET_FILE_SCHEME
#define INET_FILE_SCHEME
SwDoc::getIDocumentStylePoolAccess
IDocumentStylePoolAccess const & getIDocumentStylePoolAccess() const
Definition: doc.cxx:426
SwBasicEscherEx::WriteHyperlinkWithinFly
void WriteHyperlinkWithinFly(SvMemoryStream &rStrm, const SwFormatURL *pINetFormatArg)
Definition: wrtw8esh.cxx:169
SwBasicEscherEx::SwBasicEscherEx
SwBasicEscherEx(SvStream *pStrm, WW8Export &rWrt)
Definition: wrtw8esh.cxx:1518
SwMSConvertControls::SwMSConvertControls
SwMSConvertControls(SfxObjectShell const *pDSh, SwPaM *pP)
Definition: wrtw8esh.cxx:3011
g_pBreakIt
SwBreakIt * g_pBreakIt
Definition: breakit.cxx:33
DFF_msofbtUDefProp
#define DFF_msofbtUDefProp
tools::Rectangle::Bottom
tools::Long Bottom() const
WW8Export::GetCurrentPageBgBrush
const SvxBrushItem * GetCurrentPageBgBrush() const
Definition: wrtw8nds.cxx:1673
MSWord_SdrAttrIter::SearchNext
sal_Int32 SearchNext(sal_Int32 nStartPos)
Definition: wrtw8esh.cxx:1052
MSWordExportBase::m_bInWriteEscher
bool m_bInWriteEscher
Definition: wrtww8.hxx:558
EscherExHostAppData::SetClientData
void SetClientData(EscherExClientRecord_Base *p)
SwRect::Width
void Width(tools::Long nNew)
Definition: swrect.hxx:186
PlcDrawObj::Append
bool Append(WW8Export const &, WW8_CP nCp, const ww8::Frame &rFormat, const Point &rNdTopLeft)
Definition: wrtw8esh.cxx:879
wwUtility::RGBToBGR
sal_uInt32 RGBToBGR(::Color nColour)
Definition: ww8struc.hxx:1088
SvStream::WriteUInt32
SvStream & WriteUInt32(sal_uInt32 nUInt32)
WinwordAnchoring::mnXAlign
sal_uInt32 mnXAlign
Definition: escher.hxx:71
SwFormat::GetSurround
const SwFormatSurround & GetSurround(bool=true) const
Definition: fmtsrnd.hxx:66
NormAngle36000
Degree100 NormAngle36000(Degree100 deg100)
o3tl::strong_int< sal_Int32, struct Degree100Tag >
SvxBrushItem::GetGraphic
const Graphic * GetGraphic(OUString const &referer=OUString()) const
mso_txflHorzN
mso_txflHorzN
EditTextObject::GetParaAttribs
virtual const SfxItemSet & GetParaAttribs(sal_Int32 nPara) const =0
AttributeOutputBase::RawText
virtual void RawText(const OUString &rText, rtl_TextEncoding eCharSet)=0
Output text (without markup).
WW8Export::WriteChar
void WriteChar(sal_Unicode c) override
Definition: wrtww8.cxx:1870
INetProtocol
INetProtocol
SwGrfNode::GetFileFilterNms
bool GetFileFilterNms(OUString *pFileNm, OUString *pFilterNm) const
Definition: ndgrf.cxx:494
SvStream::remainingSize
sal_uInt64 remainingSize()
SwBasicEscherEx::WriteBrushAttr
void WriteBrushAttr(const SvxBrushItem &rBrush, EscherPropertyContainer &rPropOpt)
Definition: wrtw8esh.cxx:1845
MSWord_SdrAttrIter::NextPos
void NextPos()
Definition: wrtww8.hxx:1483
SwBasicEscherEx::GetInvisibleHellId
SdrLayerID GetInvisibleHellId() const
Definition: wrtw8esh.cxx:2180
SwBasicEscherEx::ToFract16
static sal_Int32 ToFract16(sal_Int32 nVal, sal_uInt32 nMax)
Definition: wrtw8esh.cxx:2159
ESCHER_Prop_fillOpacity
#define ESCHER_Prop_fillOpacity
AttributeOutputBase::OutputItem
void OutputItem(const SfxPoolItem &rHt)
Call the right virtual function according to the type of the item.
Definition: ww8atr.cxx:5346
SwBasicEscherEx::BuildFileName
OUString BuildFileName(sal_uInt16 &rnLevel, bool &rbRel, const OUString &rUrl)
Definition: wrtw8esh.cxx:134
SwBasicEscherEx::WriteGrfBullet
void WriteGrfBullet(const Graphic &)
Definition: wrtw8esh.cxx:1568
SwBasicEscherEx::GetBasePath
OUString GetBasePath() const
Definition: wrtw8esh.cxx:116
sName
const char * sName
EscherEx::AddDummyShape
sal_uInt32 AddDummyShape()
EscherEx::QueryPictureStream
SvStream * QueryPictureStream()
WW8Fib::m_lcbPlcfspaMom
sal_Int32 m_lcbPlcfspaMom
Definition: ww8scan.hxx:1388
SwFormatURL::GetName
const OUString & GetName() const
Definition: fmturl.hxx:71
ww8::Frame::GetFrameFormat
const SwFrameFormat & GetFrameFormat() const
Get the writer SwFrameFormat that this object describes.
Definition: writerhelper.hxx:113
ESCHER_Prop_dyTextBottom
#define ESCHER_Prop_dyTextBottom
ESCHER_Prop_cropFromTop
#define ESCHER_Prop_cropFromTop
DrawObj::mnDirection
SvxFrameDirection mnDirection
Definition: wrtww8.hxx:348
PlcDrawObj::size
int size()
Definition: wrtww8.hxx:375
GraphicDrawMode
GraphicDrawMode
IDocumentDrawModelAccess::GetInvisibleHellId
virtual SdrLayerID GetInvisibleHellId() const =0
ESCHER_Prop_fNoLineDrawDash
#define ESCHER_Prop_fNoLineDrawDash
SwMSConvertControls::ExportControl
void ExportControl(WW8Export &rWrt, const SdrUnoObj &rFormObj)
Definition: wrtw8esh.cxx:3033
SwWW8Writer::WriteString16
static void WriteString16(SvStream &rStrm, const OUString &rStr, bool bAddZero)
Definition: wrtww8.cxx:1741
ESCHER_Prop_lineDashing
#define ESCHER_Prop_lineDashing
SvxBrushItem::GetColor
const Color & GetColor() const
SdrTextObj::CreateEditOutlinerParaObject
std::unique_ptr< OutlinerParaObject > CreateEditOutlinerParaObject() const
DFF_Prop_shadowOffsetX
#define DFF_Prop_shadowOffsetX
conversionFract
Fraction conversionFract(o3tl::Length from, o3tl::Length to)
MSWord_SdrAttrIter::nTmpSwPos
sal_Int32 nTmpSwPos
Definition: wrtww8.hxx:1462
ShapeFlag
ShapeFlag
SwPaM
PaM is Point and Mark: a selection of the document model.
Definition: pam.hxx:136
SvxShadowItem::GetColor
const Color & GetColor() const
ESCHER_Prop_lineBackColor
#define ESCHER_Prop_lineBackColor
ESCHER_ShpInst_TextBox
#define ESCHER_ShpInst_TextBox
MSWordExportBase::m_pPapPlc
std::unique_ptr< WW8_WrPlcPn > m_pPapPlc
Definition: wrtww8.hxx:498
SwFormat::GetFollowTextFlow
const SwFormatFollowTextFlow & GetFollowTextFlow(bool=true) const
Definition: fmtfollowtextflow.hxx:51
OutlinerParaObject::GetTextObject
const EditTextObject & GetTextObject() const
sw::util::CorrectWordWrapPolygonForExport
tools::Polygon CorrectWordWrapPolygonForExport(const tools::PolyPolygon &rPolyPoly, const SwNoTextNode *pNd, bool bCorrectCrop)
Undo all scaling / move tricks of the wrap polygon done during import.
Definition: writerhelper.cxx:648
SwFrameFormat
Style of a layout element.
Definition: frmfmt.hxx:58
sw::WW8FFData::setName
void setName(const OUString &rName)
Definition: WW8FFData.hxx:74
ESCHER_Prop_pictureContrast
#define ESCHER_Prop_pictureContrast
SAL_MAX_INT32
#define SAL_MAX_INT32
SfxItemSet::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
MSWordExportBase::SetCurItemSet
void SetCurItemSet(const SfxItemSet *pS)
Setter for pISet.
Definition: wrtww8.hxx:732
SwEscherEx::aHostData
EscherExHostAppData aHostData
Definition: escher.hxx:144
SwFormat::GetAnchor
const SwFormatAnchor & GetAnchor(bool=true) const
Definition: fmtanchr.hxx:81
i
int i
DFF_Prop_shadowOffsetY
#define DFF_Prop_shadowOffsetY
ESCHER_BlipFlagDoNotSave
ESCHER_BlipFlagDoNotSave
WW8Fib::m_ccpHdrTxbx
WW8_CP m_ccpHdrTxbx
Definition: ww8scan.hxx:1216
SwFormatVertOrient::SetVertOrient
void SetVertOrient(sal_Int16 eNew)
Definition: fmtornt.hxx:56
MSWord_SdrAttrIter::HasTextItem
virtual const SfxPoolItem * HasTextItem(sal_uInt16 nWhich) const override
Definition: wrtw8esh.cxx:1214
mso_lineDashGEL
mso_lineDashGEL
SwFormatAnchor::GetAnchorId
RndStdIds GetAnchorId() const
Definition: fmtanchr.hxx:65
SwDoc::GetPageDesc
const SwPageDesc & GetPageDesc(const size_t i) const
Definition: doc.hxx:881
STREAM_SEEK_TO_BEGIN
#define STREAM_SEEK_TO_BEGIN
ESCHER_Prop_dxWrapDistRight
#define ESCHER_Prop_dxWrapDistRight
SwFormat::GetHoriOrient
const SwFormatHoriOrient & GetHoriOrient(bool=true) const
Definition: fmtornt.hxx:108
SwFormatAnchor::GetContentAnchor
const SwPosition * GetContentAnchor() const
Definition: fmtanchr.hxx:67
SwEscherEx::WritePictures
virtual void WritePictures() override
Definition: wrtw8esh.cxx:1486
WinwordAnchoring::mnXRelTo
sal_uInt32 mnXRelTo
Definition: escher.hxx:73
MSWordExportBase::m_pHFTextBxs
std::unique_ptr< WW8_WrPlcTextBoxes > m_pHFTextBxs
Definition: wrtww8.hxx:504
RES_URL
constexpr TypedWhichId< SwFormatURL > RES_URL(111)
ESCHER_BlipFlagLinkToFile
ESCHER_BlipFlagLinkToFile
SwBasicEscherEx::IsRelUrl
bool IsRelUrl() const
Definition: wrtw8esh.cxx:105
RES_GRFATR_CROPGRF
constexpr TypedWhichId< SwCropGrf > RES_GRFATR_CROPGRF(134)
tools::Rectangle::SetSize
void SetSize(const Size &rSize)
WW8_WrPlcTextBoxes::GetPos
sal_uInt16 GetPos(const void *p) const
Definition: wrtww8.hxx:1302
MSWord_SdrAttrIter::aChrSetArr
std::vector< rtl_TextEncoding > aChrSetArr
Definition: wrtww8.hxx:1459
SwFormatVertOrient::SetPos
void SetPos(SwTwips nNew)
Definition: fmtornt.hxx:60
HdFtPlcDrawObj::RegisterWithFib
virtual void RegisterWithFib(WW8Fib &rFib, sal_uInt32 nStart, sal_uInt32 nLen) const override
Definition: wrtw8esh.cxx:867
DFF_Prop_shadowColor
#define DFF_Prop_shadowColor
CntUnencodedStringItem::GetValue
const OUString & GetValue() const
EditTextObject::GetText
virtual OUString GetText(sal_Int32 nPara) const =0
SwWW8Writer::WriteShort
static void WriteShort(SvStream &rStrm, sal_Int16 nVal)
Definition: wrtww8.hxx:961
FrPair::X
const Fraction & X() const
SdrModel::GetPage
const SdrPage * GetPage(sal_uInt16 nPgNum) const
SwEscherEx::FinishEscher
void FinishEscher()
Definition: wrtw8esh.cxx:2339
IDocumentDrawModelAccess::GetDrawModel
virtual const SwDrawModel * GetDrawModel() const =0
Draw Model and id accessors.
MSWord_SdrAttrIter::eNdChrSet
rtl_TextEncoding eNdChrSet
Definition: wrtww8.hxx:1463
SvStream::WriteBytes
std::size_t WriteBytes(const void *pData, std::size_t nSize)
SwBasicEscherEx::DrawModelToEmu
sal_Int32 DrawModelToEmu(sal_Int32 nVal) const
Definition: escher.hxx:110
SvxGraphicPosition
SvxGraphicPosition
SwMSConvertControls::InsertControl
virtual bool InsertControl(const css::uno::Reference< css::form::XFormComponent > &rFComp, const css::awt::Size &rSize, css::uno::Reference< css::drawing::XShape > *pShape, bool bFloatingCtrl) override
Definition: ww8par3.cxx:2535
WW8Export::MiserableRTLFrameFormatHack
void MiserableRTLFrameFormatHack(SwTwips &rLeft, SwTwips &rRight, const ww8::Frame &rFrameFormat)
Nasty swap for bidi if necessary.
Definition: wrtw8esh.cxx:583
SwFormatHoriOrient::GetHoriOrient
sal_Int16 GetHoriOrient() const
Definition: fmtornt.hxx:87
WinwordAnchoring::WriteData
void WriteData(EscherEx &rEx) const override
Definition: wrtw8esh.cxx:1429
WW8Export::DoComboBox
void DoComboBox(css::uno::Reference< css::beans::XPropertySet > const &xPropSet)
SdrObject::GetOrdNum
sal_uInt32 GetOrdNum() const
SwBasicEscherEx::mnEmuMul
tools::Long mnEmuMul
Definition: escher.hxx:99
mso_txflBtoT
mso_txflBtoT
MSWordExportBase::m_rDoc
SwDoc & m_rDoc
Definition: wrtww8.hxx:574
SwFormatSurround::GetSurround
css::text::WrapTextMode GetSurround() const
Definition: fmtsrnd.hxx:51
GetSdrObjectFromXShape
SVXCORE_DLLPUBLIC SdrObject * GetSdrObjectFromXShape(const css::uno::Reference< css::drawing::XShape > &xShape) noexcept
mso_lineThinThick
mso_lineThinThick
SfxMedium::GetItemSet
SfxItemSet * GetItemSet() const
WW8Export::WriteCR
virtual void WriteCR(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner=ww8::WW8TableNodeInfoInner::Pointer_t()) override
Definition: wrtww8.cxx:1860
SwFormat::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
Definition: format.cxx:388
sw::WW8FFData::setType
void setType(sal_uInt8 nType)
Definition: WW8FFData.hxx:70
SwFormatChain
Connection (text flow) between two FlyFrames.
Definition: fmtcnct.hxx:31
DFF_Prop_pWrapPolygonVertices
#define DFF_Prop_pWrapPolygonVertices
tools::Polygon::GetSize
sal_uInt16 GetSize() const
ESCHER_FillPicture
ESCHER_FillPicture
SwNodeIndex
Marks a node in the document model.
Definition: ndindex.hxx:31
SwEscherEx::GetFlyShapeId
sal_uInt32 GetFlyShapeId(const SwFrameFormat &rFormat, unsigned int nHdFtIndex, DrawObjPointerVector &rPVec)
Definition: wrtw8esh.cxx:2979
WW8Export::GetWriter
SwWW8Writer & GetWriter() const
Definition: wrtww8.hxx:1180
SfxItemPool::GetSlotId
sal_uInt16 GetSlotId(sal_uInt16 nWhich) const
SwEscherEx::WriteFlyFrame
sal_Int32 WriteFlyFrame(const DrawObj &rObj, sal_uInt32 &rShapeId, DrawObjPointerVector &rPVec)
Definition: wrtw8esh.cxx:2744
WW8_WrPlcTextBoxes::WriteText
bool WriteText(WW8Export &rWrt)
Definition: wrtw8esh.cxx:911
SwFormat::GetDoc
const SwDoc * GetDoc() const
The document is set in SwAttrPool now, therefore you always can access it.
Definition: format.hxx:123
SwFormat::getIDocumentSettingAccess
const IDocumentSettingAccess & getIDocumentSettingAccess() const
Provides access to the document settings interface.
Definition: format.cxx:717
WW8Fib::m_ccpTxbx
WW8_CP m_ccpTxbx
Definition: ww8scan.hxx:1215
sw::WW8FFData::Write
void Write(SvStream *pDataStrm)
Definition: WW8FFData.cxx:77
tools::Rectangle::Top
tools::Long Top() const
ESCHER_Prop_dyWrapDistTop
#define ESCHER_Prop_dyWrapDistTop
GPOS_AREA
GPOS_AREA
SvStream::WriteStream
SvStream & WriteStream(SvStream &rStream)
EscherEx::EndSdrObjectPage
void EndSdrObjectPage()
sw::hack::TransformWhichBetweenPools
sal_uInt16 TransformWhichBetweenPools(const SfxItemPool &rDestPool, const SfxItemPool &rSrcPool, sal_uInt16 nWhich)
Map an ID valid in one SfxItemPool to its equivalent in another.
Definition: writerhelper.cxx:268
ESCHER_Prop_cropFromRight
#define ESCHER_Prop_cropFromRight
MSWordExportBase::m_pSdrObjs
std::unique_ptr< MainTextPlcDrawObj > m_pSdrObjs
Definition: wrtww8.hxx:540
ESCHER_BlipFlagDefault
ESCHER_BlipFlagDefault
nLineWidth
sal_Int32 nLineWidth
SwTwips
tools::Long SwTwips
Definition: swtypes.hxx:50
WW8Fib::m_lcbPlcfspaHdr
sal_Int32 m_lcbPlcfspaHdr
Definition: ww8scan.hxx:1393
SwBasicEscherEx::mnEmuDiv
tools::Long mnEmuDiv
Definition: escher.hxx:99
ESCHER_Prop_pibName
#define ESCHER_Prop_pibName
Y
#define Y
SwFormatChain::GetNext
SwFlyFrameFormat * GetNext() const
Definition: fmtcnct.hxx:54
ESCHER_Prop_fillBlip
#define ESCHER_Prop_fillBlip
SdrObject::GetObjInventor
virtual SdrInventor GetObjInventor() const
ESCHER_Prop_shadowColor
#define ESCHER_Prop_shadowColor
EscherEx::GetGroupLevel
sal_uInt32 GetGroupLevel() const
WW8_CP
sal_Int32 WW8_CP
Definition: ww8struc.hxx:153
sw::WW8FFData::setStatus
void setStatus(const OUString &rStatus)
Definition: WW8FFData.cxx:57
tools::Rectangle::TopLeft
constexpr Point TopLeft() const
IDocumentDrawModelAccess::GetHellId
virtual SdrLayerID GetHellId() const =0
ESCHER_Prop_fillBackColor
#define ESCHER_Prop_fillBackColor
ESCHER_Prop_hspNext
#define ESCHER_Prop_hspNext
SdrObject::GetLayer
virtual SdrLayerID GetLayer() const
sw::WW8FFData::setHelp
void setHelp(const OUString &rHelp)
Definition: WW8FFData.cxx:51
WinwordAnchoring::mnYAlign
sal_uInt32 mnYAlign
Definition: escher.hxx:72
ww::eFORMTEXT
eFORMTEXT
SwFormatContent::GetContentIdx
const SwNodeIndex * GetContentIdx() const
Definition: fmtcntnt.hxx:46
SwEscherEx::~SwEscherEx
virtual ~SwEscherEx() override
Definition: wrtw8esh.cxx:2335
SvStream::ReadBytes
std::size_t ReadBytes(void *pData, std::size_t nSize)
ESCHER_Prop_dxTextLeft
#define ESCHER_Prop_dxTextLeft
RES_UNKNOWNATR_BEGIN
constexpr sal_uInt16 RES_UNKNOWNATR_BEGIN(RES_BOXATR_END)
SwBreakIt::GetBreakIter
css::uno::Reference< css::i18n::XBreakIterator > const & GetBreakIter() const
Definition: breakit.hxx:62
SvxGrfCrop::GetBottom
sal_Int32 GetBottom() const
ESCHER_Prop_fillColor
#define ESCHER_Prop_fillColor
SwAttrSet::GetMirrorGrf
const SwMirrorGrf & GetMirrorGrf(bool=true) const
Definition: grfatr.hxx:282
SwFormat::Which
sal_uInt16 Which() const
for Querying of Writer-functions.
Definition: format.hxx:82
WW8Fib::m_ccpEdn
WW8_CP m_ccpEdn
Definition: ww8scan.hxx:1214
WW8Fib::m_fcPlcfspaHdr
WW8_FC m_fcPlcfspaHdr
Definition: ww8scan.hxx:1390
ESCHER_DggContainer
#define ESCHER_DggContainer
WW8_WrPlcTextBoxes::GetShapeIdArr
virtual const std::vector< sal_uInt32 > * GetShapeIdArr() const override
Definition: wrtw8esh.cxx:946
SvxGrfCrop::GetTop
sal_Int32 GetTop() const
SwPageDesc::GetMaster
SwFrameFormat & GetMaster()
Definition: pagedesc.hxx:238
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
SwTextNode
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:79
sw::IsFlyFrameFormatInHeader
bool IsFlyFrameFormatInHeader(const SwFrameFormat &rFormat)
Definition: atrfrm.cxx:3641
ESCHER_SpContainer
#define ESCHER_SpContainer
ESCHER_Prop_fBackground
#define ESCHER_Prop_fBackground
DrawObj::mnHdFtIndex
unsigned int mnHdFtIndex
Definition: wrtww8.hxx:349
SwField::ExpandField
OUString ExpandField(bool bCached, SwRootFrame const *pLayout) const
expand the field.
Definition: fldbas.cxx:465
SwFormatHoriOrient::IsPosToggle
bool IsPosToggle() const
Definition: fmtornt.hxx:95
SwBasicEscherEx::WriteGrfAttr
static void WriteGrfAttr(const SwNoTextNode &rNd, const SwFrameFormat &rFormat, EscherPropertyContainer &rPropOpt)
Definition: wrtw8esh.cxx:1665
StgWriter::GetStorage
SotStorage & GetStorage() const
Definition: shellio.hxx:499
WW8_WrPlcTextBoxes::Append
void Append(const SdrObject &rObj, sal_uInt32 nShapeId)
Definition: wrtw8esh.cxx:930
GetMapFactor
FrPair GetMapFactor(MapUnit eS, MapUnit eD)
mso_sptTextBox
mso_sptTextBox
RES_TXTATR_END
constexpr sal_uInt16 RES_TXTATR_END(RES_TXTATR_NOEND_END)
EscherEx::CloseContainer
virtual void CloseContainer()
SfxItemState
SfxItemState
ESCHER_ShpInst_PictureFrame
#define ESCHER_ShpInst_PictureFrame
RES_CHRATR_BEGIN
constexpr sal_uInt16 RES_CHRATR_BEGIN(HINT_BEGIN)
RES_BACKGROUND
constexpr TypedWhichId< SvxBrushItem > RES_BACKGROUND(105)
SwFormat::GetChain
const SwFormatChain & GetChain(bool=true) const
Definition: fmtcnct.hxx:70
SwEscherEx::MakeZOrderArrAndFollowIds
void MakeZOrderArrAndFollowIds(std::vector< DrawObj > &rSrcArr, DrawObjPointerVector &rDstArr)
Definition: wrtw8esh.cxx:2953
Fraction::GetDenominator
sal_Int32 GetDenominator() const
WW8Export::Strm
SvStream & Strm() const
Definition: wrtww8.hxx:1181
SwFormatHoriOrient::GetRelationOrient
sal_Int16 GetRelationOrient() const
Definition: fmtornt.hxx:88
EscherEx::AddAtom
void AddAtom(sal_uInt32 nAtomSitze, sal_uInt16 nRecType, int nRecVersion=0, int nRecInstance=0)
MSWord_SdrAttrIter::mnTyp
sal_uInt8 mnTyp
Definition: wrtww8.hxx:1465
SfxItemSet::Get
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
SfxItemPool::GetWhich
sal_uInt16 GetWhich(sal_uInt16 nSlot, bool bDeep=true) const
ESCHER_ShpInst_Rectangle
#define ESCHER_ShpInst_Rectangle
sal_uInt8
unsigned char sal_uInt8
SdrTextObj::GetOutlinerParaObject
virtual OutlinerParaObject * GetOutlinerParaObject() const override
ww8::Frame
Make exporting a Writer Frame easy.
Definition: writerhelper.hxx:86
SwBasicEscherEx::WriteFrameExtraData
virtual void WriteFrameExtraData(const SwFrameFormat &)
Definition: wrtw8esh.cxx:1528
ESCHER_Prop_lineColor
#define ESCHER_Prop_lineColor
SfxMedium::IsRemote
bool IsRemote() const
tools::Rectangle::setWidth
void setWidth(tools::Long n)
SwFormatVertOrient::GetPos
SwTwips GetPos() const
Definition: fmtornt.hxx:59
ESCHER_Prop_fNoFillHitTest
#define ESCHER_Prop_fNoFillHitTest
EditTextObject::GetParagraphCount
virtual sal_Int32 GetParagraphCount() const =0
SwFormatURL::GetTargetFrameName
const OUString & GetTargetFrameName() const
Definition: fmturl.hxx:65
MSWord_SdrAttrIter::nScript
sal_uInt16 nScript
Definition: wrtww8.hxx:1464
MSWord_SdrAttrIter::IsTextAttr
bool IsTextAttr(sal_Int32 nSwPos)
Definition: wrtw8esh.cxx:1198
EscherEx::OpenContainer
virtual void OpenContainer(sal_uInt16 nEscherContainer, int nRecInstance=0)
MSWord_SdrAttrIter::aTextAtrArr
std::vector< EECharAttrib > aTextAtrArr
Definition: wrtww8.hxx:1457
SwBasicEscherEx::WritePictures
virtual void WritePictures()
Definition: wrtw8esh.cxx:2185
SvStream::SetEndian
void SetEndian(SvStreamEndian SvStreamEndian)
COL_WHITE
const ::std::vector< Color > ImpSvNumberformatScan::StandardColor COL_WHITE
MSO_TextFlow
MSO_TextFlow
INetURLObject::HasMark
bool HasMark() const
INetURLObject::GetProtocol
INetProtocol GetProtocol() const
MSWord_SdrAttrIter::MSWord_SdrAttrIter
MSWord_SdrAttrIter(const MSWord_SdrAttrIter &)=delete
if
if(aStr!=aBuf) UpdateName_Impl(m_xFollowLb.get()
RES_GRFATR_DRAWMODE
constexpr TypedWhichId< SwDrawModeGrf > RES_GRFATR_DRAWMODE(144)
ESCHER_Prop_fillType
#define ESCHER_Prop_fillType
SvxBoxItemLine
SvxBoxItemLine
IDocumentStylePoolAccess::GetTextCollFromPool
virtual SwTextFormatColl * GetTextCollFromPool(sal_uInt16 nId, bool bRegardLanguage=true)=0
Return "Auto-Collection with ID.
EscherEx::EnterGroup
virtual sal_uInt32 EnterGroup(const OUString &rShapeName, const tools::Rectangle *pBoundRect)
MSO_LineStyle
MSO_LineStyle
RTLDrawingsHack
static bool RTLDrawingsHack(SwTwips &rLeft, sal_Int16 eHoriOri, sal_Int16 eHoriRel, SwTwips nPageLeft, SwTwips nPageRight, SwTwips nPageSize)
Definition: wrtw8esh.cxx:558
mso_txflTtoBA
mso_txflTtoBA
MSWordExportBase::m_nTextTyp
sal_uInt8 m_nTextTyp
Definition: wrtww8.hxx:547
WW8Export::WriteSdrTextObj
void WriteSdrTextObj(const SdrTextObj &rObj, sal_uInt8 nTyp)
Definition: wrtw8esh.cxx:1317
DFF_Prop_fshadowObscured
#define DFF_Prop_fshadowObscured
AttributeOutputBase::EndURL
virtual bool EndURL(bool isAtEndOfParagraph)=0
Output URL end.
SvStream::Tell
sal_uInt64 Tell() const
p
void * p
EscherPropertyContainer::AddOpt
void AddOpt(sal_uInt16 nPropID, bool bBlib, sal_uInt32 nSizeReduction, SvMemoryStream &rStream)
WW8Fib
FIB - the File Information Block.
Definition: ww8scan.hxx:1104
SwBasicEscherEx::WriteEmptyFlyFrame
void WriteEmptyFlyFrame(const SwFrameFormat &rFormat, sal_uInt32 nShapeId)
Definition: wrtw8esh.cxx:1534
Fraction::GetNumerator
sal_Int32 GetNumerator() const
SwFormat::GetFormatAttr
const SfxPoolItem & GetFormatAttr(sal_uInt16 nWhich, bool bInParents=true) const
If bInParents is FALSE, search only in this format for attribute.
Definition: format.cxx:369
RES_LR_SPACE
constexpr TypedWhichId< SvxLRSpaceItem > RES_LR_SPACE(91)
WW8Fib::m_ccpText
WW8_CP m_ccpText
Definition: ww8scan.hxx:1209
EE_CHAR_FONTINFO
constexpr TypedWhichId< SvxFontItem > EE_CHAR_FONTINFO(EE_CHAR_START+1)
WW8_WrPlcTextBoxes::Count
sal_uInt16 Count() const
Definition: wrtww8.hxx:1301
SwFormatVertOrient::GetVertOrient
sal_Int16 GetVertOrient() const
Definition: fmtornt.hxx:54
WW8Fib::m_ccpFootnote
WW8_CP m_ccpFootnote
Definition: ww8scan.hxx:1210
MSWordExportBase::m_pTextBxs
std::unique_ptr< WW8_WrPlcTextBoxes > m_pTextBxs
Definition: wrtww8.hxx:504
WW8Fib::m_ccpAtn
WW8_CP m_ccpAtn
Definition: ww8scan.hxx:1213
SvStream::WriteChar
SvStream & WriteChar(char nChar)
EditTextObject::GetCharAttribs
virtual void GetCharAttribs(sal_Int32 nPara, std::vector< EECharAttrib > &rLst) const =0
IDocumentSettingAccess::get
virtual bool get(DocumentSettingId id) const =0
Return the specified document setting.
SwWW8Writer::InsUInt16
static void InsUInt16(ww::bytes &rO, sal_uInt16 n)
Definition: wrtww8.cxx:1706
SwEscherExGlobal::~SwEscherExGlobal
virtual ~SwEscherExGlobal() override
Definition: wrtw8esh.cxx:1506
RES_BOX
constexpr TypedWhichId< SvxBoxItem > RES_BOX(106)
SwBasicEscherEx::PreWriteHyperlinkWithinFly
void PreWriteHyperlinkWithinFly(const SwFrameFormat &rFormat, EscherPropertyContainer &rPropOpt)
Definition: wrtw8esh.cxx:277
SwFormat::GetFrameSize
const SwFormatFrameSize & GetFrameSize(bool=true) const
Definition: fmtfsize.hxx:104
SwContentNode::GetSwAttrSet
const SwAttrSet & GetSwAttrSet() const
Does node has already its own auto-attributes? Access to SwAttrSet.
Definition: node.hxx:715
SwFormat::GetContent
const SwFormatContent & GetContent(bool=true) const
Definition: fmtcntnt.hxx:55
sw::BroadcastingModify::CallSwClientNotify
virtual void CallSwClientNotify(const SfxHint &rHint) const override
Definition: calbck.cxx:326
SwFormatHoriOrient::SetPos
void SetPos(SwTwips nNew)
Definition: fmtornt.hxx:93
AttributeOutputBase::StartURL
virtual bool StartURL(const OUString &rUrl, const OUString &rTarget)=0
Output URL start.
SvxGrfCrop::GetRight
sal_Int32 GetRight() const
SdrUnoObj::GetUnoControlModel
const css::uno::Reference< css::awt::XControlModel > & GetUnoControlModel() const
SwEscherExGlobal::ImplQueryPictureStream
virtual SvStream * ImplQueryPictureStream() override
Override to create a new memory stream for picture data.
Definition: wrtw8esh.cxx:1510
ESCHER_SplitMenuColors
#define ESCHER_SplitMenuColors
SwInputField::GetToolTip
const OUString & GetToolTip() const
Definition: expfld.cxx:1419
MSWord_SdrAttrIter::aChrTextAtrArr
std::vector< const EECharAttrib * > aChrTextAtrArr
Definition: wrtww8.hxx:1458
MSWordExportBase::m_bFontSizeWritten
bool m_bFontSizeWritten
Is font size written already as part of the current character properties?
Definition: wrtww8.hxx:571
SwEscherEx::SwEscherEx
SwEscherEx(SvStream *pStrm, WW8Export &rWW8Wrt)
Definition: wrtw8esh.cxx:2198
SwBasicEscherEx::WriteGrfFlyFrame
sal_Int32 WriteGrfFlyFrame(const SwFrameFormat &rFormat, sal_uInt32 nShapeId)
Definition: wrtw8esh.cxx:1605
EscherEx::GetHellLayerId
SdrLayerID GetHellLayerId() const
ESCHER_BlipFlagURL
ESCHER_BlipFlagURL
MapUnit
MapUnit
WW8Export::CreateEscher
void CreateEscher()
Definition: wrtw8esh.cxx:1457
MSWordExportBase
Base class for WW8Export and DocxExport.
Definition: wrtww8.hxx:449
INetURLObject::GetMark
OUString GetMark(DecodeMechanism eMechanism=DecodeMechanism::ToIUri, rtl_TextEncoding eCharset=RTL_TEXTENCODING_UTF8) const
RndStdIds
RndStdIds
WW8Fib::m_fcPlcfspaMom
WW8_FC m_fcPlcfspaMom
Definition: ww8scan.hxx:1385
SdrObject::GetRotateAngle
virtual Degree100 GetRotateAngle() const
EE_FEATURE_FIELD
constexpr sal_uInt16 EE_FEATURE_FIELD(EE_FEATURE_NOTCONV+1)
SdrObject::GetLogicRect
virtual const tools::Rectangle & GetLogicRect() const
SwEscherEx::aWinwordAnchoring
WinwordAnchoring aWinwordAnchoring
Definition: escher.hxx:145
ww8::Frame::IsInline
bool IsInline() const
Is this frame inline (as character)
Definition: writerhelper.hxx:143
SwMSConvertControls::ReadOCXStream
bool ReadOCXStream(tools::SvRef< SotStorage > const &rSrc1, css::uno::Reference< css::drawing::XShape > *pShapeRef, bool bFloatingCtrl=false)
Definition: wrtw8esh.cxx:3019
WW8Export::WriteOutliner
void WriteOutliner(const OutlinerParaObject &rOutliner, sal_uInt8 nTyp)
Definition: wrtw8esh.cxx:1345
ww8::Frame::GetWriterType
WriterSource GetWriterType() const
Get the type of frame that this wraps.
Definition: writerhelper.hxx:136
MSWord_SdrAttrIter::GetItem
virtual const SfxPoolItem & GetItem(sal_uInt16 nWhich) const override
Definition: wrtw8esh.cxx:1231
MSWord_SdrAttrIter::GetNextCharSet
rtl_TextEncoding GetNextCharSet() const
Definition: wrtw8esh.cxx:1044
MSWord_SdrAttrIter::SetItemsThatDifferFromStandard
void SetItemsThatDifferFromStandard(bool bCharAttr, SfxItemSet &rSet)
Definition: wrtw8esh.cxx:1248
SwNode::GetGrfNode
SwGrfNode * GetGrfNode()
Definition: ndgrf.hxx:154
DrawObjPointerVector
std::vector< DrawObj * > DrawObjPointerVector
Definition: wrtww8.hxx:360
SwFormat::GetAttrSet
const SwAttrSet & GetAttrSet() const
For querying the attribute array.
Definition: format.hxx:120
sw::hack::GetSetWhichFromSwDocWhich
sal_uInt16 GetSetWhichFromSwDocWhich(const SfxItemSet &rSet, const SwDoc &rDoc, sal_uInt16 nWhich)
Map a SwDoc WhichId to the equivalent Id for a given SfxItemSet.
Definition: writerhelper.cxx:279
ESCHER_Prop_fPrint
#define ESCHER_Prop_fPrint
SwBasicEscherEx::~SwBasicEscherEx
virtual ~SwBasicEscherEx() override
Definition: wrtw8esh.cxx:1524
WW8Export::DoFormText
virtual void DoFormText(const SwInputField *pField) override
Definition: wrtw8esh.cxx:475
EscherEx::GetColor
static sal_uInt32 GetColor(const sal_uInt32 nColor)
EscherPropertyContainer::GetOpt
bool GetOpt(sal_uInt16 nPropertyID, sal_uInt32 &rPropValue) const
SwBasicEscherEx::WriteOLEPicture
void WriteOLEPicture(EscherPropertyContainer &rPropOpt, ShapeFlag nShapeFlags, const Graphic &rGraphic, const SdrObject &rObj, sal_uInt32 nShapeId, const css::awt::Rectangle *pVisArea)
Definition: wrtw8esh.cxx:2901
EscherEx::SetHellLayerId
void SetHellLayerId(SdrLayerID nId)
SwFormatChain::GetPrev
SwFlyFrameFormat * GetPrev() const
Definition: fmtcnct.hxx:53
SfxItemSet::GetItem
const SfxPoolItem * GetItem(sal_uInt16 nWhich, bool bSearchInParent=true) const
mso_lineSimple
mso_lineSimple
SwNode::IsTextNode
bool IsTextNode() const
Definition: node.hxx:637
ESCHER_Prop_pibFlags
#define ESCHER_Prop_pibFlags
MSWordAttrIter
The class MSWordAttrIter is a helper class to build the Fkp.chpx.
Definition: wrtww8.hxx:1435
SwWW8Writer::WriteLong
static void WriteLong(SvStream &rStrm, sal_Int32 nVal)
Definition: wrtww8.hxx:964
RES_CHRATR_CJK_FONTSIZE
constexpr TypedWhichId< SvxFontHeightItem > RES_CHRATR_CJK_FONTSIZE(23)
DrawObj::maContent
ww8::Frame maContent
Definition: wrtww8.hxx:345
ww8::Frame::GetPosition
const SwPosition & GetPosition() const
Get the position this frame is anchored at.
Definition: writerhelper.hxx:120
MSWordExportBase::WriteChar
virtual void WriteChar(sal_Unicode c)=0
aStr
aStr
WW8Fib::m_ccpHdr
WW8_CP m_ccpHdr
Definition: ww8scan.hxx:1211
MSWord_SdrAttrIter::NextPara
void NextPara(sal_Int32 nPar)
Definition: wrtw8esh.cxx:1024
WinwordAnchoring::mnYRelTo
sal_uInt32 mnYRelTo
Definition: escher.hxx:74
RES_UL_SPACE
constexpr TypedWhichId< SvxULSpaceItem > RES_UL_SPACE(92)
SwInputField::GetPar2
virtual OUString GetPar2() const override
aPromptText
Definition: expfld.cxx:1399
MSWordExportBase::m_pChpPlc
std::unique_ptr< WW8_WrPlcPn > m_pChpPlc
Definition: wrtww8.hxx:499
tools::Rectangle::Right
tools::Long Right() const
SfxPoolItem::Which
sal_uInt16 Which() const
MSWordExportBase::TrueFrameDirection
SvxFrameDirection TrueFrameDirection(const SwFrameFormat &rFlyFormat) const
Right to left?
Definition: wrtw8nds.cxx:1640
SwFrameFormat::FindRealSdrObject
SdrObject * FindRealSdrObject()
Definition: atrfrm.cxx:2802
SwGrfNode::GetGrf
const Graphic & GetGrf(bool bWait=false) const
Definition: ndgrf.cxx:373
SwWW8Writer::InsAsString16
static void InsAsString16(ww::bytes &rO, const OUString &rStr)
Definition: wrtww8.cxx:1724
RES_SHADOW
constexpr TypedWhichId< SvxShadowItem > RES_SHADOW(107)
SwEscherEx::WriteTextFlyFrame
sal_Int32 WriteTextFlyFrame(const DrawObj &rObj, sal_uInt32 nShapeId, sal_uInt32 nTextBox, DrawObjPointerVector &rPVec)
Definition: wrtw8esh.cxx:2847
SvxSizeItem::GetSize
const Size & GetSize() const
tools::Rectangle::setHeight
void setHeight(tools::Long n)
nPos
sal_uInt16 nPos
mso_lineDotGEL
mso_lineDotGEL
WW8Export::WriteEscher
void WriteEscher()
Definition: wrtw8esh.cxx:1470
SfxItemIter::GetCurItem
const SfxPoolItem * GetCurItem() const
ESCHER_Prop_lTxid
#define ESCHER_Prop_lTxid
SwDoc::GetAttrPool
const SwAttrPool & GetAttrPool() const
Definition: doc.hxx:1319
nValue
sal_Int16 nValue
ESCHER_ClientData
#define ESCHER_ClientData
SL::aObjectPool
constexpr OUStringLiteral aObjectPool
Definition: ww8scan.hxx:45
ESCHER_Prop_pihlShape
#define ESCHER_Prop_pihlShape
SvxFieldItem::GetField
const SvxFieldData * GetField() const
SdrTextObj::GetLogicRect
virtual const tools::Rectangle & GetLogicRect() const override
SvxShadowItem::GetWidth
sal_uInt16 GetWidth() const
SwFormatURL::GetURL
const OUString & GetURL() const
Definition: fmturl.hxx:66
SvxShadowLocation
SvxShadowLocation
ESCHER_Prop_dxTextRight
#define ESCHER_Prop_dxTextRight
SfxEnumItem::GetValue
EnumT GetValue() const
Generated on Fri Jul 30 2021 18:29:30 for LibreOffice Module sw (master) by   doxygen 1.8.10