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