LibreOffice Module sw (master)  1
wrtww8gr.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/XEmbedPersist.hpp>
22 #include <com/sun/star/embed/Aspects.hpp>
23 #include <com/sun/star/embed/ElementModes.hpp>
24 #include <sal/log.hxx>
25 #include <vcl/graphicfilter.hxx>
26 #include <vcl/gdimtf.hxx>
27 #include <svl/itemiter.hxx>
28 #include <tools/UnitConversion.hxx>
29 
30 #include <svtools/embedhlp.hxx>
31 
32 #include <hintids.hxx>
33 #include <editeng/boxitem.hxx>
34 #include <editeng/shaditem.hxx>
36 #include <editeng/fhgtitem.hxx>
37 #include <svx/svdoole2.hxx>
38 
40 #include <fmtanchr.hxx>
41 #include <ndgrf.hxx>
42 #include <frmfmt.hxx>
43 #include <grfatr.hxx>
44 #include <ndole.hxx>
45 #include <fmtfsize.hxx>
46 #include <fmtornt.hxx>
47 
48 #include "sprmids.hxx"
49 
50 #include <doc.hxx>
51 #include "writerhelper.hxx"
52 #include "writerwordglue.hxx"
53 #include "ww8struc.hxx"
54 #include "wrtww8.hxx"
55 #include "ww8par.hxx"
56 #include "escher.hxx"
57 //Added for i120568
58 #include "ww8attributeoutput.hxx"
59 #include <fmturl.hxx>
60 
62 #include <drawdoc.hxx>
63 
64 using namespace ::com::sun::star;
65 
66 // TODO:
67 // 5. convert the MapModes that Widows can't handle
68 
69 // OutGrf () is called for every GrfNode in the document. A PicLocFc-Sprm
70 // will be inserted, which contains a magic number instead of an address.
71 // The GrfNode-Ptr is saved in Graf-Class (used later for output of
72 // the graphic and patching of the PicLocFc attributes)
73 
74 void WW8Export::OutputGrfNode( const SwGrfNode& /*rNode*/ )
75 {
76  SAL_INFO("sw", "WW8Export::OutputGrfNode( const SwGrfNode& )" );
77  OSL_ENSURE( m_pParentFrame, "frame not set!" );
78  if ( m_pParentFrame )
79  {
81  pFib->m_fHasPic = true;
82  }
83 }
84 
86  const tools::SvRef<SotStorage>& xObjStg,
87  OUString const& rStorageName, SwOLENode* pOLENd)
88 {
89  bool bGraphicNeeded = false;
90  SfxItemIter aIter( rSet );
91  for (auto pItem = aIter.GetCurItem(); !bGraphicNeeded && pItem; pItem = aIter.NextItem())
92  {
93  switch (pItem->Which())
94  {
95  /*
96  For an inline object these properties are irrelevant because they
97  will be the same as the defaults that msword applies in their
98  absence, so if that is all that there is for these inline objects
99  then if there turns out to be enough information in the object
100  itself to regenerate the correct size and preview of the object
101  then we will not need to provide an additional graphics preview in
102  the data stream, which can save a lot of disk space.
103  */
104  case RES_FRM_SIZE:
105  case RES_CNTNT:
106  case RES_VERT_ORIENT:
107  case RES_ANCHOR:
108  break;
109  default:
110  bGraphicNeeded = true;
111  }
112  }
113 
114  /*
115  Now we must see if the object contains a preview itself which is equal to
116  the preview that we are currently using. If the graphics are equal then we
117  don't need to store another preview
118  */
119  GDIMetaFile aWMF;
120  tools::Long nX=0,nY=0;
121  if (!bGraphicNeeded && SwWW8ImplReader::ImportOleWMF(xOleStg,aWMF,nX,nY))
122  {
123  // bGraphicNeeded set to true is right / fixes #i51670#.
124  bGraphicNeeded = true;
125  tools::Rectangle aRect( Point(), Size( nX, nY ) );
126  Graphic aGraph(aWMF);
127 
128  ErrCode nErr = ERRCODE_NONE;
129  sal_Int64 nAspect = embed::Aspects::MSOLE_CONTENT;
130  if ( pOLENd )
131  nAspect = pOLENd->GetAspect();
134  rStorageName,
135  xObjStg,
137  aGraph,
138  aRect,
140  nullptr,
141  nErr,
142  0,
143  nAspect,
144  m_pWriter->GetBaseURL());
145 
146  if (pRet)
147  {
148  uno::Reference< embed::XEmbeddedObject > xObj = pOLENd->GetOLEObj().GetOleRef();
149  if ( xObj.is() )
150  {
151  std::unique_ptr<SvStream> pGraphicStream;
153  try
154  {
155  uno::Reference< embed::XEmbedPersist > xPersist(
156  xObj,
157  uno::UNO_QUERY_THROW );
158 
159  // it makes no sense to search the object in the container by reference since the object was created
160  // outside of the container and was not inserted there, only the name makes sense
161  pGraphicStream =
162  ::utl::UcbStreamHelper::CreateStream( aCnt.GetGraphicStream( xPersist->getEntryName() ) );
163  }
164  catch( const uno::Exception& )
165  {}
166 
167  OSL_ENSURE( pGraphicStream && !pGraphicStream->GetError(), "No graphic stream available!" );
168  if ( pGraphicStream && !pGraphicStream->GetError() )
169  {
170  Graphic aGr1;
172  if( rGF.ImportGraphic( aGr1, OUString(), *pGraphicStream ) == ERRCODE_NONE )
173  {
174  Graphic aGr2;
175  pGraphicStream =
176  ::utl::UcbStreamHelper::CreateStream( aCnt.GetGraphicStream( pRet->GetObjRef() ) );
177  if( pGraphicStream && rGF.ImportGraphic( aGr2, OUString(), *pGraphicStream ) == ERRCODE_NONE )
178  {
179  if ( aGr1 == aGr2 )
180  bGraphicNeeded = false;
181  }
182  }
183  }
184  }
185 
186  // always use SdrObject::Free(...) for SdrObjects (!)
187  SdrObject* pTemp(pRet);
188  SdrObject::Free(pTemp);
189  }
190  }
191  else
192  bGraphicNeeded = true;
193  return bGraphicNeeded;
194 }
195 
196 void WW8Export::OutputOLENode( const SwOLENode& rOLENode )
197 {
198  SAL_INFO("sw", "WW8Export::OutputOLENode( const SwOLENode& rOLENode )" );
199  sal_uInt8 *pSpecOLE;
200  sal_uInt8 *pDataAdr;
201  short nSize;
202  static sal_uInt8 aSpecOLE_WW8[] = {
203  0x03, 0x6a, 0, 0, 0, 0, // sprmCPicLocation
204  0x0a, 0x08, 1, // sprmCFOLE2
205  0x56, 0x08, 1 // sprmCFObj
206  };
207 
208  pSpecOLE = aSpecOLE_WW8;
209  nSize = sizeof( aSpecOLE_WW8 );
210  pDataAdr = pSpecOLE + 2; //WW6 sprm is 1 but has 1 byte len as well.
211 
213 
214  if( !xObjStg.is() )
215  return;
216 
217  uno::Reference < embed::XEmbeddedObject > xObj(const_cast<SwOLENode&>(rOLENode).GetOLEObj().GetOleRef());
218  if( !xObj.is() )
219  return;
220 
221  const embed::XEmbeddedObject *pObj = xObj.get();
222  //Don't want to use pointer ids, as is traditional, because we need
223  //to put this into a 32bit value, and on 64bit the bottom bits
224  //might collide and two unrelated ole objects end up considered the
225  //same. Don't want to simply start at 0 which is a special value
226  sal_Int32 nPictureId = SAL_MAX_INT32 - m_aOleMap.size();
227  WW8OleMap::value_type entry = std::make_pair(pObj, nPictureId);
228  std::pair<WW8OleMap::iterator, bool> aRes = m_aOleMap.insert(entry);
229  bool bIsNotDuplicate = aRes.second; //.second is false when element already existed
230  nPictureId = aRes.first->second;
231  Set_UInt32(pDataAdr, nPictureId);
232  OUString sStorageName = "_" + OUString::number( nPictureId );
233  tools::SvRef<SotStorage> xOleStg = xObjStg->OpenSotStorage( sStorageName );
234  if( !xOleStg.is() )
235  return;
236 
237  /*
238  If this object storage has been written already don't
239  waste time rewriting it
240  */
241  if (bIsNotDuplicate)
242  {
243  sal_Int64 nAspect = rOLENode.GetAspect();
244  svt::EmbeddedObjectRef aObjRef( xObj, nAspect );
245  m_pOLEExp->ExportOLEObject( aObjRef, *xOleStg );
246  if ( nAspect == embed::Aspects::MSOLE_ICON )
247  {
248  OUString aObjInfo( "\3ObjInfo" );
249  if ( !xOleStg->IsStream( aObjInfo ) )
250  {
251  const sal_uInt8 pObjInfoData[] = { 0x40, 0x00, 0x03, 0x00 };
252  tools::SvRef<SotStorageStream> rObjInfoStream = xOleStg->OpenSotStream( aObjInfo );
253  if ( rObjInfoStream.is() && !rObjInfoStream->GetError() )
254  {
255  rObjInfoStream->WriteBytes(pObjInfoData, sizeof(pObjInfoData));
256  xOleStg->Commit();
257  }
258  }
259  }
260  }
261 
262  // write as embedded field - the other things will be done
263  // in the escher export
264  OUString sServer = FieldString(ww::eEMBED) + xOleStg->GetUserName() + " ";
265 
266  OutputField(nullptr, ww::eEMBED, sServer, FieldFlags::Start |
268 
269  m_pChpPlc->AppendFkpEntry( Strm().Tell(),
270  nSize, pSpecOLE );
271 
272  bool bEndCR = true;
273  /*
274  In the word filter we only need a preview image for
275  floating images, and then only (the usual case) if the
276  object doesn't contain enough information to reconstruct
277  what we need.
278 
279  We don't need a graphic for inline objects, so we don't
280  even need the overhead of a graphic in that case.
281  */
282  bool bGraphicNeeded = false;
283 
284  if (m_pParentFrame)
285  {
286  bGraphicNeeded = true;
287 
288  if (m_pParentFrame->IsInline())
289  {
290  const SwAttrSet& rSet =
292  bEndCR = false;
293  bGraphicNeeded = TestOleNeedsGraphic(rSet,
294  xOleStg, xObjStg, sStorageName, const_cast<SwOLENode*>(&rOLENode));
295  }
296  }
297 
298  if (!bGraphicNeeded)
299  WriteChar(0x1);
300  else
301  {
302  /*
303  ##897##
304  We need to insert the graphic representation of
305  this object for the inline case, otherwise word
306  has no place to find the dimensions of the ole
307  object, and will not be able to draw it
308  */
310  }
311 
312  OutputField(nullptr, ww::eEMBED, OUString(),
314 
315  if (bEndCR) //No newline in inline case
316  WriteCR();
317 }
318 
319 void WW8Export::OutputLinkedOLE( const OUString& rOleId )
320 {
321  uno::Reference< embed::XStorage > xDocStg = m_rDoc.GetDocStorage();
322  uno::Reference< embed::XStorage > xOleStg = xDocStg->openStorageElement( "OLELinks", embed::ElementModes::READ );
323  tools::SvRef<SotStorage> xObjSrc = SotStorage::OpenOLEStorage( xOleStg, rOleId, StreamMode::READ );
324 
326 
327  if( !(xObjStg.is() && xObjSrc.is()) )
328  return;
329 
330  tools::SvRef<SotStorage> xOleDst = xObjStg->OpenSotStorage( rOleId );
331  if ( xOleDst.is() )
332  xObjSrc->CopyTo( xOleDst.get() );
333 
334  if ( xOleDst->GetError( ) )
335  return;
336 
337  xOleDst->Commit();
338 
339  // Output the cPicLocation attribute
340  std::unique_ptr<ww::bytes> pBuf( new ww::bytes );
342  SwWW8Writer::InsUInt32( *pBuf, rOleId.copy( 1 ).toInt32() );
343 
345  pBuf->push_back( 1 );
346 
348  pBuf->push_back( 1 );
349 
351  pBuf->push_back( 1 );
352 
353  m_pChpPlc->AppendFkpEntry( Strm().Tell(), pBuf->size(), pBuf->data() );
354 }
355 
356 void WW8Export::OutGrf(const ww8::Frame &rFrame)
357 {
358  //Added for i120568,the hyperlink info within a graphic whose anchor type is "As character"
359  //will be exported to ensure the fidelity
360  const SwFormatURL& rURL = rFrame.GetFrameFormat().GetAttrSet().GetURL();
361  bool bURLStarted = false;
362  if( !rURL.GetURL().isEmpty() && rFrame.GetWriterType() == ww8::Frame::eGraphic)
363  {
364  bURLStarted = true;
365  m_pAttrOutput->StartURL( rURL.GetURL(), rURL.GetTargetFrameName() );
366  }
367 
368  // Store the graphic settings in GrfNode so they may be written-out later
369  m_pGrf->Insert(rFrame);
370 
371  m_pChpPlc->AppendFkpEntry( Strm().Tell(), pO->size(), pO->data() );
372  pO->clear();
373 
374  // #i29408#
375  // linked, as-character anchored graphics have to be exported as fields.
376  const SwGrfNode* pGrfNd = rFrame.IsInline() && rFrame.GetContent()
377  ? rFrame.GetContent()->GetGrfNode() : nullptr;
378  if ( pGrfNd && pGrfNd->IsLinkedFile() )
379  {
380  OUString sStr;
381  pGrfNd->GetFileFilterNms(&sStr, nullptr);
382  sStr = FieldString(ww::eINCLUDEPICTURE) + " \"" + sStr + "\" \\d";
383 
384  OutputField( nullptr, ww::eINCLUDEPICTURE, sStr,
386  }
387 
388  WriteChar( char(1) ); // paste graphic symbols in the main text
389 
390  sal_uInt8 aArr[ 18 ];
391  sal_uInt8* pArr = aArr;
392 
393  const SwFrameFormat &rFlyFormat = rFrame.GetFrameFormat();
394  const RndStdIds eAn = rFlyFormat.GetAttrSet().GetAnchor(false).GetAnchorId();
395  if (eAn == RndStdIds::FLY_AS_CHAR)
396  {
397  sal_Int16 eVert = rFlyFormat.GetVertOrient().GetVertOrient();
398  if ((eVert == text::VertOrientation::CHAR_CENTER) || (eVert == text::VertOrientation::LINE_CENTER))
399  {
400  bool bVert = false;
401  //The default for word in vertical text mode is to center,
402  //otherwise a sub/super script hack is employed
403  if (auto pTextNd = dynamic_cast< const SwContentNode *>( m_pOutFormatNode ) )
404  {
405  SwPosition aPos(*pTextNd);
406  bVert = m_rDoc.IsInVerticalText(aPos);
407  }
408  if (!bVert)
409  {
410  SwTwips nHeight = rFlyFormat.GetFrameSize().GetHeight();
411  nHeight/=20; //nHeight was in twips, want it in half points, but
412  //then half of total height.
413  tools::Long nFontHeight = GetItem(RES_CHRATR_FONTSIZE).GetHeight();
414  nHeight-=nFontHeight/20;
415 
417  Set_UInt16( pArr, - static_cast<sal_Int16>(nHeight));
418  }
419  }
420  }
421 
422  // sprmCFSpec
423  Set_UInt16( pArr, 0x855 );
424  Set_UInt8( pArr, 1 );
425 
426  // sprmCPicLocation
428  Set_UInt32( pArr, GRF_MAGIC_321 );
429 
430  // vary Magic, so that different graphic attributes will not be merged
431  static sal_uInt8 nAttrMagicIdx = 0;
432  --pArr;
433  Set_UInt8( pArr, nAttrMagicIdx++ );
434  m_pChpPlc->AppendFkpEntry( Strm().Tell(), static_cast< short >(pArr - aArr), aArr );
435 
436  // #i75464#
437  // Check, if graphic isn't exported as-character anchored.
438  // Otherwise, an additional paragraph is exported for a graphic, which is
439  // forced to be treated as inline, because it's anchored inside another frame.
440  if ( !rFrame.IsInline() &&
441  ( (eAn == RndStdIds::FLY_AT_PARA) ||
442  (eAn == RndStdIds::FLY_AT_PAGE) ) )
443  {
444  WriteChar( char(0x0d) ); // close the surrounding frame with CR
445 
446  static sal_uInt8 nSty[2] = { 0, 0 };
447  pO->insert( pO->end(), nSty, nSty+2 ); // Style #0
448  bool bOldGrf = m_bOutGrf;
449  m_bOutGrf = true;
450 
451  OutputFormat( rFrame.GetFrameFormat(), false, false, true ); // Fly-Attrs
452 
453  m_bOutGrf = bOldGrf;
454  m_pPapPlc->AppendFkpEntry( Strm().Tell(), pO->size(), pO->data() );
455  pO->clear();
456  }
457  // #i29408#
458  // linked, as-character anchored graphics have to be exported as fields.
459  else if ( pGrfNd && pGrfNd->IsLinkedFile() )
460  {
461  OutputField( nullptr, ww::eINCLUDEPICTURE, OUString(), FieldFlags::Close );
462  }
463  //Added for i120568,the hyperlink info within a graphic whose anchor type is
464  //"As character" will be exported to ensure the fidelity
465  if( bURLStarted )
466  m_pAttrOutput->EndURL(false);
467 }
468 
470 {
471  const Size aSize( rFly.GetLayoutSize() );
472  const sal_uInt16 nWidth = static_cast< sal_uInt16 >(aSize.Width());
473  const sal_uInt16 nHeight = static_cast< sal_uInt16 >(aSize.Height());
474  maDetails.emplace_back(rFly, nWidth, nHeight);
475 }
476 
478  sal_uInt16 mm, sal_uInt16 nWidth, sal_uInt16 nHeight, const SwAttrSet* pAttrSet)
479 {
480  sal_Int16 nXSizeAdd = 0, nYSizeAdd = 0;
481  sal_Int16 nCropL = 0, nCropR = 0, nCropT = 0, nCropB = 0;
482 
483  // write Crop-Attribute content in Header ( if available )
484  const SfxPoolItem* pItem;
485  if (pAttrSet && (SfxItemState::SET
486  == pAttrSet->GetItemState(RES_GRFATR_CROPGRF, false, &pItem)))
487  {
488  const SwCropGrf& rCr = *static_cast<const SwCropGrf*>(pItem);
489  nCropL = static_cast<sal_Int16>(rCr.GetLeft());
490  nCropR = static_cast<sal_Int16>(rCr.GetRight());
491  nCropT = static_cast<sal_Int16>(rCr.GetTop());
492  nCropB = static_cast<sal_Int16>(rCr.GetBottom());
493  nXSizeAdd = nXSizeAdd - static_cast<sal_Int16>( rCr.GetLeft() + rCr.GetRight() );
494  nYSizeAdd = nYSizeAdd - static_cast<sal_Int16>( rCr.GetTop() + rCr.GetBottom() );
495  }
496 
497  Size aGrTwipSz(rFly.GetSize());
498  sal_uInt16 nHdrLen = 0x44;
499 
500  sal_uInt8 aArr[ 0x44 ] = { 0 };
501 
502  sal_uInt8* pArr = aArr + 0x2E; // Do borders first
503 
504  const SwAttrSet& rAttrSet = rFly.GetFrameFormat().GetAttrSet();
505  if (SfxItemState::SET == rAttrSet.GetItemState(RES_BOX, false, &pItem))
506  {
507  const SvxBoxItem* pBox = static_cast<const SvxBoxItem*>(pItem);
508  if( pBox )
509  {
510  bool bShadow = false; // Shadow ?
511  if (const SvxShadowItem* pSI = rAttrSet.GetItem<SvxShadowItem>(RES_SHADOW))
512  {
513  bShadow = (pSI->GetLocation() != SvxShadowLocation::NONE) &&
514  (pSI->GetWidth() != 0);
515  }
516 
517  static const SvxBoxItemLine aLnArr[4] = { SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
518  SvxBoxItemLine::BOTTOM, SvxBoxItemLine::RIGHT };
519  for(const SvxBoxItemLine & i : aLnArr)
520  {
521  const ::editeng::SvxBorderLine* pLn = pBox->GetLine( i );
522  WW8_BRC aBrc;
523  if (pLn)
524  {
526  pBox->GetDistance( i ), bShadow );
528  aBrc90.cv()));
529  aBrc = WW8_BRC(aBrc90.dptLineWidth(), aBrc90.brcType(), ico,
530  aBrc90.dptSpace(), aBrc90.fShadow(), aBrc90.fFrame());
531  }
532 
533  // use importer logic to determine how large the exported
534  // border will really be in word and adjust accordingly
535  short nSpacing;
536  short nThick = aBrc.DetermineBorderProperties(&nSpacing);
537  switch (i)
538  {
539  case SvxBoxItemLine::TOP:
540  case SvxBoxItemLine::BOTTOM:
541  nHeight -= bShadow ? nThick*2 : nThick;
542  nHeight = nHeight - nSpacing;
543  break;
544  case SvxBoxItemLine::LEFT:
545  case SvxBoxItemLine::RIGHT:
546  default:
547  nWidth -= bShadow ? nThick*2 : nThick;
548  nWidth = nWidth - nSpacing;
549  break;
550  }
551  memcpy( pArr, &aBrc.aBits1, 2);
552  pArr+=2;
553 
554  memcpy( pArr, &aBrc.aBits2, 2);
555  pArr+=2;
556  }
557  }
558  }
559 
560  pArr = aArr + 4; // skip lcb
561  Set_UInt16( pArr, nHdrLen ); // set cbHeader
562 
563  Set_UInt16( pArr, mm ); // set mm
564 
565  /*
566  Just in case our original size is too big to fit inside a ushort we can
567  substitute the final size and lose on retaining the scaling factor but
568  still keep the correct display size anyway.
569  */
570  const bool bIsSubstitutedSize = (aGrTwipSz.Width() > SHRT_MAX) || (aGrTwipSz.Height() > SHRT_MAX) ||
571  aGrTwipSz.IsEmpty();
572  if ( bIsSubstitutedSize )
573  {
574  aGrTwipSz.setWidth( nWidth );
575  aGrTwipSz.setHeight( nHeight );
576  }
577  using namespace sw::types;
578  // set xExt & yExt
579  Set_UInt16(pArr, msword_cast<sal_uInt16>(convertTwipToMm100(aGrTwipSz.Width())));
580  Set_UInt16(pArr, msword_cast<sal_uInt16>(convertTwipToMm100(aGrTwipSz.Height())));
581  pArr += 16;
582  // skip hMF & rcWinMF
583  // set dxaGoal & dyaGoal
584  Set_UInt16(pArr, msword_cast<sal_uInt16>(aGrTwipSz.Width()));
585  Set_UInt16(pArr, msword_cast<sal_uInt16>(aGrTwipSz.Height()));
586 
587  if ( aGrTwipSz.Width() + nXSizeAdd ) // set mx
588  {
589  if ( !bIsSubstitutedSize )
590  {
591  const double fVal = nWidth * 1000.0 / (aGrTwipSz.Width() + nXSizeAdd );
592  Set_UInt16( pArr, static_cast<sal_uInt16>(::rtl::math::round(fVal)) );
593  }
594  else
595  {
596  Set_UInt16( pArr, 1000 );
597  }
598  }
599  else
600  {
601  pArr += 2;
602  }
603 
604  if ( aGrTwipSz.Height() + nYSizeAdd ) // set my
605  {
606  if ( !bIsSubstitutedSize )
607  {
608  const double fVal = nHeight * 1000.0 / (aGrTwipSz.Height() + nYSizeAdd);
609  Set_UInt16( pArr, static_cast<sal_uInt16>(::rtl::math::round(fVal)) );
610  }
611  else
612  {
613  Set_UInt16( pArr, 1000 );
614  }
615  }
616  else
617  {
618  pArr += 2;
619  }
620 
621  if ( !bIsSubstitutedSize )
622  {
623  Set_UInt16( pArr, nCropL ); // set dxaCropLeft
624  Set_UInt16( pArr, nCropT ); // set dyaCropTop
625  Set_UInt16( pArr, nCropR ); // set dxaCropRight
626  Set_UInt16( pArr, nCropB ); // set dyaCropBottom
627  }
628 
629  rStrm.WriteBytes(aArr, nHdrLen);
630 }
631 
633  const ww8::Frame &rFly, sal_uInt16 nWidth, sal_uInt16 nHeight)
634 {
635  if (rGrfNd.IsLinkedFile()) // Linked File
636  {
637  OUString aFileN;
638  rGrfNd.GetFileFilterNms( &aFileN, nullptr );
639 
640  sal_uInt16 const mm = 94; // 94 = BMP, GIF
641 
642  WritePICFHeader(rStrm, rFly, mm, nWidth, nHeight,
643  rGrfNd.GetpSwAttrSet());
644  rStrm.WriteUChar( aFileN.getLength() ); // write Pascal-String
645  SwWW8Writer::WriteString8(rStrm, aFileN, false,
646  RTL_TEXTENCODING_MS_1252);
647  }
648  else // Embedded File or DDE or something like that
649  {
650  WritePICFHeader(rStrm, rFly, 0x64, nWidth, nHeight,
651  rGrfNd.GetpSwAttrSet());
652  SwBasicEscherEx aInlineEscher(&rStrm, rWrt);
653  aInlineEscher.WriteGrfFlyFrame(rFly.GetFrameFormat(), 0x401);
654  aInlineEscher.WritePictures();
655  }
656 }
657 //For i120928,export graphic info of bullet
659  sal_uInt16 mm, sal_uInt16 nWidth, sal_uInt16 nHeight)
660 {
661  sal_Int16 nXSizeAdd = 0, nYSizeAdd = 0;
662 
663  Size aGrTwipSz(rGrf.GetPrefSize());
664  sal_uInt16 nHdrLen = 0x44;
665 
666  sal_uInt8 aArr[ 0x44 ] = { 0 };
667 
668  sal_uInt8* pArr = aArr + 0x2E; //Do borders first
669 
670  static const SvxBoxItemLine aLnArr[4] = { SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
671  SvxBoxItemLine::BOTTOM, SvxBoxItemLine::RIGHT };
672  for(const SvxBoxItemLine & i : aLnArr)
673  {
674  WW8_BRC aBrc;
675 
676  short nSpacing;
677  short nThick = aBrc.DetermineBorderProperties(&nSpacing);
678  switch (i)
679  {
680  case SvxBoxItemLine::TOP:
681  case SvxBoxItemLine::BOTTOM:
682  nHeight -= nThick;
683  nHeight = nHeight - nSpacing;
684  break;
685  case SvxBoxItemLine::LEFT:
686  case SvxBoxItemLine::RIGHT:
687  default:
688  nWidth -= nThick;
689  nWidth = nWidth - nSpacing;
690  break;
691  }
692  memcpy( pArr, &aBrc.aBits1, 2);
693  pArr+=2;
694 
695  memcpy(pArr, &aBrc.aBits2, 2);
696  pArr+=2;
697  }
698 
699  pArr = aArr + 4; //skip lcb
700  Set_UInt16( pArr, nHdrLen ); // set cbHeader
701 
702  Set_UInt16( pArr, mm ); // set mm
703 
704  if ( (convertTwipToMm100(aGrTwipSz.Width()) > USHRT_MAX ) || ( convertTwipToMm100(aGrTwipSz.Height()) > USHRT_MAX )
705  || aGrTwipSz.IsEmpty() )
706  {
707  aGrTwipSz.setWidth( nWidth );
708  aGrTwipSz.setHeight( nHeight );
709  }
710  using namespace sw::types;
711  // set xExt & yExt
712  Set_UInt16(pArr, msword_cast<sal_uInt16>(convertTwipToMm100(aGrTwipSz.Width())));
713  Set_UInt16(pArr, msword_cast<sal_uInt16>(convertTwipToMm100(aGrTwipSz.Height())));
714  pArr += 16;
715  // skip hMF & rcWinMF
716  // set dxaGoal & dyaGoal
717  Set_UInt16(pArr, msword_cast<sal_uInt16>(aGrTwipSz.Width()));
718  Set_UInt16(pArr, msword_cast<sal_uInt16>(aGrTwipSz.Height()));
719 
720  if( aGrTwipSz.Width() + nXSizeAdd ) // set mx
721  {
722  double fVal = nWidth * 1000.0 / (aGrTwipSz.Width() + nXSizeAdd);
723  Set_UInt16( pArr, static_cast<sal_uInt16>(::rtl::math::round(fVal)) );
724  }
725  else
726  pArr += 2;
727 
728  if( aGrTwipSz.Height() + nYSizeAdd ) // set my
729  {
730  double fVal = nHeight * 1000.0 / (aGrTwipSz.Height() + nYSizeAdd);
731  Set_UInt16( pArr, static_cast<sal_uInt16>(::rtl::math::round(fVal)) );
732  }
733  else
734  pArr += 2;
735 
736  Set_UInt16( pArr, 0 ); // set dxaCropLeft
737  Set_UInt16( pArr, 0 ); // set dyaCropTop
738  Set_UInt16( pArr, 0 ); // set dxaCropRight
739  Set_UInt16( pArr, 0 ); // set dyaCropBottom
740 
741  rStrm.WriteBytes(aArr, nHdrLen);
742 }
743 
744 void SwWW8WrGrf::WriteGrfForBullet(SvStream& rStrm, const Graphic &rGrf, sal_uInt16 nWidth, sal_uInt16 nHeight)
745 {
746  WritePICBulletFHeader(rStrm,rGrf, 0x64,nWidth,nHeight);
747  SwBasicEscherEx aInlineEscher(&rStrm, rWrt);
748  aInlineEscher.WriteGrfBullet(rGrf);
749  aInlineEscher.WritePictures();
750 }
751 
753 {
754  sal_uInt16 nWidth = rItem.mnWid;
755  sal_uInt16 nHeight = rItem.mnHei;
756  sal_uInt32 nPos = rStrm.Tell(); // store start of graphic
757 
758  const ww8::Frame &rFly = rItem.maFly;
759  switch (rFly.GetWriterType())
760  {
762  {
763  const SwNode *pNode = rItem.maFly.GetContent();
764  const SwGrfNode *pNd = pNode ? pNode->GetGrfNode() : nullptr;
765  OSL_ENSURE(pNd, "Impossible");
766  if (pNd)
767  WriteGrfFromGrfNode(rStrm, *pNd, rItem.maFly, nWidth, nHeight);
768  }
769  break;
770  //For i120928,add branch to export graphic of bullet
772  {
773  if (rItem.maFly.HasGraphic())
774  {
775  const Graphic& rGrf = rItem.maFly.GetGraphic();
776  WriteGrfForBullet(rStrm, rGrf, nWidth, nHeight);
777  }
778  }
779  break;
780 
781  case ww8::Frame::eOle:
782  {
783  const SwNode *pNode = rItem.maFly.GetContent();
784  const SwOLENode *pNd = pNode ? pNode->GetOLENode() : nullptr;
785  OSL_ENSURE(pNd, "Impossible");
786  if (pNd)
787  {
788 #ifdef OLE_PREVIEW_AS_EMF
789  //Convert this ole2 preview in ww8+ to an EMF for better unicode
790  //support (note that at this moment this breaks StarSymbol
791  //using graphics because I need to embed starsymbol in exported
792  //documents.
793  WritePICFHeader(rStrm, rFly, 0x64, nWidth, nHeight,
794  pNd->GetpSwAttrSet());
795  SwBasicEscherEx aInlineEscher(&rStrm, rWrt);
796  aInlineEscher.WriteOLEFlyFrame(rFly.GetFrameFormat(), 0x401);
797  aInlineEscher.WritePictures();
798 #else
799  // cast away const
800  SwOLENode *pOleNd = const_cast<SwOLENode*>(pNd);
801  SwOLEObj& rSObj= pOleNd->GetOLEObj();
802 
803  // TODO/LATER: do we need to load object?
804  Graphic* pGr = SdrOle2Obj::GetGraphicFromObject( pOleNd->GetDoc()->GetDocStorage(), rObj );
805 
806  //TODO/LATER: do we really want to use GDIMetafile?!
807  GDIMetaFile aMtf;
808  if ( pGr )
809  aMtf = pGr->GetGDIMetaFile();
810 
811  Size aS(aMtf.GetPrefSize());
812  aMtf.WindStart();
813  aMtf.Play(Application::GetDefaultDevice(), Point(0, 0),
814  Size(2880, 2880));
815 
816  WritePICFHeader(rStrm, rFly, 8, nWidth, nHeight,
817  pNd->GetpSwAttrSet());
818  WriteWindowMetafileBits(rStrm, aMtf);
819  delete pGr;
820 #endif
821  }
822  }
823  break;
827  /*
828  #i3958# We only export an empty dummy picture frame here, this is
829  what word does the escher export should contain an anchored to
830  character element which is drawn over this dummy and the whole
831  shebang surrounded with a SHAPE field. This isn't *my* hack :-),
832  it's what word does.
833  */
834  {
835  WritePICFHeader(rStrm, rFly, 0x64, nWidth, nHeight);
836  SwBasicEscherEx aInlineEscher(&rStrm, rWrt);
837  aInlineEscher.WriteEmptyFlyFrame(rFly.GetFrameFormat(), 0x401);
838  }
839  break;
840  default:
841  OSL_ENSURE(false, "Some inline export not implemented");
842  break;
843  }
844 
845  sal_uInt32 nPos2 = rStrm.Tell(); // store the end
846  rStrm.Seek( nPos );
847  rStrm.WriteUInt32(nPos2 - nPos); // patch graphic length in the header
848  rStrm.Seek( nPos2 ); // restore Pos
849 }
850 
851 // SwWW8WrGrf::Write() is called after the text.
852 // It writes out all the graphics and remembers the file locations of the graphics,
853 // so when writing the attributes of the items it can be patched into PicLocFc-SPRMs.
854 // The search in the attributes for the Magic sal_uLong and patching
855 // happens when writing the attributes. Class SwWW8WrGrf provides with
856 // GetFPos() sequentially the positions
858 {
860  auto aEnd = maDetails.end();
861  for (auto aIter = maDetails.begin(); aIter != aEnd; ++aIter)
862  {
863  sal_uInt32 nPos = rStrm.Tell(); // align to 4 Bytes
864  if( nPos & 0x3 )
865  SwWW8Writer::FillCount( rStrm, 4 - ( nPos & 0x3 ) );
866 
867  auto aIter2 = std::find(maDetails.begin(), aIter, *aIter);
868  if (aIter2 != aIter)
869  {
870  aIter->mnPos = aIter2->mnPos;
871  }
872  else
873  {
874  aIter->mnPos = rStrm.Tell();
875  WriteGraphicNode(rStrm, *aIter);
876  }
877  }
878 }
879 
880 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
css::uno::Reference< css::embed::XStorage > GetDocStorage()
Definition: docnew.cxx:629
bool is() const
static void InsUInt32(ww::bytes &rO, sal_uInt32 n)
Definition: wrtww8.cxx:1714
const OUString & GetBaseURL() const
Definition: shellio.hxx:439
const sw::BroadcastingModify * m_pOutFormatNode
Definition: wrtww8.hxx:535
sal_Int64 GetAspect() const
Definition: ndole.hxx:136
sal_uInt8 brcType() const
Definition: ww8struc.hxx:325
SVBT16 aBits1
Definition: ww8struc.hxx:263
std::unique_ptr< ww::bytes > pO
Buffer.
Definition: wrtww8.hxx:988
std::unique_ptr< SvxMSExportOLEObjects > m_pOLEExp
Definition: wrtww8.hxx:474
Marks a position in the document model.
Definition: pam.hxx:35
sal_Int32 GetLeft() const
ErrCode ImportGraphic(Graphic &rGraphic, const INetURLObject &rPath, sal_uInt16 nFormat=GRFILTER_FORMAT_DONTKNOW, sal_uInt16 *pDeterminedFormat=nullptr, GraphicFilterImportFlags nImportFlags=GraphicFilterImportFlags::NONE)
std::unique_ptr< WW8Fib > pFib
File Information Block.
Definition: wrtww8.hxx:992
const SfxPoolItem & GetItem(sal_uInt16 nWhich) const
Definition: wrtww8.cxx:780
css::uno::Reference< css::embed::XEmbeddedObject > const & GetObjRef() const
static SdrOle2Obj * CreateSdrOLEFromStorage(SdrModel &rSdrModel, const OUString &rStorageName, tools::SvRef< SotStorage > const &rSrcStorage, const css::uno::Reference< css::embed::XStorage > &xDestStg, const Graphic &rGraf, const tools::Rectangle &rBoundRect, const tools::Rectangle &rVisArea, SvStream *pDataStrrm, ErrCode &rError, sal_uInt32 nConvertFlags, sal_Int64 nAspect, OUString const &rBaseURL)
SwOLENode * GetOLENode()
Inline methods from Node.hxx.
Definition: ndole.hxx:161
const SwOLEObj & GetOLEObj() const
Definition: ndole.hxx:112
OUString GetUserName()
bool HasGraphic() const
const SwFormatVertOrient & GetVertOrient(bool=true) const
Definition: fmtornt.hxx:106
const SwFormatURL & GetURL(bool=true) const
Definition: fmturl.hxx:75
constexpr TypedWhichId< SwFormatFrameSize > RES_FRM_SIZE(89)
std::vector< sal_uInt8 > bytes
Definition: types.hxx:29
ErrCode GetError() const
sal_uInt8 TransColToIco(const Color &rCol)
long Long
static bool ImportOleWMF(const tools::SvRef< SotStorage > &xSrc1, GDIMetaFile &rWMF, tools::Long &rX, tools::Long &rY)
Definition: ww8par4.cxx:305
constexpr TypedWhichId< SvxFontHeightItem > RES_CHRATR_FONTSIZE(8)
const SwFormatAnchor & GetAnchor(bool=true) const
Definition: fmtanchr.hxx:78
static void WritePICBulletFHeader(SvStream &rStrm, const Graphic &rGrf, sal_uInt16 mm, sal_uInt16 nWidth, sal_uInt16 nHeight)
Definition: wrtww8gr.cxx:658
css::uno::Reference< css::embed::XEmbeddedObject > const & GetOleRef()
Definition: ndole.cxx:915
static SotStorage * OpenOLEStorage(css::uno::Reference< css::embed::XStorage > const &xStorage, OUString const &rEleName, StreamMode=StreamMode::STD_READWRITE)
sal_uInt16 GetDistance(SvxBoxItemLine nLine) const
bool IsLinkedFile() const
Definition: ndgrf.hxx:164
sal_uInt64 Seek(sal_uInt64 nPos)
static void WriteString8(SvStream &rStrm, std::u16string_view rStr, bool bAddZero, rtl_TextEncoding eCodeSet)
Definition: wrtww8.cxx:1764
bool IsStream(const OUString &rEleName) const
void Set_UInt32(sal_uInt8 *&p, sal_uInt32 n)
Definition: ww8struc.hxx:53
static constexpr sal_uInt16 val
Definition: sprmids.hxx:277
static void Free(SdrObject *&_rpObject)
bool WriteWindowMetafileBits(SvStream &rStream, const GDIMetaFile &rMTF)
OUString FieldString(ww::eField eIndex)
Definition: ww8atr.cxx:2648
bool Commit()
IDocumentDrawModelAccess const & getIDocumentDrawModelAccess() const
Definition: doc.cxx:155
constexpr auto convertTwipToMm100(N n)
static OutputDevice * GetDefaultDevice()
static void WritePICFHeader(SvStream &rStrm, const ww8::Frame &rFly, sal_uInt16 mm, sal_uInt16 nWidth, sal_uInt16 nHeight, const SwAttrSet *pAttrSet=nullptr)
Definition: wrtww8gr.cxx:477
constexpr TypedWhichId< SwFormatVertOrient > RES_VERT_ORIENT(102)
const SfxPoolItem * NextItem()
virtual void OutputOLENode(const SwOLENode &) override
Output SwOLENode.
Definition: wrtww8gr.cxx:196
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:1787
static std::unique_ptr< SvStream > CreateStream(const OUString &rFileName, StreamMode eOpenMode, css::uno::Reference< css::awt::XWindow > xParentWin=nullptr)
bool fFrame() const
Definition: ww8struc.hxx:331
void OutputFormat(const SwFormat &rFormat, bool bPapFormat, bool bChpFormat, bool bFlyFormat=false)
Output attributes.
Definition: ww8atr.cxx:798
sal_uInt32 cv() const
Definition: ww8struc.hxx:321
bool IsInVerticalText(const SwPosition &rPos) const
Definition: doclay.cxx:1665
sal_uInt8 dptSpace() const
Definition: ww8struc.hxx:327
const Size & GetLayoutSize() const
The layout size of the contained element.
WW8Export & rWrt
for access to the variables
Definition: wrtww8.hxx:1404
bool CopyTo(SotStorage *pDestStg)
const GDIMetaFile & GetGDIMetaFile() const
SvStream & WriteUInt32(sal_uInt32 nUInt32)
short DetermineBorderProperties(short *pSpace) const
Definition: ww8scan.cxx:1364
void Set_UInt16(sal_uInt8 *&p, sal_uInt16 n)
Definition: ww8struc.hxx:47
const editeng::SvxBorderLine * GetLine(SvxBoxItemLine nLine) const
void OutGrf(const ww8::Frame &rFrame)
Definition: wrtww8gr.cxx:356
static WW8_BRCVer9 TranslateBorderLine(const ::editeng::SvxBorderLine &pLine, sal_uInt16 nDist, bool bShadow)
Definition: ww8atr.cxx:4373
void WriteChar(sal_Unicode c) override
Definition: wrtww8.cxx:1870
bool GetFileFilterNms(OUString *pFileNm, OUString *pFilterNm) const
Definition: ndgrf.cxx:494
void WriteGraphicNode(SvStream &rStrm, const GraphicDetails &rItem)
Definition: wrtww8gr.cxx:752
void WriteGrfBullet(const Graphic &)
Definition: wrtw8esh.cxx:1566
const SwFrameFormat & GetFrameFormat() const
Get the writer SwFrameFormat that this object describes.
sal_uInt16 mnWid
Definition: wrtww8.hxx:1383
std::vector< GraphicDetails > maDetails
Definition: wrtww8.hxx:1406
const SwAttrSet * GetpSwAttrSet() const
Definition: node.hxx:452
std::unique_ptr< WW8_WrPlcPn > m_pPapPlc
Definition: wrtww8.hxx:496
T * get() const
static sal_uInt8 nAttrMagicIdx
Definition: wrtww8.cxx:1597
Style of a layout element.
Definition: frmfmt.hxx:58
#define SAL_MAX_INT32
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
int i
SwDoc & GetDoc()
Definition: node.hxx:212
RndStdIds GetAnchorId() const
Definition: fmtanchr.hxx:65
tools::SvRef< SotStorageStream > OpenSotStream(const OUString &rEleName, StreamMode=StreamMode::STD_READWRITE)
constexpr TypedWhichId< SwCropGrf > RES_GRFATR_CROPGRF(134)
void WriteGrfFromGrfNode(SvStream &rStrm, const SwGrfNode &rNd, const ww8::Frame &rFly, sal_uInt16 nWidth, sal_uInt16 nHeight)
Definition: wrtww8gr.cxx:632
const SvxPageUsage aArr[]
const ww8::Frame * m_pParentFrame
Definition: wrtww8.hxx:516
eINCLUDEPICTURE
std::size_t WriteBytes(const void *pData, std::size_t nSize)
const Graphic & GetGraphic() const
SwDoc & m_rDoc
Definition: wrtww8.hxx:572
virtual void WriteCR(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner=ww8::WW8TableNodeInfoInner::Pointer_t()) override
Definition: wrtww8.cxx:1860
SwWW8Writer & GetWriter() const
Definition: wrtww8.hxx:1177
::Color BGRToRGB(sal_uInt32 nColour)
WW8OleMap m_aOleMap
Definition: wrtww8.hxx:476
tools::Long GetHeight() const
tools::Long SwTwips
Definition: swtypes.hxx:49
constexpr TypedWhichId< SwFormatContent > RES_CNTNT(95)
SVBT16 aBits2
Definition: ww8struc.hxx:264
SwWW8Writer * m_pWriter
Pointer to the writer.
Definition: wrtww8.hxx:1001
sal_uInt8 dptLineWidth() const
Definition: ww8struc.hxx:323
Size GetPrefSize() const
sal_Int32 GetBottom() const
virtual void OutputGrfNode(const SwGrfNode &) override
Output SwGrfNode.
Definition: wrtww8gr.cxx:74
const SwNode * GetContent() const
Get the first node of content in the frame.
sal_Int32 GetTop() const
SotStorage & GetStorage() const
Definition: shellio.hxx:494
SvStream & Strm() const
Definition: wrtww8.hxx:1178
#define ERRCODE_NONE
unsigned char sal_uInt8
Make exporting a Writer Frame easy.
std::unique_ptr< SwWW8WrGrf > m_pGrf
Definition: wrtww8.hxx:533
const o3tl::enumarray< SvxAdjust, unsigned short > aSvxToUnoAdjust USHRT_MAX
Definition: unosett.cxx:254
const OUString & GetTargetFrameName() const
Definition: fmturl.hxx:65
virtual void WritePictures()
Definition: wrtw8esh.cxx:2183
#define GRF_MAGIC_321
Definition: wrtww8.hxx:137
#define SAL_INFO(area, stream)
SvStream & WriteUChar(unsigned char nChar)
SvStream * pDataStrm
Streams for WW97 Export.
Definition: wrtww8.hxx:990
const Size & GetSize() const
The Size of the contained element.
virtual SwDrawModel * GetOrCreateDrawModel()=0
virtual void OutputLinkedOLE(const OUString &) override
Definition: wrtww8gr.cxx:319
SvxBoxItemLine
sal_uInt64 Tell() const
void WriteEmptyFlyFrame(const SwFrameFormat &rFormat, sal_uInt32 nShapeId)
Definition: wrtw8esh.cxx:1532
bool TestOleNeedsGraphic(const SwAttrSet &rSet, tools::SvRef< SotStorage > const &xOleStg, const tools::SvRef< SotStorage > &xObjStg, OUString const &rStorageName, SwOLENode *pOLENd)
Definition: wrtww8gr.cxx:85
sal_Int16 GetVertOrient() const
Definition: fmtornt.hxx:54
static void InsUInt16(ww::bytes &rO, sal_uInt16 n)
Definition: wrtww8.cxx:1706
constexpr TypedWhichId< SvxBoxItem > RES_BOX(106)
const SwFormatFrameSize & GetFrameSize(bool=true) const
Definition: fmtfsize.hxx:104
void Write()
Definition: wrtww8gr.cxx:857
sal_Int32 GetRight() const
sal_uInt16 mnHei
Definition: wrtww8.hxx:1384
static GraphicFilter & GetGraphicFilter()
void Insert(const ww8::Frame &rFly)
Definition: wrtww8gr.cxx:469
void Set_UInt8(sal_uInt8 *&p, sal_uInt8 n)
Definition: ww8struc.hxx:41
RndStdIds
bool IsInline() const
Is this frame inline (as character)
WriterSource GetWriterType() const
Get the type of frame that this wraps.
ww8::Frame maFly
Definition: wrtww8.hxx:1381
SwGrfNode * GetGrfNode()
Definition: ndgrf.hxx:154
const SwAttrSet & GetAttrSet() const
For querying the attribute array.
Definition: format.hxx:120
const SfxPoolItem * GetItem(sal_uInt16 nWhich, bool bSearchInParent=true) const
void SvStream & rStrm
void WriteGrfForBullet(SvStream &rStrm, const Graphic &rGrf, sal_uInt16 nWidth, sal_uInt16 nHeight)
Definition: wrtww8gr.cxx:744
static void FillCount(SvStream &rStrm, sal_uLong nCount)
Definition: wrtww8.cxx:931
std::unique_ptr< WW8_WrPlcPn > m_pChpPlc
Definition: wrtww8.hxx:497
constexpr TypedWhichId< SvxShadowItem > RES_SHADOW(107)
sal_uInt16 nPos
const SfxPoolItem * GetCurItem() const
constexpr TypedWhichId< SwFormatAnchor > RES_ANCHOR(104)
constexpr OUStringLiteral aObjectPool
Definition: ww8scan.hxx:44
const OUString & GetURL() const
Definition: fmturl.hxx:66
bool fShadow() const
Definition: ww8struc.hxx:329
Base class of the Writer document model elements.
Definition: node.hxx:80
std::unique_ptr< WW8AttributeOutput > m_pAttrOutput
Converting attributes to stream data.
Definition: wrtww8.hxx:1002