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