?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Drop some needless mappings to identical strings
[LibreOffice.git] / filter / source / msfilter / escherex.cxx
blob1fbba9923dc27b628fbfccb8e3d7e52d4bf9b480
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 "eschesdo.hxx"
21 #include <o3tl/any.hxx>
22 #include <o3tl/string_view.hxx>
23 #include <svx/svdxcgv.hxx>
24 #include <svx/svdomedia.hxx>
25 #include <svx/xflftrit.hxx>
26 #include <filter/msfilter/escherex.hxx>
27 #include <filter/msfilter/util.hxx>
28 #include <svx/unoapi.hxx>
29 #include <svx/svdobj.hxx>
30 #include <svx/svdoashp.hxx>
31 #include <svx/svdoole2.hxx>
32 #include <svx/sdtfsitm.hxx>
33 #include <editeng/outlobj.hxx>
34 #include <utility>
35 #include <vcl/graph.hxx>
36 #include <vcl/cvtgrf.hxx>
37 #include <vcl/svapp.hxx>
38 #include <tools/debug.hxx>
39 #include <tools/stream.hxx>
40 #include <tools/zcodec.hxx>
41 #include <tools/urlobj.hxx>
42 #include <svx/svdopath.hxx>
43 #include <stdlib.h>
44 #include <vcl/graphicfilter.hxx>
45 #include <svx/EnhancedCustomShapeTypeNames.hxx>
46 #include <svx/EnhancedCustomShapeGeometry.hxx>
47 #include <svx/EnhancedCustomShapeFunctionParser.hxx>
48 #include <svx/EnhancedCustomShape2d.hxx>
49 #include <com/sun/star/beans/PropertyValues.hpp>
50 #include <com/sun/star/beans/XPropertySet.hpp>
51 #include <com/sun/star/beans/XPropertyState.hpp>
52 #include <com/sun/star/awt/GradientStyle.hpp>
53 #include <com/sun/star/awt/Gradient.hpp>
54 #include <com/sun/star/drawing/LineStyle.hpp>
55 #include <com/sun/star/drawing/LineJoint.hpp>
56 #include <com/sun/star/drawing/LineCap.hpp>
57 #include <com/sun/star/drawing/FillStyle.hpp>
58 #include <com/sun/star/drawing/LineDash.hpp>
59 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
60 #include <com/sun/star/drawing/ConnectorType.hpp>
61 #include <com/sun/star/drawing/CircleKind.hpp>
62 #include <com/sun/star/drawing/PointSequence.hpp>
63 #include <com/sun/star/drawing/FlagSequence.hpp>
64 #include <com/sun/star/drawing/PolygonFlags.hpp>
65 #include <com/sun/star/text/WritingMode.hpp>
66 #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
67 #include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
68 #include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
69 #include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
70 #include <com/sun/star/drawing/EnhancedCustomShapeGluePointType.hpp>
71 #include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
72 #include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
73 #include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
74 #include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
75 #include <com/sun/star/drawing/ProjectionMode.hpp>
76 #include <com/sun/star/text/XSimpleText.hpp>
77 #include <com/sun/star/drawing/ShadeMode.hpp>
78 #include <com/sun/star/drawing/TextFitToSizeType.hpp>
79 #include <vcl/hatch.hxx>
80 #include <com/sun/star/awt/FontSlant.hpp>
81 #include <com/sun/star/awt/FontWeight.hpp>
82 #include <com/sun/star/drawing/ColorMode.hpp>
83 #include <com/sun/star/drawing/Position3D.hpp>
84 #include <com/sun/star/drawing/Direction3D.hpp>
85 #include <com/sun/star/drawing/Hatch.hpp>
86 #include <com/sun/star/graphic/XGraphic.hpp>
87 #include <com/sun/star/text/GraphicCrop.hpp>
88 #include <unotools/ucbstreamhelper.hxx>
89 #include <comphelper/string.hxx>
90 #include <vcl/virdev.hxx>
91 #include <rtl/crc.h>
92 #include <rtl/strbuf.hxx>
93 #include <sal/log.hxx>
94 #include <basegfx/polygon/b2dpolypolygontools.hxx>
95 #include <basegfx/polygon/b2dpolygontools.hxx>
96 #include <basegfx/numeric/ftools.hxx>
97 #include <osl/diagnose.h>
98
99 #include <algorithm>
100 #include <memory>
101
102 using namespace css;
103
104 EscherExContainer::EscherExContainer( SvStream& rSt, const sal_uInt16 nRecType, const sal_uInt16 nInstance ) :
105 rStrm ( rSt )
106 {
107 rStrm.WriteUInt32( ( 0xf | ( nInstance << 4 ) ) | ( nRecType << 16 ) ).WriteUInt32( 0 );
108 nContPos = rStrm.Tell();
109 }
110 EscherExContainer::~EscherExContainer()
111 {
112 sal_uInt64 nPos = rStrm.Tell();
113 sal_uInt32 nSize = nPos - nContPos;
114 if ( nSize )
115 {
116 rStrm.Seek( nContPos - 4 );
117 rStrm.WriteUInt32( nSize );
118 rStrm.Seek( nPos );
119 }
120 }
121
122 EscherExAtom::EscherExAtom( SvStream& rSt, const sal_uInt16 nRecType, const sal_uInt16 nInstance, const sal_uInt8 nVersion ) :
123 rStrm ( rSt )
124 {
125 rStrm.WriteUInt32( ( nVersion | ( nInstance << 4 ) ) | ( nRecType << 16 ) ).WriteUInt32( 0 );
126 nContPos = rStrm.Tell();
127 }
128 EscherExAtom::~EscherExAtom()
129 {
130 sal_uInt64 nPos = rStrm.Tell();
131 sal_uInt32 nSize = nPos - nContPos;
132 if ( nSize )
133 {
134 rStrm.Seek( nContPos - 4 );
135 rStrm.WriteUInt32( nSize );
136 rStrm.Seek( nPos );
137 }
138 }
139
140 EscherExClientRecord_Base::~EscherExClientRecord_Base()
141 {
142 }
143
144 EscherExClientAnchor_Base::~EscherExClientAnchor_Base()
145 {
146 }
147
148 EscherPropertyContainer::EscherPropertyContainer(
149 EscherGraphicProvider * pGraphProv, SvStream * pPiOutStrm,
150 tools::Rectangle * pBoundRect):
151 pGraphicProvider(pGraphProv),
152 pPicOutStrm(pPiOutStrm),
153 pShapeBoundRect(pBoundRect),
154 nCountCount(0),
155 nCountSize(0),
156 bHasComplexData(false)
157 {
158 pSortStruct.reserve(64);
159 }
160
161 EscherPropertyContainer::EscherPropertyContainer()
162 : EscherPropertyContainer(nullptr, nullptr, nullptr)
163 {}
164
165 EscherPropertyContainer::EscherPropertyContainer(
166 EscherGraphicProvider& rGraphProv,
167 SvStream* pPiOutStrm,
168 tools::Rectangle& rBoundRect ) :
169 EscherPropertyContainer(&rGraphProv, pPiOutStrm, &rBoundRect)
170 {}
171
172 EscherPropertyContainer::~EscherPropertyContainer()
173 {
174 };
175
176 void EscherPropertyContainer::AddOpt(
177 sal_uInt16 nPropID,
178 bool bBlib,
179 sal_uInt32 nSizeReduction,
180 SvMemoryStream& rStream)
181 {
182 sal_uInt8 const* pBuf(static_cast<sal_uInt8 const *>(rStream.GetData()));
183 const sal_uInt64 nSize(rStream.GetSize());
184 std::vector<sal_uInt8> aBuf;
185 aBuf.reserve(nSize);
186
187 for(sal_uInt64 a(0); a < nSize; a++)
188 {
189 aBuf.push_back(*pBuf++);
190 }
191
192 sal_uInt32 nPropValue(static_cast<sal_uInt32>(nSize));
193
194 if(0 != nSizeReduction && nPropValue > nSizeReduction)
195 {
196 nPropValue -= nSizeReduction;
197 }
198
199 AddOpt(nPropID, bBlib, nPropValue, aBuf);
200 }
201
202 void EscherPropertyContainer::AddOpt(
203 sal_uInt16 nPropID,
204 sal_uInt32 nPropValue,
205 bool bBlib)
206 {
207 AddOpt(nPropID, bBlib, nPropValue, std::vector<sal_uInt8>());
208 }
209
210 void EscherPropertyContainer::AddOpt(
211 sal_uInt16 nPropID,
212 std::u16string_view rString)
213 {
214 std::vector<sal_uInt8> aBuf;
215 aBuf.reserve(rString.size() * 2 + 2);
216
217 for(const sal_Unicode nUnicode: rString)
218 {
219 aBuf.push_back(static_cast<sal_uInt8>(nUnicode));
220 aBuf.push_back(static_cast<sal_uInt8>(nUnicode >> 8));
221 }
222
223 aBuf.push_back(0);
224 aBuf.push_back(0);
225
226 AddOpt(nPropID, true, aBuf.size(), aBuf);
227 }
228
229 void EscherPropertyContainer::AddOpt(
230 sal_uInt16 nPropID,
231 bool bBlib,
232 sal_uInt32 nPropValue,
233 const std::vector<sal_uInt8>& rProp)
234 {
235 if ( bBlib ) // bBlib is only valid when fComplex = 0
236 nPropID |= 0x4000;
237 if ( !rProp.empty() )
238 nPropID |= 0x8000; // fComplex = sal_True;
239
240 for( size_t i = 0; i < pSortStruct.size(); i++ )
241 {
242 if ( ( pSortStruct[ i ].nPropId &~0xc000 ) == ( nPropID &~0xc000 ) ) // check, whether the Property only gets replaced
243 {
244 pSortStruct[ i ].nPropId = nPropID;
245 if ( !pSortStruct[ i ].nProp.empty() )
246 {
247 nCountSize -= pSortStruct[ i ].nProp.size();
248 }
249 pSortStruct[ i ].nProp = rProp;
250 pSortStruct[ i ].nPropValue = nPropValue;
251 if ( !rProp.empty() )
252 nCountSize += rProp.size();
253 return;
254 }
255 }
256 nCountCount++;
257 nCountSize += 6;
258 pSortStruct.emplace_back();
259 pSortStruct.back().nPropId = nPropID; // insert property
260 pSortStruct.back().nProp = rProp;
261 pSortStruct.back().nPropValue = nPropValue;
262
263 if ( !rProp.empty() )
264 {
265 nCountSize += rProp.size();
266 bHasComplexData = true;
267 }
268 }
269
270 bool EscherPropertyContainer::GetOpt( sal_uInt16 nPropId, sal_uInt32& rPropValue ) const
271 {
272 EscherPropSortStruct aPropStruct;
273
274 if ( GetOpt( nPropId, aPropStruct ) )
275 {
276 rPropValue = aPropStruct.nPropValue;
277 return true;
278 }
279 return false;
280 }
281
282 bool EscherPropertyContainer::GetOpt( sal_uInt16 nPropId, EscherPropSortStruct& rPropValue ) const
283 {
284 for( size_t i = 0; i < pSortStruct.size(); i++ )
285 {
286 if ( ( pSortStruct[ i ].nPropId &~0xc000 ) == ( nPropId &~0xc000 ) )
287 {
288 rPropValue = pSortStruct[ i ];
289 return true;
290 }
291 }
292 return false;
293 }
294
295 const EscherProperties & EscherPropertyContainer::GetOpts() const
296 {
297 return pSortStruct;
298 }
299
300 extern "C" {
301
302 static int EscherPropSortFunc( const void* p1, const void* p2 )
303 {
304 sal_Int16 nID1 = static_cast<EscherPropSortStruct const *>(p1)->nPropId &~0xc000;
305 sal_Int16 nID2 = static_cast<EscherPropSortStruct const *>(p2)->nPropId &~0xc000;
306
307 if( nID1 < nID2 )
308 return -1;
309 else if( nID1 > nID2 )
310 return 1;
311 else
312 return 0;
313 }
314
315 }
316
317 void EscherPropertyContainer::Commit( SvStream& rSt, sal_uInt16 nVersion, sal_uInt16 nRecType )
318 {
319 rSt.WriteUInt16( ( nCountCount << 4 ) | ( nVersion & 0xf ) ).WriteUInt16( nRecType ).WriteUInt32( nCountSize );
320 if ( pSortStruct.empty() )
321 return;
322
323 qsort( pSortStruct.data(), pSortStruct.size(), sizeof( EscherPropSortStruct ), EscherPropSortFunc );
324
325 for ( size_t i = 0; i < pSortStruct.size(); i++ )
326 {
327 sal_uInt32 nPropValue = pSortStruct[ i ].nPropValue;
328 sal_uInt16 nPropId = pSortStruct[ i ].nPropId;
329
330 rSt.WriteUInt16( nPropId )
331 .WriteUInt32( nPropValue );
332 }
333 if ( bHasComplexData )
334 {
335 for ( size_t i = 0; i < pSortStruct.size(); i++ )
336 {
337 if ( !pSortStruct[ i ].nProp.empty() )
338 rSt.WriteBytes(
339 pSortStruct[i].nProp.data(),
340 pSortStruct[i].nProp.size());
341 }
342 }
343 }
344
345 bool EscherPropertyContainer::IsFontWork() const
346 {
347 sal_uInt32 nTextPathFlags = 0;
348 GetOpt( DFF_Prop_gtextFStrikethrough, nTextPathFlags );
349 return ( nTextPathFlags & 0x4000 ) != 0;
350 }
351
352 sal_uInt32 EscherPropertyContainer::ImplGetColor( const sal_uInt32 nSOColor, bool bSwap )
353 {
354 if ( bSwap )
355 {
356 sal_uInt32 nColor = nSOColor & 0xff00; // green
357 nColor |= static_cast<sal_uInt8>(nSOColor) << 16; // red
358 nColor |= static_cast<sal_uInt8>( nSOColor >> 16 ); // blue
359 return nColor;
360 }
361 else
362 return nSOColor & 0xffffff;
363 }
364
365 sal_uInt32 EscherPropertyContainer::GetGradientColor(
366 const awt::Gradient* pGradient,
367 sal_uInt32 nStartColor )
368 {
369 sal_uInt32 nIntensity = 100;
370 Color aColor;
371
372 if ( pGradient )
373 {
374 if ( nStartColor & 1 )
375 {
376 nIntensity = pGradient->StartIntensity;
377 aColor = Color(ColorTransparency, pGradient->StartColor);
378 }
379 else
380 {
381 nIntensity = pGradient->EndIntensity;
382 aColor = Color(ColorTransparency, pGradient->EndColor);
383 }
384 }
385 sal_uInt32 nRed = ( aColor.GetRed() * nIntensity ) / 100;
386 sal_uInt32 nGreen = ( ( aColor.GetGreen() * nIntensity ) / 100 ) << 8;
387 sal_uInt32 nBlue = ( ( aColor.GetBlue() * nIntensity ) / 100 ) << 16;
388 return nRed | nGreen | nBlue;
389 }
390
391 void EscherPropertyContainer::CreateGradientProperties(
392 const awt::Gradient & rGradient )
393 {
394 sal_uInt32 nFillType = ESCHER_FillShadeScale;
395 sal_uInt32 nAngle = 0;
396 sal_uInt32 nFillFocus = 0;
397 sal_uInt32 nFillLR = 0;
398 sal_uInt32 nFillTB = 0;
399 sal_uInt32 nFirstColor = 0;
400 bool bWriteFillTo = false;
401
402 switch ( rGradient.Style )
403 {
404 case awt::GradientStyle_LINEAR :
405 case awt::GradientStyle_AXIAL :
406 {
407 nFillType = ESCHER_FillShadeScale;
408 nAngle = (rGradient.Angle * 0x10000) / 10;
409 nFillFocus = (sal::static_int_cast<int>(rGradient.Style) ==
410 sal::static_int_cast<int>(css::awt::GradientStyle_LINEAR)) ? 0 : 50;
411 }
412 break;
413 case awt::GradientStyle_RADIAL :
414 case awt::GradientStyle_ELLIPTICAL :
415 case awt::GradientStyle_SQUARE :
416 case awt::GradientStyle_RECT :
417 {
418 nFillLR = (rGradient.XOffset * 0x10000) / 100;
419 nFillTB = (rGradient.YOffset * 0x10000) / 100;
420 if ( ((nFillLR > 0) && (nFillLR < 0x10000)) || ((nFillTB > 0) && (nFillTB < 0x10000)) )
421 nFillType = ESCHER_FillShadeShape;
422 else
423 nFillType = ESCHER_FillShadeCenter;
424 nFirstColor = 1;
425 bWriteFillTo = true;
426 }
427 break;
428 case awt::GradientStyle::GradientStyle_MAKE_FIXED_SIZE : break;
429 }
430 AddOpt( ESCHER_Prop_fillType, nFillType );
431 AddOpt( ESCHER_Prop_fillAngle, nAngle );
432 AddOpt( ESCHER_Prop_fillColor, GetGradientColor( &rGradient, nFirstColor ) );
433 AddOpt( ESCHER_Prop_fillBackColor, GetGradientColor( &rGradient, nFirstColor ^ 1 ) );
434 AddOpt( ESCHER_Prop_fillFocus, nFillFocus );
435 if ( bWriteFillTo )
436 {
437 AddOpt( ESCHER_Prop_fillToLeft, nFillLR );
438 AddOpt( ESCHER_Prop_fillToTop, nFillTB );
439 AddOpt( ESCHER_Prop_fillToRight, nFillLR );
440 AddOpt( ESCHER_Prop_fillToBottom, nFillTB );
441 }
442 }
443
444 void EscherPropertyContainer::CreateGradientProperties(
445 const uno::Reference<beans::XPropertySet> & rXPropSet , bool bTransparentGradient)
446 {
447 uno::Any aAny;
448 awt::Gradient const * pGradient = nullptr;
449
450 sal_uInt32 nFillType = ESCHER_FillShadeScale;
451 sal_Int32 nAngle = 0;
452 sal_uInt32 nFillFocus = 0;
453 sal_uInt32 nFillLR = 0;
454 sal_uInt32 nFillTB = 0;
455 sal_uInt32 nFirstColor = 0;// like the control var nChgColors in import logic
456 bool bWriteFillTo = false;
457
458 // Transparency gradient: Means the third setting in transparency page is set
459 if (bTransparentGradient && EscherPropertyValueHelper::GetPropertyValue(
460 aAny, rXPropSet, u"FillTransparenceGradient"_ustr ) )
461 {
462 pGradient = o3tl::doAccess<awt::Gradient>(aAny);
463
464 uno::Any aAnyTemp;
465 if ( EscherPropertyValueHelper::GetPropertyValue(
466 aAnyTemp, rXPropSet, u"FillStyle"_ustr ) )
467 {
468 drawing::FillStyle eFS;
469 if ( ! ( aAnyTemp >>= eFS ) )
470 eFS = drawing::FillStyle_SOLID;
471 // solid and transparency
472 if ( eFS == drawing::FillStyle_SOLID)
473 {
474 if ( EscherPropertyValueHelper::GetPropertyValue(
475 aAnyTemp, rXPropSet, u"FillColor"_ustr ) )
476 {
477 const_cast<awt::Gradient *>(pGradient)->StartColor = ImplGetColor( *o3tl::doAccess<sal_uInt32>(aAnyTemp), false );
478 const_cast<awt::Gradient *>(pGradient)->EndColor = ImplGetColor( *o3tl::doAccess<sal_uInt32>(aAnyTemp), false );
479 }
480 }
481 // gradient and transparency.
482 else if( eFS == drawing::FillStyle_GRADIENT )
483 {
484 if ( EscherPropertyValueHelper::GetPropertyValue(
485 aAny, rXPropSet, u"FillGradient"_ustr ) )
486 pGradient = o3tl::doAccess<awt::Gradient>(aAny);
487 }
488 }
489
490 }
491 // Not transparency gradient
492 else if ( EscherPropertyValueHelper::GetPropertyValue(
493 aAny, rXPropSet, u"FillGradient"_ustr ) )
494 {
495 pGradient = o3tl::doAccess<awt::Gradient>(aAny);
496 }
497
498 if ( pGradient )
499 {
500 switch ( pGradient->Style )
501 {
502 case awt::GradientStyle_LINEAR :
503 case awt::GradientStyle_AXIAL :
504 {
505 nFillType = ESCHER_FillShadeScale;
506 nAngle = pGradient->Angle;
507 while ( nAngle > 0 ) nAngle -= 3600;
508 while ( nAngle <= -3600 ) nAngle += 3600;
509 // Value of the real number = Integral + (Fractional / 65536.0)
510 nAngle = ( nAngle * 0x10000) / 10;
511
512 nFillFocus = (pGradient->Style == awt::GradientStyle_LINEAR) ?
513 ( pGradient->XOffset + pGradient->YOffset )/2 : -50;
514 if( !nFillFocus )
515 nFirstColor=nFirstColor ^ 1;
516 if ( !nAngle )
517 nFirstColor=nFirstColor ^ 1;
518 }
519 break;
520 case awt::GradientStyle_RADIAL :
521 case awt::GradientStyle_ELLIPTICAL :
522 case awt::GradientStyle_SQUARE :
523 case awt::GradientStyle_RECT :
524 {
525 // according to the import logic and rect type fill** value
526 nFillLR = (pGradient->XOffset * 0x10000) / 100;
527 nFillTB = (pGradient->YOffset * 0x10000) / 100;
528 if ( ((nFillLR > 0) && (nFillLR < 0x10000)) || ((nFillTB > 0) && (nFillTB < 0x10000)) )
529 nFillType = ESCHER_FillShadeShape;
530 else
531 nFillType = ESCHER_FillShadeCenter;
532 nFirstColor = 1;
533 bWriteFillTo = true;
534 }
535 break;
536 default: break;
537 }
538 }
539
540 AddOpt( ESCHER_Prop_fillType, nFillType );
541 AddOpt( ESCHER_Prop_fillAngle, nAngle );
542 AddOpt( ESCHER_Prop_fillColor, GetGradientColor( pGradient, nFirstColor ) );
543 AddOpt( ESCHER_Prop_fillBackColor, GetGradientColor( pGradient, nFirstColor ^ 1 ) );
544 AddOpt( ESCHER_Prop_fillFocus, nFillFocus );
545 if ( bWriteFillTo )
546 {
547 // according to rect type fillTo** value
548 if(nFillLR)
549 {
550 AddOpt( ESCHER_Prop_fillToLeft, nFillLR );
551 AddOpt( ESCHER_Prop_fillToRight, nFillLR );
552 }
553 if(nFillTB)
554 {
555 AddOpt( ESCHER_Prop_fillToTop, nFillTB );
556 AddOpt( ESCHER_Prop_fillToBottom, nFillTB );
557 }
558 }
559
560 // Transparency gradient
561 if (bTransparentGradient && EscherPropertyValueHelper::GetPropertyValue(
562 aAny, rXPropSet, u"FillTransparenceGradient"_ustr ) )
563 {
564 pGradient = o3tl::doAccess<awt::Gradient>(aAny);
565 if ( pGradient )
566 {
567 sal_uInt32 nBlue = GetGradientColor( pGradient, nFirstColor ) >> 16;
568 AddOpt( ESCHER_Prop_fillOpacity,( ( 100 - ( nBlue * 100 / 255 ) ) << 16 ) / 100 );
569 nBlue = GetGradientColor( pGradient, nFirstColor ^ 1 ) >>16 ;
570 AddOpt( ESCHER_Prop_fillBackOpacity,( ( 100 - ( nBlue * 100 / 255 ) ) << 16 )/ 100 );
571 }
572 }
573 }
574
575 void EscherPropertyContainer::CreateFillProperties(
576 const uno::Reference<beans::XPropertySet> & rXPropSet,
577 bool bEdge , const uno::Reference<drawing::XShape> & rXShape )
578 {
579 if ( rXShape.is() )
580 {
581 SdrObject* pObj = SdrObject::getSdrObjectFromXShape(rXShape);
582 if ( pObj )
583 {
584 const SfxItemSet& aAttr( pObj->GetMergedItemSet() );
585 // transparency with gradient. Means the third setting in transparency page is set
586 bool bTransparentGradient = ( aAttr.GetItemState( XATTR_FILLFLOATTRANSPARENCE ) == SfxItemState::SET ) &&
587 aAttr.Get( XATTR_FILLFLOATTRANSPARENCE ).IsEnabled();
588 CreateFillProperties( rXPropSet, bEdge, bTransparentGradient );
589 }
590 }
591 }
592
593 void EscherPropertyContainer::CreateFillProperties(
594 const uno::Reference<beans::XPropertySet> & rXPropSet,
595 bool bEdge , bool bTransparentGradient)
596
597 {
598 uno::Any aAny;
599 AddOpt( ESCHER_Prop_WrapText, ESCHER_WrapNone );
600 AddOpt( ESCHER_Prop_AnchorText, ESCHER_AnchorMiddle );
601 static constexpr OUString aPropName( u"FillStyle"_ustr );
602
603 if ( EscherPropertyValueHelper::GetPropertyValue(
604 aAny, rXPropSet, aPropName ) )
605 {
606 drawing::FillStyle eFS;
607 if ( ! ( aAny >>= eFS ) )
608 eFS = drawing::FillStyle_SOLID;
609 sal_uInt32 nFillBackColor = 0;
610 switch( eFS )
611 {
612 case drawing::FillStyle_GRADIENT :
613 {
614 CreateGradientProperties( rXPropSet , bTransparentGradient );
615 AddOpt( ESCHER_Prop_fNoFillHitTest, 0x140014 );
616 }
617 break;
618
619 case drawing::FillStyle_BITMAP :
620 {
621 CreateGraphicProperties(rXPropSet, u"FillBitmap"_ustr, true);
622 AddOpt( ESCHER_Prop_fNoFillHitTest, 0x140014 );
623 AddOpt( ESCHER_Prop_fillBackColor, nFillBackColor );
624 }
625 break;
626 case drawing::FillStyle_HATCH :
627 {
628 CreateGraphicProperties( rXPropSet, u"FillHatch"_ustr, true );
629 }
630 break;
631 case drawing::FillStyle_SOLID :
632 default:
633 {
634 if ( bTransparentGradient )
635 CreateGradientProperties( rXPropSet , bTransparentGradient );
636 else
637 {
638 beans::PropertyState ePropState = EscherPropertyValueHelper::GetPropertyState(
639 rXPropSet, aPropName );
640 if ( ePropState == beans::PropertyState_DIRECT_VALUE )
641 AddOpt( ESCHER_Prop_fillType, ESCHER_FillSolid );
642
643 if ( EscherPropertyValueHelper::GetPropertyValue(
644 aAny, rXPropSet, u"FillColor"_ustr ) )
645 {
646 sal_uInt32 nFillColor = ImplGetColor( *o3tl::doAccess<sal_uInt32>(aAny) );
647 nFillBackColor = nFillColor ^ 0xffffff;
648 AddOpt( ESCHER_Prop_fillColor, nFillColor );
649 }
650 AddOpt( ESCHER_Prop_fNoFillHitTest, 0x100010 );
651 AddOpt( ESCHER_Prop_fillBackColor, nFillBackColor );
652 }
653 break;
654 }
655 case drawing::FillStyle_NONE :
656 AddOpt( ESCHER_Prop_fNoFillHitTest, 0x100000 );
657 break;
658 }
659 if ( eFS != drawing::FillStyle_NONE )
660 {
661 sal_uInt16 nTransparency = ( EscherPropertyValueHelper::GetPropertyValue(
662 aAny, rXPropSet, u"FillTransparence"_ustr, true ) )
663 ? *o3tl::doAccess<sal_Int16>(aAny) : 0;
664 if ( nTransparency )
665 AddOpt( ESCHER_Prop_fillOpacity, ( ( 100 - nTransparency ) << 16 ) / 100 );
666 }
667 }
668 CreateLineProperties( rXPropSet, bEdge );
669 }
670
671 void EscherPropertyContainer::CreateTextProperties(
672 const uno::Reference< beans::XPropertySet > & rXPropSet, sal_uInt32 nTextId,
673 const bool bIsCustomShape, const bool bIsTextFrame )
674 {
675 uno::Any aAny;
676 text::WritingMode eWM( text::WritingMode_LR_TB );
677 drawing::TextVerticalAdjust eVA( drawing::TextVerticalAdjust_TOP );
678 drawing::TextHorizontalAdjust eHA( drawing::TextHorizontalAdjust_LEFT );
679
680 sal_Int32 nLeft ( 0 );
681 sal_Int32 nTop ( 0 );
682 sal_Int32 nRight ( 0 );
683 sal_Int32 nBottom ( 0 );
684
685 // used with normal shapes:
686 bool bAutoGrowWidth ( false );
687 const bool bAutoGrowHeight ( false ); //#ii63936 not setting autogrowheight, because minframeheight would be ignored
688 // used with ashapes:
689 bool bWordWrap ( false );
690 bool bAutoGrowSize ( false );
691
692 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextWritingMode"_ustr, true ) )
693 aAny >>= eWM;
694 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextVerticalAdjust"_ustr, true ) )
695 aAny >>= eVA;
696 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextHorizontalAdjust"_ustr, true ) )
697 aAny >>= eHA;
698 if ( bIsCustomShape )
699 {
700 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextWordWrap"_ustr ) )
701 aAny >>= bWordWrap;
702 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextAutoGrowHeight"_ustr, true ) )
703 aAny >>= bAutoGrowSize;
704 }
705 else if ( bIsTextFrame )
706 {
707 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextAutoGrowWidth"_ustr, true ) )
708 aAny >>= bAutoGrowWidth;
709
710 // i63936 not setting autogrowheight, because otherwise
711 // the minframeheight of the text will be ignored
712 //
713 // if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, "TextAutoGrowHeight", sal_True ) )
714 // aAny >>= bAutoGrowHeight;
715 }
716 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextLeftDistance"_ustr ) )
717 aAny >>= nLeft;
718 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextUpperDistance"_ustr ) )
719 aAny >>= nTop;
720 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextRightDistance"_ustr ) )
721 aAny >>= nRight;
722 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"TextLowerDistance"_ustr ) )
723 aAny >>= nBottom;
724
725 ESCHER_AnchorText eAnchor = ESCHER_AnchorTop;
726 ESCHER_WrapMode eWrapMode = ESCHER_WrapSquare;
727 sal_uInt32 nTextAttr = 0x40004; // rotate text with shape
728
729 if ( eWM == text::WritingMode_TB_RL )
730 { // vertical writing
731 switch ( eHA )
732 {
733 case drawing::TextHorizontalAdjust_LEFT :
734 eAnchor = ESCHER_AnchorBottom;
735 break;
736 case drawing::TextHorizontalAdjust_CENTER :
737 eAnchor = ESCHER_AnchorMiddle;
738 break;
739 default :
740 case drawing::TextHorizontalAdjust_BLOCK :
741 case drawing::TextHorizontalAdjust_RIGHT :
742 eAnchor = ESCHER_AnchorTop;
743 break;
744 }
745 if ( eVA == drawing::TextVerticalAdjust_CENTER )
746 {
747 switch ( eAnchor )
748 {
749 case ESCHER_AnchorMiddle :
750 eAnchor = ESCHER_AnchorMiddleCentered;
751 break;
752 case ESCHER_AnchorBottom :
753 eAnchor = ESCHER_AnchorBottomCentered;
754 break;
755 default :
756 case ESCHER_AnchorTop :
757 eAnchor = ESCHER_AnchorTopCentered;
758 break;
759 }
760 }
761 if ( bIsCustomShape )
762 {
763 if ( bWordWrap )
764 eWrapMode = ESCHER_WrapSquare;
765 else
766 eWrapMode = ESCHER_WrapNone;
767 if ( bAutoGrowSize )
768 nTextAttr |= 0x20002;
769 }
770 else
771 {
772 if ( bAutoGrowHeight )
773 eWrapMode = ESCHER_WrapNone;
774 if ( bAutoGrowWidth )
775 nTextAttr |= 0x20002;
776 }
777
778 AddOpt( ESCHER_Prop_txflTextFlow, ESCHER_txflTtoBA ); // rotate text within shape by 90
779 }
780 else
781 { // normal from left to right
782 switch ( eVA )
783 {
784 case drawing::TextVerticalAdjust_CENTER :
785 eAnchor = ESCHER_AnchorMiddle;
786 break;
787
788 case drawing::TextVerticalAdjust_BOTTOM :
789 eAnchor = ESCHER_AnchorBottom;
790 break;
791
792 default :
793 case drawing::TextVerticalAdjust_TOP :
794 eAnchor = ESCHER_AnchorTop;
795 break;
796 }
797 if ( eHA == drawing::TextHorizontalAdjust_CENTER )
798 {
799 switch( eAnchor )
800 {
801 case ESCHER_AnchorMiddle :
802 eAnchor = ESCHER_AnchorMiddleCentered;
803 break;
804 case ESCHER_AnchorBottom :
805 eAnchor = ESCHER_AnchorBottomCentered;
806 break;
807 case ESCHER_AnchorTop :
808 eAnchor = ESCHER_AnchorTopCentered;
809 break;
810 default: break;
811 }
812 }
813 if ( bIsCustomShape )
814 {
815 if ( bWordWrap )
816 eWrapMode = ESCHER_WrapSquare;
817 else
818 eWrapMode = ESCHER_WrapNone;
819 if ( bAutoGrowSize )
820 nTextAttr |= 0x20002;
821 }
822 else
823 {
824 if ( bAutoGrowWidth )
825 eWrapMode = ESCHER_WrapNone;
826 if ( bAutoGrowHeight )
827 nTextAttr |= 0x20002;
828 }
829 }
830 AddOpt( ESCHER_Prop_dxTextLeft, nLeft * 360 );
831 AddOpt( ESCHER_Prop_dxTextRight, nRight * 360 );
832 AddOpt( ESCHER_Prop_dyTextTop, nTop * 360 );
833 AddOpt( ESCHER_Prop_dyTextBottom, nBottom * 360 );
834
835 AddOpt( ESCHER_Prop_WrapText, eWrapMode );
836 AddOpt( ESCHER_Prop_AnchorText, eAnchor );
837 AddOpt( ESCHER_Prop_FitTextToShape, nTextAttr );
838
839 if ( nTextId )
840 AddOpt( ESCHER_Prop_lTxid, nTextId );
841
842 // n#404221: In case of rotation we need to write the txtflTextFlow
843 // attribute too.
844 // fdo#58204: not custom shapes (TODO: other cases when it doesn't work?)
845 if (!bIsTextFrame || bIsCustomShape)
846 return;
847
848 sal_uInt16 nAngle = EscherPropertyValueHelper::GetPropertyValue(
849 aAny, rXPropSet, u"RotateAngle"_ustr, true ) ?
850 static_cast<sal_uInt16>( ( *o3tl::doAccess<sal_Int32>(aAny) ) + 5 ) / 10 : 0;
851 if (nAngle==900)
852 {
853 AddOpt( ESCHER_Prop_txflTextFlow, ESCHER_txflBtoT );
854 }
855 if (nAngle==2700)
856 {
857 AddOpt( ESCHER_Prop_txflTextFlow, ESCHER_txflTtoBA );
858 }
859 }
860
861 bool EscherPropertyContainer::GetLineArrow( const bool bLineStart,
862 const uno::Reference<beans::XPropertySet> & rXPropSet,
863 ESCHER_LineEnd& reLineEnd, sal_Int32& rnArrowLength, sal_Int32& rnArrowWidth )
864 {
865 const OUString sLine ( bLineStart ? u"LineStart"_ustr : u"LineEnd"_ustr );
866 const OUString sLineName ( bLineStart ? u"LineStartName"_ustr : u"LineEndName"_ustr );
867
868 bool bIsArrow = false;
869
870 uno::Any aAny;
871 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, sLine ) )
872 {
873 tools::PolyPolygon aPolyPoly( EscherPropertyContainer::GetPolyPolygon( aAny ) );
874 if ( aPolyPoly.Count() && aPolyPoly[ 0 ].GetSize() )
875 {
876 bIsArrow = true;
877
878 reLineEnd = ESCHER_LineArrowEnd;
879 rnArrowLength = 1;
880 rnArrowWidth = 1;
881
882 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, sLineName ) )
883 {
884 OUString aArrowStartName = *o3tl::doAccess<OUString>(aAny);
885 sal_uInt16 nWhich = bLineStart ? sal_uInt16(XATTR_LINESTART) : sal_uInt16(XATTR_LINEEND);
886
887 // remove extra space separated number
888 sal_Int32 nPos = aArrowStartName.lastIndexOf(' ');
889 if (nPos > -1 && aArrowStartName.lastIndexOf(' ', nPos) > -1)
890 aArrowStartName = aArrowStartName.copy(0, nPos);
891
892 OUString aApiName = SvxUnogetApiNameForItem(nWhich, aArrowStartName);
893 bool bIsMapped = true;
894 if ( !aApiName.isEmpty() )
895 {
896
897 // TODO: calculate the best option for ArrowLength and ArrowWidth
898 if ( aApiName == "Arrow concave" )
899 reLineEnd = ESCHER_LineArrowStealthEnd;
900 else if ( aApiName == "Square 45" )
901 reLineEnd = ESCHER_LineArrowDiamondEnd;
902 else if ( aApiName == "Small Arrow" )
903 reLineEnd = ESCHER_LineArrowEnd;
904 else if ( aApiName == "Dimension Lines" )
905 {
906 rnArrowLength = 0;
907 rnArrowWidth = 2;
908 reLineEnd = ESCHER_LineArrowOvalEnd;
909 }
910 else if ( aApiName == "Double Arrow" )
911 reLineEnd = ESCHER_LineArrowEnd;
912 else if ( aApiName == "Rounded short Arrow" )
913 reLineEnd = ESCHER_LineArrowEnd;
914 else if ( aApiName == "Symmetric Arrow" )
915 reLineEnd = ESCHER_LineArrowEnd;
916 else if ( aApiName == "Line Arrow" )
917 reLineEnd = ESCHER_LineArrowOpenEnd;
918 else if ( aApiName == "Rounded large Arrow" )
919 reLineEnd = ESCHER_LineArrowEnd;
920 else if ( aApiName == "Circle" )
921 reLineEnd = ESCHER_LineArrowOvalEnd;
922 else if ( aApiName == "Square" )
923 reLineEnd = ESCHER_LineArrowDiamondEnd;
924 else if ( aApiName == "Arrow" )
925 reLineEnd = ESCHER_LineArrowEnd;
926 else
927 bIsMapped = false;
928
929 }
930 if ( !bIsMapped && comphelper::string::getTokenCount(aArrowStartName, ' ') == 2 )
931 {
932 sal_Int32 nIdx{ 0 };
933 std::u16string_view aArrowName( o3tl::getToken(aArrowStartName, 0, ' ', nIdx ) );
934 if ( aArrowName == u"msArrowEnd" )
935 reLineEnd = ESCHER_LineArrowEnd;
936 else if ( aArrowName == u"msArrowOpenEnd" )
937 reLineEnd = ESCHER_LineArrowOpenEnd;
938 else if ( aArrowName == u"msArrowStealthEnd" )
939 reLineEnd = ESCHER_LineArrowStealthEnd;
940 else if ( aArrowName == u"msArrowDiamondEnd" )
941 reLineEnd = ESCHER_LineArrowDiamondEnd;
942 else if ( aArrowName == u"msArrowOvalEnd" )
943 reLineEnd = ESCHER_LineArrowOvalEnd;
944 else
945 nIdx = -1;
946
947 // now we have the arrow, and try to determine the arrow size;
948 if ( nIdx>0 )
949 {
950 std::u16string_view aArrowSize = o3tl::getToken(aArrowStartName, 0, ' ', nIdx );
951 sal_Int32 nArrowSize = o3tl::toInt32(aArrowSize);
952 rnArrowWidth = ( nArrowSize - 1 ) / 3;
953 rnArrowLength = nArrowSize - ( rnArrowWidth * 3 ) - 1;
954 }
955 }
956 }
957 }
958 }
959 return bIsArrow;
960 }
961
962 void EscherPropertyContainer::CreateLineProperties(
963 const uno::Reference<beans::XPropertySet> & rXPropSet, bool bEdge )
964 {
965 uno::Any aAny;
966 sal_uInt32 nLineFlags = 0x80008;
967
968 ESCHER_LineEnd eLineEnd;
969 sal_Int32 nArrowLength;
970 sal_Int32 nArrowWidth;
971
972 bool bSwapLineEnds = false;
973 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"CircleKind"_ustr, true ) )
974 {
975 drawing::CircleKind eCircleKind;
976 if ( aAny >>= eCircleKind )
977 {
978 if ( eCircleKind == drawing::CircleKind_ARC )
979 bSwapLineEnds = true;
980 }
981 }
982 if ( GetLineArrow( !bSwapLineEnds, rXPropSet, eLineEnd, nArrowLength, nArrowWidth ) )
983 {
984 AddOpt( ESCHER_Prop_lineStartArrowLength, nArrowLength );
985 AddOpt( ESCHER_Prop_lineStartArrowWidth, nArrowWidth );
986 AddOpt( ESCHER_Prop_lineStartArrowhead, eLineEnd );
987 nLineFlags |= 0x100010;
988 }
989 if ( GetLineArrow( bSwapLineEnds, rXPropSet, eLineEnd, nArrowLength, nArrowWidth ) )
990 {
991 AddOpt( ESCHER_Prop_lineEndArrowLength, nArrowLength );
992 AddOpt( ESCHER_Prop_lineEndArrowWidth, nArrowWidth );
993 AddOpt( ESCHER_Prop_lineEndArrowhead, eLineEnd );
994 nLineFlags |= 0x100010;
995 }
996
997 // support LineCaps
998 if(EscherPropertyValueHelper::GetPropertyValue(aAny, rXPropSet, u"LineCap"_ustr))
999 {
1000 drawing::LineCap aLineCap(drawing::LineCap_BUTT);
1001
1002 if(aAny >>= aLineCap)
1003 {
1004 switch (aLineCap)
1005 {
1006 default: /* drawing::LineCap_BUTT */
1007 {
1008 AddOpt(ESCHER_Prop_lineEndCapStyle, ESCHER_LineEndCapFlat);
1009 break;
1010 }
1011 case drawing::LineCap_ROUND:
1012 {
1013 AddOpt(ESCHER_Prop_lineEndCapStyle, ESCHER_LineEndCapRound);
1014 break;
1015 }
1016 case drawing::LineCap_SQUARE:
1017 {
1018 AddOpt(ESCHER_Prop_lineEndCapStyle, ESCHER_LineEndCapSquare);
1019 break;
1020 }
1021 }
1022 }
1023 }
1024
1025 sal_uInt32 nLineWidth = ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"LineWidth"_ustr ) )
1026 ? *o3tl::doAccess<sal_uInt32>(aAny) : 0;
1027 if ( nLineWidth > 1 )
1028 AddOpt( ESCHER_Prop_lineWidth, nLineWidth * 360 ); // 100TH MM -> PT , 1PT = 12700 EMU
1029
1030 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"LineStyle"_ustr ) )
1031 {
1032 drawing::LineStyle eLS;
1033 if ( aAny >>= eLS )
1034 {
1035 switch ( eLS )
1036 {
1037 case drawing::LineStyle_NONE :
1038 AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x90000 ); // 80000
1039 break;
1040
1041 case drawing::LineStyle_DASH :
1042 {
1043 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"LineDash"_ustr ) )
1044 {
1045 ESCHER_LineDashing eDash = ESCHER_LineSolid;
1046 auto pLineDash = o3tl::doAccess<drawing::LineDash>(aAny);
1047 switch ( pLineDash->Style )
1048 {
1049 case drawing::DashStyle_ROUND :
1050 case drawing::DashStyle_ROUNDRELATIVE :
1051 AddOpt( ESCHER_Prop_lineEndCapStyle, 0 ); // set Style Round
1052 break;
1053 default : break;
1054 }
1055 // Try to detect exact prstDash styles. Use a similar method as in oox export.
1056 // Map it to a roughly fitting prstDash in other cases.
1057 bool bIsConverted = false;
1058 bool bIsRelative = pLineDash->Style == drawing::DashStyle_RECTRELATIVE
1059 || pLineDash->Style == drawing::DashStyle_ROUNDRELATIVE;
1060 sal_Int16 nDashes = pLineDash->Dashes;
1061 sal_Int16 nDots = pLineDash->Dots;
1062 sal_Int32 nDashLen = pLineDash->DashLen;
1063 sal_Int32 nDotLen = pLineDash->DotLen;
1064 sal_Int32 nDistance = pLineDash->Distance;
1065
1066 // Caution! The names are misleading. "dot" is always the first dash and "dash"
1067 // the second one, regardless of the actual length. All prstDash
1068 // definitions start with the longer dash and have exact one longer dash.
1069 // Preset line style definitions for binary format are the same as for OOXML.
1070 if (bIsRelative && nDots == 1)
1071 {
1072 // I'm not sure that LO always uses 100%, because in case of absolute values, LO
1073 // sets length to 0 but treats it as 100%, if the attribute is missing in ODF.
1074 // So to be sure set 100% explicitly in case of relative too.
1075 if (nDashes > 0 && nDashLen == 0)
1076 nDashLen = 100;
1077 if (nDotLen == 0)
1078 nDotLen = 100;
1079 bIsConverted = true;
1080 if (nDotLen == 100 && nDashes == 0 && nDashLen == 0 && nDistance == 300)
1081 eDash = ESCHER_LineDotGEL;
1082 else if (nDotLen == 400 && nDashes == 0 && nDashLen == 0 && nDistance == 300)
1083 eDash = ESCHER_LineDashGEL;
1084 else if (nDotLen == 400 && nDashes == 1 && nDashLen == 100 && nDistance == 300)
1085 eDash = ESCHER_LineDashDotGEL;
1086 else if (nDotLen == 800 && nDashes == 0 && nDashLen == 0 && nDistance == 300)
1087 eDash = ESCHER_LineLongDashGEL;
1088 else if (nDotLen == 800 && nDashes == 1 && nDashLen == 100 && nDistance == 300)
1089 eDash = ESCHER_LineLongDashDotGEL;
1090 else if (nDotLen == 800 && nDashes == 2 && nDashLen == 100 && nDistance == 300)
1091 eDash = ESCHER_LineLongDashDotDotGEL;
1092 else if (nDotLen == 100 && nDashes == 0 && nDashLen == 0 && nDistance == 100)
1093 eDash = ESCHER_LineDotSys;
1094 else if (nDotLen == 300 && nDashes == 0 && nDashLen == 0 && nDistance == 100)
1095 eDash = ESCHER_LineDashSys;
1096 else if (nDotLen == 300 && nDashes == 1 && nDashLen == 100 && nDistance == 100)
1097 eDash = ESCHER_LineDashDotSys;
1098 else if (nDotLen == 300 && nDashes == 2 && nDashLen == 100 && nDistance == 100)
1099 eDash = ESCHER_LineDashDotDotSys;
1100 else
1101 bIsConverted = false;
1102 }
1103
1104 if (!bIsConverted)
1105 { // Map the style roughly to preset line styles.
1106 if (((!(pLineDash->Dots)) || (!(pLineDash->Dashes)))
1107 || (pLineDash->DotLen == pLineDash->DashLen))
1108 {
1109 sal_Int32 nLen = pLineDash->DotLen;
1110 if (pLineDash->Dashes)
1111 nLen = pLineDash->DashLen;
1112 if (nLen >= nDistance)
1113 eDash = ESCHER_LineLongDashGEL;
1114 else if (pLineDash->Dots)
1115 eDash = ESCHER_LineDotSys;
1116 else
1117 eDash = ESCHER_LineDashGEL;
1118 }
1119 else // X Y
1120 {
1121 if (pLineDash->Dots != pLineDash->Dashes)
1122 {
1123 if ((pLineDash->DashLen > nDistance) || (pLineDash->DotLen > nDistance))
1124 eDash = ESCHER_LineLongDashDotDotGEL;
1125 else
1126 eDash = ESCHER_LineDashDotDotSys;
1127 }
1128 else // X Y Y
1129 {
1130 if ((pLineDash->DashLen > nDistance) || (pLineDash->DotLen > nDistance))
1131 eDash = ESCHER_LineLongDashDotGEL;
1132 else
1133 eDash = ESCHER_LineDashDotGEL;
1134 }
1135 }
1136 }
1137 AddOpt( ESCHER_Prop_lineDashing, eDash );
1138 }
1139 }
1140 [[fallthrough]];
1141 case drawing::LineStyle_SOLID :
1142 default:
1143 {
1144 AddOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags );
1145 }
1146 break;
1147 }
1148 }
1149 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"LineColor"_ustr ) )
1150 {
1151 sal_uInt32 nLineColor = ImplGetColor( *o3tl::doAccess<sal_uInt32>(aAny) );
1152 AddOpt( ESCHER_Prop_lineColor, nLineColor );
1153 AddOpt( ESCHER_Prop_lineBackColor, nLineColor ^ 0xffffff );
1154 }
1155 }
1156
1157 ESCHER_LineJoin eLineJoin = ESCHER_LineJoinMiter;
1158 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"LineJoint"_ustr, true ) )
1159 {
1160 drawing::LineJoint eLJ;
1161 if ( aAny >>= eLJ )
1162 {
1163 switch ( eLJ )
1164 {
1165 case drawing::LineJoint_NONE :
1166 case drawing::LineJoint_BEVEL :
1167 eLineJoin = ESCHER_LineJoinBevel;
1168 break;
1169 default:
1170 case drawing::LineJoint_MIDDLE :
1171 case drawing::LineJoint_MITER :
1172 eLineJoin = ESCHER_LineJoinMiter;
1173 break;
1174 case drawing::LineJoint_ROUND :
1175 eLineJoin = ESCHER_LineJoinRound;
1176 break;
1177 }
1178 }
1179 }
1180 AddOpt( ESCHER_Prop_lineJoinStyle, eLineJoin );
1181
1182 if ( EscherPropertyValueHelper::GetPropertyValue(
1183 aAny, rXPropSet, u"LineTransparence"_ustr, true ) )
1184 {
1185 sal_Int16 nTransparency = 0;
1186 if ( aAny >>= nTransparency )
1187 AddOpt( ESCHER_Prop_lineOpacity, ( ( 100 - nTransparency ) << 16 ) / 100 );
1188 }
1189
1190
1191 if ( !bEdge )
1192 {
1193 AddOpt( ESCHER_Prop_fFillOK, 0x1001 );
1194 AddOpt( ESCHER_Prop_fNoFillHitTest, 0x100000 );
1195 }
1196 }
1197
1198 static Size lcl_SizeToEmu(Size aPrefSize, const MapMode& aPrefMapMode)
1199 {
1200 Size aRetSize;
1201 if (aPrefMapMode.GetMapUnit() == MapUnit::MapPixel)
1202 aRetSize = Application::GetDefaultDevice()->PixelToLogic(aPrefSize, MapMode(MapUnit::Map100thMM));
1203 else
1204 aRetSize = OutputDevice::LogicToLogic(aPrefSize, aPrefMapMode, MapMode(MapUnit::Map100thMM));
1205 return aRetSize;
1206 }
1207
1208 void EscherPropertyContainer::ImplCreateGraphicAttributes( const uno::Reference<beans::XPropertySet> & rXPropSet,
1209 sal_uInt32 nBlibId, bool bCreateCroppingAttributes )
1210 {
1211 uno::Any aAny;
1212
1213 sal_uInt32 nPicFlags = 0;
1214 drawing::ColorMode eColorMode( drawing::ColorMode_STANDARD );
1215 sal_Int16 nLuminance = 0;
1216 sal_Int32 nContrast = 0;
1217
1218 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"GraphicColorMode"_ustr ) )
1219 aAny >>= eColorMode;
1220 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"AdjustLuminance"_ustr ) )
1221 aAny >>= nLuminance;
1222 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"AdjustContrast"_ustr ) )
1223 {
1224 sal_Int16 nC = sal_Int16();
1225 aAny >>= nC;
1226 nContrast = nC;
1227 }
1228
1229 if ( eColorMode == drawing::ColorMode_WATERMARK )
1230 {
1231 eColorMode = drawing::ColorMode_STANDARD;
1232 nLuminance += 70;
1233 if ( nLuminance > 100 )
1234 nLuminance = 100;
1235 nContrast -= 70;
1236 if ( nContrast < -100 )
1237 nContrast = -100;
1238 }
1239 if ( eColorMode == drawing::ColorMode_GREYS )
1240 nPicFlags |= 0x40004;
1241 else if ( eColorMode == drawing::ColorMode_MONO )
1242 nPicFlags |= 0x60006;
1243
1244 if ( nContrast )
1245 {
1246 nContrast += 100;
1247 if ( nContrast == 100)
1248 nContrast = 0x10000;
1249 else if ( nContrast < 100 )
1250 {
1251 nContrast *= 0x10000;
1252 nContrast /= 100;
1253 }
1254 else if ( nContrast < 200 )
1255 nContrast = ( 100 * 0x10000 ) / ( 200 - nContrast );
1256 else
1257 nContrast = 0x7fffffff;
1258 AddOpt( ESCHER_Prop_pictureContrast, nContrast );
1259 }
1260 if ( nLuminance )
1261 AddOpt( ESCHER_Prop_pictureBrightness, nLuminance * 327 );
1262 if ( nPicFlags )
1263 AddOpt( ESCHER_Prop_pictureActive, nPicFlags );
1264
1265 if ( !(bCreateCroppingAttributes && pGraphicProvider) )
1266 return;
1267
1268 Size aPrefSize;
1269 MapMode aPrefMapMode;
1270 if ( !pGraphicProvider->GetPrefSize( nBlibId, aPrefSize, aPrefMapMode ) )
1271 return;
1272
1273 Size aCropSize(lcl_SizeToEmu(aPrefSize, aPrefMapMode));
1274 if ( !(aCropSize.Width() && aCropSize.Height()) )
1275 return;
1276
1277 if ( !EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"GraphicCrop"_ustr ) )
1278 return;
1279
1280 text::GraphicCrop aGraphCrop;
1281 if ( !(aAny >>= aGraphCrop) )
1282 return;
1283
1284 if ( aGraphCrop.Left )
1285 {
1286 sal_uInt32 nLeft = ( aGraphCrop.Left * 65536 ) / aCropSize.Width();
1287 AddOpt( ESCHER_Prop_cropFromLeft, nLeft );
1288 }
1289 if ( aGraphCrop.Top )
1290 {
1291 sal_uInt32 nTop = ( aGraphCrop.Top * 65536 ) / aCropSize.Height();
1292 AddOpt( ESCHER_Prop_cropFromTop, nTop );
1293 }
1294 if ( aGraphCrop.Right )
1295 {
1296 sal_uInt32 nRight = ( aGraphCrop.Right * 65536 ) / aCropSize.Width();
1297 AddOpt( ESCHER_Prop_cropFromRight, nRight );
1298 }
1299 if ( aGraphCrop.Bottom )
1300 {
1301 sal_uInt32 nBottom = ( aGraphCrop.Bottom * 65536 ) / aCropSize.Height();
1302 AddOpt( ESCHER_Prop_cropFromBottom, nBottom );
1303 }
1304 }
1305
1306 void EscherPropertyContainer::CreateShapeProperties( const uno::Reference<drawing::XShape> & rXShape )
1307 {
1308 uno::Reference< beans::XPropertySet > aXPropSet( rXShape, uno::UNO_QUERY );
1309 if ( !aXPropSet.is() )
1310 return;
1311
1312 bool bVisible = false;
1313 bool bPrintable = false;
1314 uno::Any aAny;
1315 sal_uInt32 nShapeAttr = 0;
1316 if (EscherPropertyValueHelper::GetPropertyValue(aAny, aXPropSet, u"Visible"_ustr, true) && (aAny >>= bVisible))
1317 {
1318 if ( !bVisible )
1319 nShapeAttr |= 0x20002; // set fHidden = true
1320 }
1321 // This property (fPrint) isn't used in Excel anymore, leaving it for legacy reasons
1322 // one change, based on XLSX: hidden implies not printed, let's not export the fPrint property in that case
1323 if (bVisible && EscherPropertyValueHelper::GetPropertyValue(aAny, aXPropSet, u"Printable"_ustr, true) && (aAny >>= bPrintable))
1324 {
1325 if ( !bPrintable )
1326 nShapeAttr |= 0x10000; // set fPrint = false;
1327 }
1328 if ( nShapeAttr )
1329 AddOpt( ESCHER_Prop_fPrint, nShapeAttr );
1330 }
1331
1332 bool EscherPropertyContainer::CreateOLEGraphicProperties(const uno::Reference<drawing::XShape> & rXShape)
1333 {
1334 bool bRetValue = false;
1335
1336 if ( rXShape.is() )
1337 {
1338 SdrObject* pObject = SdrObject::getSdrObjectFromXShape(rXShape); // SJ: leaving unoapi, because currently there is
1339 if (auto pOle2Obj = dynamic_cast<const SdrOle2Obj*>(pObject)) // no access to the native graphic object
1340 {
1341 const Graphic* pGraphic = pOle2Obj->GetGraphic();
1342 if (pGraphic)
1343 {
1344 GraphicObject aGraphicObject(*pGraphic);
1345 bRetValue = CreateGraphicProperties(rXShape, aGraphicObject);
1346 }
1347 }
1348 }
1349 return bRetValue;
1350 }
1351
1352 bool EscherPropertyContainer::CreateGraphicProperties(const uno::Reference<drawing::XShape> & rXShape, const GraphicObject& rGraphicObj)
1353 {
1354 bool bRetValue = false;
1355 OString aUniqueId(rGraphicObj.GetUniqueID());
1356 if ( !aUniqueId.isEmpty() )
1357 {
1358 AddOpt( ESCHER_Prop_fillType, ESCHER_FillPicture );
1359 uno::Reference< beans::XPropertySet > aXPropSet( rXShape, uno::UNO_QUERY );
1360
1361 if ( pGraphicProvider && pPicOutStrm && pShapeBoundRect && aXPropSet.is() )
1362 {
1363 uno::Any aAny;
1364 std::unique_ptr<awt::Rectangle> pVisArea;
1365 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"VisibleArea"_ustr ) )
1366 {
1367 pVisArea.reset(new awt::Rectangle);
1368 aAny >>= *pVisArea;
1369 }
1370 sal_uInt32 nBlibId = pGraphicProvider->GetBlibID( *pPicOutStrm, rGraphicObj, pVisArea.get() );
1371 if ( nBlibId )
1372 {
1373 AddOpt( ESCHER_Prop_pib, nBlibId, true );
1374 ImplCreateGraphicAttributes( aXPropSet, nBlibId, false );
1375 bRetValue = true;
1376 }
1377 }
1378 }
1379 return bRetValue;
1380 }
1381
1382 bool EscherPropertyContainer::CreateMediaGraphicProperties(const uno::Reference<drawing::XShape> & rXShape)
1383 {
1384 bool bRetValue = false;
1385 if ( rXShape.is() )
1386 {
1387 SdrObject* pSdrObject(SdrObject::getSdrObjectFromXShape(rXShape)); // SJ: leaving unoapi, because currently there is
1388 if (auto pSdrMediaObj = dynamic_cast<const SdrMediaObj*>(pSdrObject)) // no access to the native graphic object
1389 {
1390 GraphicObject aGraphicObject(pSdrMediaObj->getSnapshot());
1391 bRetValue = CreateGraphicProperties(rXShape, aGraphicObject);
1392 }
1393 }
1394 return bRetValue;
1395 }
1396
1397 bool EscherPropertyContainer::ImplCreateEmbeddedBmp(GraphicObject const & rGraphicObject)
1398 {
1399 if (rGraphicObject.GetType() != GraphicType::NONE)
1400 {
1401 EscherGraphicProvider aProvider;
1402 SvMemoryStream aMemStrm;
1403
1404 if (aProvider.GetBlibID( aMemStrm, rGraphicObject))
1405 {
1406 AddOpt(ESCHER_Prop_fillBlip, true, 0, aMemStrm);
1407 return true;
1408 }
1409 }
1410 return false;
1411 }
1412
1413 void EscherPropertyContainer::CreateEmbeddedBitmapProperties(
1414 uno::Reference<awt::XBitmap> const & rxBitmap, drawing::BitmapMode eBitmapMode )
1415 {
1416 uno::Reference<graphic::XGraphic> xGraphic(rxBitmap, uno::UNO_QUERY);
1417 if (!xGraphic.is())
1418 return;
1419 Graphic aGraphic(xGraphic);
1420 if (aGraphic.IsNone())
1421 return;
1422 GraphicObject aGraphicObject(std::move(aGraphic));
1423 if (aGraphicObject.GetType() == GraphicType::NONE)
1424 return;
1425 if (ImplCreateEmbeddedBmp(aGraphicObject))
1426 {
1427 // bitmap mode property
1428 bool bRepeat = eBitmapMode == drawing::BitmapMode_REPEAT;
1429 AddOpt( ESCHER_Prop_fillType, bRepeat ? ESCHER_FillTexture : ESCHER_FillPicture );
1430 }
1431 }
1432
1433 namespace {
1434
1435 Graphic lclDrawHatch( const drawing::Hatch& rHatch, const Color& rBackColor, bool bFillBackground, const tools::Rectangle& rRect )
1436 {
1437 // #i121183# For hatch, do no longer create a bitmap with the fixed size of 28x28 pixels. Also
1438 // do not create a bitmap in page size, that would explode file sizes (and have no good quality).
1439 // Better use a MetaFile graphic in page size; thus we have good quality due to vector format and
1440 // no bit file sizes.
1441 ScopedVclPtrInstance< VirtualDevice > pVDev;
1442 GDIMetaFile aMtf;
1443
1444 pVDev->SetOutputSizePixel(Size(2, 2));
1445 pVDev->EnableOutput(false);
1446 pVDev->SetMapMode(MapMode(MapUnit::Map100thMM));
1447 aMtf.Clear();
1448 aMtf.Record(pVDev);
1449 pVDev->SetLineColor();
1450 pVDev->SetFillColor(bFillBackground ? rBackColor : COL_TRANSPARENT);
1451 pVDev->DrawRect(rRect);
1452 pVDev->DrawHatch(tools::PolyPolygon(rRect), Hatch(static_cast<HatchStyle>(rHatch.Style), Color(ColorTransparency, rHatch.Color), rHatch.Distance,
1453 Degree10(rHatch.Angle)));
1454 aMtf.Stop();
1455 aMtf.WindStart();
1456 aMtf.SetPrefMapMode(MapMode(MapUnit::Map100thMM));
1457 aMtf.SetPrefSize(rRect.GetSize());
1458
1459 return Graphic(aMtf);
1460 }
1461
1462 } // namespace
1463
1464 void EscherPropertyContainer::CreateEmbeddedHatchProperties(const drawing::Hatch& rHatch, const Color& rBackColor, bool bFillBackground )
1465 {
1466 const tools::Rectangle aRect(pShapeBoundRect ? *pShapeBoundRect : tools::Rectangle(Point(0,0), Size(28000, 21000)));
1467 Graphic aGraphic(lclDrawHatch(rHatch, rBackColor, bFillBackground, aRect));
1468 GraphicObject aGraphicObject(std::move(aGraphic));
1469
1470 if (ImplCreateEmbeddedBmp(aGraphicObject))
1471 AddOpt( ESCHER_Prop_fillType, ESCHER_FillTexture );
1472 }
1473
1474 bool EscherPropertyContainer::CreateGraphicProperties(const uno::Reference<beans::XPropertySet> & rXPropSet,
1475 const OUString& rSource,
1476 const bool bCreateFillBitmap,
1477 const bool bCreateCroppingAttributes,
1478 const bool bFillBitmapModeAllowed,
1479 const bool bOOxmlExport )
1480 {
1481 bool bRetValue = false;
1482 bool bCreateFillStyles = false;
1483
1484 std::unique_ptr<GraphicAttr> pGraphicAttr;
1485 uno::Reference<graphic::XGraphic> xGraphic;
1486
1487 uno::Any aAny;
1488
1489 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, rSource ) )
1490 {
1491 bool bMirrored = false;
1492 bool bRotate = true;
1493 bool bIsGraphicMtf = false;
1494 sal_Int16 nTransparency(0);
1495 sal_Int16 nRed(0);
1496 sal_Int16 nGreen(0);
1497 sal_Int16 nBlue(0);
1498 double fGamma(1.0);
1499 drawing::BitmapMode eBitmapMode(drawing::BitmapMode_NO_REPEAT);
1500 OUString aGraphicUrl;
1501
1502 sal_uInt16 nAngle = 0;
1503 if ( rSource == "MetaFile" )
1504 {
1505 auto & aSeq = *o3tl::doAccess<uno::Sequence<sal_Int8>>(aAny);
1506 const sal_Int8* pArray = aSeq.getConstArray();
1507 sal_uInt32 nArrayLength = aSeq.getLength();
1508
1509 // the metafile is already rotated
1510 bRotate = false;
1511
1512 if (pArray && nArrayLength)
1513 {
1514 Graphic aGraphic;
1515 SvMemoryStream aStream(const_cast<sal_Int8 *>(pArray), nArrayLength, StreamMode::READ);
1516 ErrCode nErrCode = GraphicConverter::Import(aStream, aGraphic, ConvertDataFormat::WMF);
1517 if ( nErrCode == ERRCODE_NONE )
1518 {
1519 xGraphic = aGraphic.GetXGraphic();
1520 bIsGraphicMtf = aGraphic.GetType() == GraphicType::GdiMetafile;
1521 }
1522 }
1523 }
1524 else if (rSource == "Bitmap" || rSource == "FillBitmap")
1525 {
1526 auto xBitmap = aAny.get<uno::Reference<awt::XBitmap>>();
1527 if (xBitmap.is())
1528 {
1529 xGraphic.set(xBitmap, uno::UNO_QUERY);
1530 Graphic aGraphic(xGraphic);
1531 bIsGraphicMtf = aGraphic.GetType() == GraphicType::GdiMetafile;
1532 }
1533 }
1534 else if ( rSource == "Graphic" )
1535 {
1536 xGraphic = aAny.get<uno::Reference<graphic::XGraphic>>();
1537 bCreateFillStyles = true;
1538 }
1539 else if ( rSource == "FillHatch" )
1540 {
1541 drawing::Hatch aHatch;
1542 if ( aAny >>= aHatch )
1543 {
1544 Color aBackColor;
1545 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"FillColor"_ustr ) )
1546 {
1547 aBackColor = Color(ColorTransparency, ImplGetColor( *o3tl::doAccess<sal_uInt32>(aAny), false ));
1548 }
1549 bool bFillBackground = false;
1550 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"FillBackground"_ustr, true ) )
1551 {
1552 aAny >>= bFillBackground;
1553 }
1554
1555 const tools::Rectangle aRect(Point(0, 0), pShapeBoundRect ? pShapeBoundRect->GetSize() : Size(28000, 21000));
1556 Graphic aGraphic(lclDrawHatch(aHatch, aBackColor, bFillBackground, aRect));
1557 xGraphic = aGraphic.GetXGraphic();
1558 eBitmapMode = drawing::BitmapMode_REPEAT;
1559 bIsGraphicMtf = aGraphic.GetType() == GraphicType::GdiMetafile;
1560 }
1561 }
1562
1563 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"IsMirrored"_ustr, true ) )
1564 aAny >>= bMirrored;
1565
1566 // #121074# transparency of graphic is not supported in MS formats, get and apply it
1567 // in the GetTransformedGraphic call in GetBlibID
1568 if(EscherPropertyValueHelper::GetPropertyValue(aAny, rXPropSet, u"Transparency"_ustr))
1569 {
1570 aAny >>= nTransparency;
1571 }
1572
1573 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"AdjustRed"_ustr ) )
1574 {
1575 aAny >>= nRed;
1576 }
1577
1578 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"AdjustGreen"_ustr ) )
1579 {
1580 aAny >>= nGreen;
1581 }
1582
1583 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"AdjustBlue"_ustr ) )
1584 {
1585 aAny >>= nBlue;
1586 }
1587
1588 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"Gamma"_ustr ) )
1589 {
1590 aAny >>= fGamma;
1591 }
1592
1593 if ( bCreateFillBitmap && bFillBitmapModeAllowed )
1594 {
1595 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"FillBitmapMode"_ustr, true ) )
1596 aAny >>= eBitmapMode;
1597 }
1598 else
1599 {
1600 nAngle = bRotate && EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"RotateAngle"_ustr, true )
1601 ? static_cast<sal_uInt16>( ( *o3tl::doAccess<sal_Int32>(aAny) ) + 5 ) / 10
1602 : 0;
1603 }
1604
1605 if (xGraphic.is())
1606 {
1607 Graphic aGraphic(xGraphic);
1608 aGraphicUrl = aGraphic.getOriginURL();
1609 }
1610
1611 if (!aGraphicUrl.isEmpty())
1612 {
1613 bool bConverted = false;
1614
1615 // externally, linked graphic? convert to embedded
1616 // one, if transformations are needed. this is because
1617 // everything < msoxp cannot even handle rotated
1618 // bitmaps.
1619 // And check whether the graphic link target is
1620 // actually supported by mso.
1621 INetURLObject aTmp( aGraphicUrl );
1622 GraphicDescriptor aDescriptor(aTmp);
1623 (void)aDescriptor.Detect();
1624 const GraphicFileFormat nFormat = aDescriptor.GetFileFormat();
1625
1626 // can MSO handle it?
1627 if ( bMirrored || nAngle || nTransparency || nRed || nGreen || nBlue || (1.0 != fGamma) ||
1628 (nFormat != GraphicFileFormat::BMP &&
1629 nFormat != GraphicFileFormat::GIF &&
1630 nFormat != GraphicFileFormat::JPG &&
1631 nFormat != GraphicFileFormat::PNG &&
1632 nFormat != GraphicFileFormat::TIF &&
1633 nFormat != GraphicFileFormat::PCT &&
1634 nFormat != GraphicFileFormat::WMF &&
1635 nFormat != GraphicFileFormat::WMZ &&
1636 nFormat != GraphicFileFormat::EMF &&
1637 nFormat != GraphicFileFormat::EMZ) )
1638 {
1639 std::unique_ptr<SvStream> pIn(::utl::UcbStreamHelper::CreateStream(
1640 aTmp.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::READ ));
1641 if ( pIn )
1642 {
1643 Graphic aGraphic;
1644 ErrCode nErrCode = GraphicConverter::Import( *pIn, aGraphic );
1645
1646 if ( nErrCode == ERRCODE_NONE )
1647 {
1648 xGraphic = aGraphic.GetXGraphic();
1649 bConverted = true;
1650 }
1651 // else: simply keep the graphic link
1652 }
1653 }
1654
1655 if (!bConverted && pGraphicProvider )
1656 {
1657 const OUString& rBaseURI( pGraphicProvider->GetBaseURI() );
1658 INetURLObject aBaseURI( rBaseURI );
1659 if( aBaseURI.GetProtocol() == aTmp.GetProtocol() )
1660 {
1661 OUString aRelUrl( INetURLObject::GetRelURL( rBaseURI, aGraphicUrl ) );
1662 if ( !aRelUrl.isEmpty() )
1663 aGraphicUrl = aRelUrl;
1664 }
1665 }
1666 }
1667
1668 if (!aGraphicUrl.isEmpty() || xGraphic.is())
1669 {
1670 if(bMirrored || nTransparency || nRed || nGreen || nBlue || (1.0 != fGamma))
1671 {
1672 pGraphicAttr.reset(new GraphicAttr);
1673
1674 if(bMirrored)
1675 {
1676 pGraphicAttr->SetMirrorFlags(BmpMirrorFlags::Horizontal);
1677 }
1678
1679 if(nTransparency)
1680 {
1681 pGraphicAttr->SetAlpha(255 - (nTransparency * 255) / 100);
1682 }
1683
1684 if(nRed)
1685 {
1686 pGraphicAttr->SetChannelR(nRed);
1687 }
1688
1689 if(nGreen)
1690 {
1691 pGraphicAttr->SetChannelG(nGreen);
1692 }
1693
1694 if(nBlue)
1695 {
1696 pGraphicAttr->SetChannelB(nBlue);
1697 }
1698
1699 if(1.0 != fGamma)
1700 {
1701 pGraphicAttr->SetGamma(fGamma);
1702 }
1703 }
1704
1705 if(nAngle && bIsGraphicMtf)
1706 {
1707 AddOpt( ESCHER_Prop_Rotation, ( ( (static_cast<sal_Int32>(nAngle) << 16 ) / 10 ) + 0x8000 ) &~ 0xffff );
1708 }
1709
1710 if ( eBitmapMode == drawing::BitmapMode_REPEAT )
1711 {
1712 sal_Int32 nSizeX = 0,nSizeY = 0,nOffsetX = 0,nOffsetY = 0,nPosOffsetX = 0,nPosOffsetY = 0;
1713 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"FillBitmapSizeX"_ustr, true ) )
1714 {
1715 aAny >>= nSizeX;
1716 }
1717 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"FillBitmapSizeY"_ustr, true ) )
1718 {
1719 aAny >>= nSizeY;
1720 }
1721 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"FillBitmapOffsetX"_ustr, true ) )
1722 {
1723 aAny >>= nOffsetX;
1724 }
1725 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"FillBitmapOffsetY"_ustr, true ) )
1726 {
1727 aAny >>= nOffsetY;
1728 }
1729 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"FillBitmapPositionOffsetX"_ustr, true ) )
1730 {
1731 aAny >>= nPosOffsetX;
1732 }
1733 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"FillBitmapPositionOffsetY"_ustr, true ) )
1734 {
1735 aAny >>= nPosOffsetY;
1736 }
1737 if(nSizeX == -100 && nSizeY == -100 && nOffsetX == 0 && nOffsetY == 0 && nPosOffsetX == 0 && nPosOffsetY == 0)
1738 AddOpt( ESCHER_Prop_fillType, ESCHER_FillPicture );
1739 else
1740 AddOpt( ESCHER_Prop_fillType, ESCHER_FillTexture );
1741 }
1742 else
1743 AddOpt( ESCHER_Prop_fillType, ESCHER_FillPicture );
1744
1745 if (xGraphic.is())
1746 {
1747 Graphic aGraphic(xGraphic);
1748 if (!aGraphic.getOriginURL().isEmpty())
1749 {
1750 AddOpt(ESCHER_Prop_pibName, aGraphicUrl);
1751 sal_uInt32 nPibFlags = 0;
1752 GetOpt(ESCHER_Prop_pibFlags, nPibFlags);
1753 AddOpt(ESCHER_Prop_pibFlags, ESCHER_BlipFlagLinkToFile | ESCHER_BlipFlagFile | ESCHER_BlipFlagDoNotSave | nPibFlags);
1754 }
1755 else if (pGraphicProvider && pPicOutStrm && pShapeBoundRect) // write out embedded graphic
1756 {
1757 GraphicObject aGraphicObject(std::move(aGraphic));
1758 const sal_uInt32 nBlibId(pGraphicProvider->GetBlibID(*pPicOutStrm, aGraphicObject, nullptr, pGraphicAttr.get()));
1759
1760 if(nBlibId)
1761 {
1762 if(bCreateFillBitmap)
1763 {
1764 AddOpt(ESCHER_Prop_fillBlip, nBlibId, true);
1765 }
1766 else
1767 {
1768 AddOpt( ESCHER_Prop_pib, nBlibId, true );
1769 ImplCreateGraphicAttributes( rXPropSet, nBlibId, bCreateCroppingAttributes );
1770 }
1771
1772 bRetValue = true;
1773 }
1774 }
1775 else
1776 {
1777 EscherGraphicProvider aProvider;
1778 SvMemoryStream aMemStrm;
1779 GraphicObject aGraphicObject(std::move(aGraphic));
1780
1781 if (aProvider.GetBlibID(aMemStrm, aGraphicObject, nullptr, pGraphicAttr.get(), bOOxmlExport))
1782 {
1783 AddOpt(ESCHER_Prop_fillBlip, true, 0, aMemStrm);
1784 bRetValue = true;
1785 }
1786 }
1787 }
1788 }
1789 }
1790 pGraphicAttr.reset();
1791 if ( bCreateFillStyles )
1792 CreateFillProperties( rXPropSet, true );
1793
1794 return bRetValue;
1795 }
1796
1797 tools::PolyPolygon EscherPropertyContainer::GetPolyPolygon( const uno::Reference< drawing::XShape > & rXShape )
1798 {
1799 tools::PolyPolygon aRetPolyPoly;
1800 uno::Reference< beans::XPropertySet > aXPropSet;
1801 uno::Any aAny( rXShape->queryInterface(
1802 cppu::UnoType<beans::XPropertySet>::get()));
1803
1804 if ( aAny >>= aXPropSet )
1805 {
1806 bool bHasProperty = EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"PolyPolygonBezier"_ustr, true );
1807 if ( !bHasProperty )
1808 bHasProperty = EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"PolyPolygon"_ustr, true );
1809 if ( !bHasProperty )
1810 bHasProperty = EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"Polygon"_ustr, true );
1811 if ( bHasProperty )
1812 aRetPolyPoly = GetPolyPolygon( aAny );
1813 }
1814 return aRetPolyPoly;
1815 }
1816
1817 // adapting to basegfx::B2DPolyPolygon now, has no sense to do corrections in the
1818 // old tools::PolyPolygon creation code. Convert to that at return time
1819 tools::PolyPolygon EscherPropertyContainer::GetPolyPolygon( const uno::Any& rAny )
1820 {
1821 basegfx::B2DPolyPolygon aRetval;
1822
1823 if(auto pBCC = o3tl::tryAccess<drawing::PolyPolygonBezierCoords>(rAny))
1824 {
1825 aRetval = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(*pBCC);
1826 }
1827 else if(auto pCC = o3tl::tryAccess<drawing::PointSequenceSequence>(rAny))
1828 {
1829 aRetval = basegfx::utils::UnoPointSequenceSequenceToB2DPolyPolygon(*pCC);
1830 }
1831 else if(auto pC = o3tl::tryAccess<drawing::PointSequence>(rAny))
1832 {
1833 aRetval.append(basegfx::utils::UnoPointSequenceToB2DPolygon(*pC));
1834 }
1835
1836 basegfx::B2DPolyPolygon aRetval2;
1837
1838 for(sal_uInt32 a(0); a < aRetval.count(); a++)
1839 {
1840 if(0 != aRetval.getB2DPolygon(a).count())
1841 {
1842 aRetval2.append(aRetval.getB2DPolygon(a));
1843 }
1844 }
1845
1846 return tools::PolyPolygon(aRetval2);
1847 }
1848
1849 bool EscherPropertyContainer::CreatePolygonProperties(
1850 const uno::Reference<beans::XPropertySet> & rXPropSet,
1851 sal_uInt32 nFlags,
1852 bool bBezier,
1853 awt::Rectangle& rGeoRect,
1854 tools::Polygon const * pPolygon )
1855 {
1856 tools::PolyPolygon aPolyPolygon;
1857
1858 if(nullptr != pPolygon)
1859 {
1860 aPolyPolygon.Insert(*pPolygon);
1861 }
1862 else
1863 {
1864 uno::Any aAny;
1865
1866 if(EscherPropertyValueHelper::GetPropertyValue(
1867 aAny,
1868 rXPropSet,
1869 bBezier ? u"PolyPolygonBezier"_ustr : u"PolyPolygon"_ustr,
1870 true))
1871 {
1872 aPolyPolygon = GetPolyPolygon(aAny);
1873 }
1874 else
1875 {
1876 return false;
1877 }
1878 }
1879
1880 if(0 == aPolyPolygon.Count())
1881 {
1882 return false;
1883 }
1884
1885 if(0 != (nFlags & ESCHER_CREATEPOLYGON_LINE))
1886 {
1887 if((1 == aPolyPolygon.Count()) && (2 == aPolyPolygon[0].GetSize()))
1888 {
1889 const tools::Polygon& rPoly(aPolyPolygon[0]);
1890
1891 rGeoRect = awt::Rectangle(
1892 rPoly[0].X(),
1893 rPoly[0].Y(),
1894 rPoly[1].X() - rPoly[0].X(),
1895 rPoly[1].Y() - rPoly[0].Y());
1896
1897 return true;
1898 }
1899
1900 return false;
1901 }
1902
1903 const tools::Rectangle aRect(aPolyPolygon.GetBoundRect());
1904
1905 rGeoRect = awt::Rectangle(
1906 aRect.Left(),
1907 aRect.Top(),
1908 aRect.GetWidth(),
1909 aRect.GetHeight());
1910
1911 const sal_uInt16 nPolyCount(aPolyPolygon.Count());
1912 sal_uInt32 nTotalPoints(0);
1913
1914 std::vector< sal_uInt8 > aVertices
1915 {
1916 0, 0, 0, 0,
1917 static_cast<sal_uInt8>(0xf0),
1918 static_cast<sal_uInt8>(0xff)
1919 };
1920
1921 std::vector< sal_uInt8 > aSegments
1922 {
1923 0, 0, 0, 0,
1924 static_cast<sal_uInt8>(2),
1925 static_cast<sal_uInt8>(0)
1926 };
1927
1928 for(sal_uInt16 j(0); j < nPolyCount; ++j)
1929 {
1930 const tools::Polygon& aPolygon(aPolyPolygon[j]);
1931 const sal_uInt16 nPoints(aPolygon.GetSize());
1932
1933 if(0 == nPoints)
1934 {
1935 continue;
1936 }
1937
1938 // Polygon start
1939 aSegments.push_back(static_cast<sal_uInt8>(0x0));
1940 aSegments.push_back(static_cast<sal_uInt8>(0x40));
1941
1942 sal_uInt16 nSegmentIgnoreCounter(0);
1943
1944 // write points from polygon to buffer
1945 for(sal_uInt16 i(0); i < nPoints; ++i)
1946 {
1947 Point aPoint(aPolygon[i]);
1948
1949 aPoint.AdjustX(-(rGeoRect.X));
1950 aPoint.AdjustY(-(rGeoRect.Y));
1951
1952 aVertices.push_back(static_cast<sal_uInt8>(aPoint.X()));
1953 aVertices.push_back(static_cast<sal_uInt8>(aPoint.X() >> 8));
1954 aVertices.push_back(static_cast<sal_uInt8>(aPoint.Y()));
1955 aVertices.push_back(static_cast<sal_uInt8>(aPoint.Y() >> 8));
1956
1957 nTotalPoints++;
1958
1959 if(0 != nSegmentIgnoreCounter)
1960 {
1961 nSegmentIgnoreCounter--;
1962 }
1963 else
1964 {
1965 aSegments.push_back(static_cast<sal_uInt8>(0));
1966
1967 if(bBezier)
1968 {
1969 aSegments.push_back(static_cast<sal_uInt8>(0xb3));
1970 }
1971 else
1972 {
1973 aSegments.push_back(static_cast<sal_uInt8>(0xac));
1974 }
1975
1976 if(i + 1 == nPoints)
1977 {
1978 if(nPolyCount > 1)
1979 {
1980 // end of polygon
1981 aSegments.push_back(static_cast<sal_uInt8>(1));
1982 aSegments.push_back(static_cast<sal_uInt8>(0x60));
1983 }
1984 }
1985 else
1986 {
1987 aSegments.push_back(static_cast<sal_uInt8>(1));
1988
1989 if(PolyFlags::Control == aPolygon.GetFlags(i + 1))
1990 {
1991 aSegments.push_back(static_cast<sal_uInt8>(0x20));
1992 nSegmentIgnoreCounter = 2;
1993 }
1994 else
1995 {
1996 aSegments.push_back(static_cast<sal_uInt8>(0));
1997 }
1998 }
1999 }
2000 }
2001 }
2002
2003 if(0 == nTotalPoints || aSegments.size() < 6 || aVertices.size() < 6)
2004 return false;
2005
2006 // Little endian
2007 aVertices[0] = static_cast<sal_uInt8>(nTotalPoints);
2008 aVertices[1] = static_cast<sal_uInt8>(nTotalPoints >> 8);
2009 aVertices[2] = static_cast<sal_uInt8>(nTotalPoints);
2010 aVertices[3] = static_cast<sal_uInt8>(nTotalPoints >> 8);
2011
2012 aSegments.push_back(static_cast<sal_uInt8>(0));
2013 aSegments.push_back(static_cast<sal_uInt8>(0x80));
2014
2015 const sal_uInt32 nSegmentBufSize(aSegments.size() - 6);
2016 aSegments[0] = static_cast<sal_uInt8>(nSegmentBufSize >> 1);
2017 aSegments[1] = static_cast<sal_uInt8>(nSegmentBufSize >> 9);
2018 aSegments[2] = static_cast<sal_uInt8>(nSegmentBufSize >> 1);
2019 aSegments[3] = static_cast<sal_uInt8>(nSegmentBufSize >> 9);
2020
2021 AddOpt(
2022 ESCHER_Prop_geoRight,
2023 rGeoRect.Width);
2024 AddOpt(
2025 ESCHER_Prop_geoBottom,
2026 rGeoRect.Height);
2027 AddOpt(
2028 ESCHER_Prop_shapePath,
2029 ESCHER_ShapeComplex);
2030 AddOpt(
2031 ESCHER_Prop_pVertices,
2032 true,
2033 aVertices.size() - 6,
2034 aVertices);
2035 AddOpt(
2036 ESCHER_Prop_pSegmentInfo,
2037 true,
2038 aSegments.size(),
2039 aSegments);
2040
2041 return true;
2042 }
2043
2044
2045 /*
2046 in MS,the connector including 9 types :
2047 "straightConnector1",
2048 "bentConnector2","bentConnector3","bentConnector4","bentConnector5"
2049 "curvedConnector2","curvedConnector3","curvedConnector4","curvedConnector5"
2050 in AOO,including 4 types:"standard","lines","line","curve"
2051 when save as MS file, the connector must be convert to corresponding type.
2052 "line" and "lines" <-> "straightConnector1"
2053 "standard" <-> "bentConnector2-5"
2054 "curve" <-> "curvedConnector2-5"
2055 */
2056 static sal_Int32 lcl_GetAdjustValueCount( const XPolygon& rPoly )
2057 {
2058 int nRet = 0;
2059 switch ( rPoly.GetSize() )
2060 {
2061 case 2 :
2062 case 3:
2063 nRet = 0;
2064 break;
2065 case 4:
2066 nRet = 1;
2067 break;
2068 case 5:
2069 nRet = 2;
2070 break;
2071 default:
2072 if ( rPoly.GetSize()>=6 )
2073 nRet = 3;
2074 break;
2075 }
2076 return nRet;
2077 }
2078
2079 // Adjust value decide the position which connector should turn a corner
2080 static sal_Int32 lcl_GetConnectorAdjustValue ( const XPolygon& rPoly, sal_uInt16 nIndex )
2081 {
2082 sal_uInt16 k = rPoly.GetSize();
2083 OSL_ASSERT ( k >= ( 3 + nIndex ) );
2084
2085 Point aPt;
2086 Point aStart = rPoly[0];
2087 Point aEnd = rPoly[k-1];
2088 if ( aEnd.Y() == aStart.Y() )
2089 aEnd.setY( aStart.Y() +4 );
2090 if ( aEnd.X() == aStart.X() )
2091 aEnd.setX( aStart.X() +4 );
2092
2093 bool bVertical = ( rPoly[1].X()-aStart.X() ) == 0 ;
2094 // vertical and horizon alternate
2095 if ( nIndex%2 == 1 ) bVertical = !bVertical;
2096 aPt = rPoly[ nIndex + 1];
2097
2098 sal_Int32 nAdjustValue;
2099 if ( bVertical )
2100 nAdjustValue = ( aPt.Y()-aStart.Y())* 21600 /(aEnd.Y()-aStart.Y());
2101 else
2102 nAdjustValue = ( aPt.X()-aStart.X() )* 21600 /(aEnd.X()-aStart.X());
2103
2104 return nAdjustValue;
2105 }
2106
2107
2108 static void lcl_Rotate(Degree100 nAngle, Point center, Point& pt)
2109 {
2110 nAngle = NormAngle36000(nAngle);
2111
2112 int cs, sn;
2113 switch (nAngle.get())
2114 {
2115 case 0:
2116 cs =1;
2117 sn =0;
2118 break;
2119 case 9000:
2120 cs =0;
2121 sn =1;
2122 break;
2123 case 18000:
2124 cs = -1;
2125 sn = 0;
2126 break;
2127 case 27000:
2128 cs = 0;
2129 sn = -1;
2130 break;
2131 default:
2132 return;
2133 }
2134 sal_Int32 x0 =pt.X()-center.X();
2135 sal_Int32 y0 =pt.Y()-center.Y();
2136 pt.setX(center.X()+ x0*cs-y0*sn );
2137 pt.setY(center.Y()+ y0*cs+x0*sn );
2138 }
2139 /*
2140 FlipV defines that the shape will be flipped vertically about the center of its bounding box.
2141 Generally, draw the connector from top to bottom, from left to right when meet the adjust value,
2142 but when (X1>X2 or Y1>Y2),the draw director must be reverse, FlipV or FlipH should be set to true.
2143 */
2144 static bool lcl_GetAngle(tools::Polygon &rPoly, ShapeFlag& rShapeFlags,sal_Int32& nAngle )
2145 {
2146 Point aStart = rPoly[0];
2147 Point aEnd = rPoly[rPoly.GetSize()-1];
2148 nAngle = ( rPoly[1].X() == aStart.X() ) ? 9000: 0 ;
2149 Point p1(aStart.X(),aStart.Y());
2150 Point p2(aEnd.X(),aEnd.Y());
2151 if ( nAngle )
2152 {
2153 Point center((aEnd.X()+aStart.X())>>1,(aEnd.Y()+aStart.Y())>>1);
2154 lcl_Rotate(Degree100(-nAngle), center,p1);
2155 lcl_Rotate(Degree100(-nAngle), center,p2);
2156 }
2157 if ( p1.X() > p2.X() )
2158 {
2159 if ( nAngle )
2160 rShapeFlags |= ShapeFlag::FlipV;
2161 else
2162 rShapeFlags |= ShapeFlag::FlipH;
2163
2164 }
2165 if ( p1.Y() > p2.Y() )
2166 {
2167 if ( nAngle )
2168 rShapeFlags |= ShapeFlag::FlipH;
2169 else
2170 rShapeFlags |= ShapeFlag::FlipV;
2171 }
2172
2173 if ( (rShapeFlags&ShapeFlag::FlipH) && (rShapeFlags&ShapeFlag::FlipV) )
2174 {
2175 rShapeFlags &= ~ShapeFlag( ShapeFlag::FlipH | ShapeFlag::FlipV );
2176 nAngle +=18000;
2177 }
2178
2179 if ( nAngle )
2180 {
2181 // Set angle properties
2182 nAngle *= 655;
2183 nAngle += 0x8000;
2184 nAngle &=~0xffff; // round nAngle to whole number of degrees
2185 return true;
2186 }
2187 return false;
2188 }
2189 bool EscherPropertyContainer::CreateConnectorProperties(
2190 const uno::Reference<drawing::XShape> & rXShape,
2191 EscherSolverContainer& rSolverContainer, awt::Rectangle& rGeoRect,
2192 sal_uInt16& rShapeType, ShapeFlag& rShapeFlags )
2193 {
2194 bool bRetValue = false;
2195 rShapeType = 0;
2196 rShapeFlags = ShapeFlag::NONE;
2197
2198 if ( rXShape.is() )
2199 {
2200 uno::Reference<beans::XPropertySet> aXPropSet;
2201 uno::Reference<drawing::XShape> aShapeA, aShapeB;
2202 uno::Any aAny( rXShape->queryInterface( cppu::UnoType<beans::XPropertySet>::get()));
2203 if ( aAny >>= aXPropSet )
2204 {
2205 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"EdgeKind"_ustr, true ) )
2206 {
2207 drawing::ConnectorType eCt;
2208 aAny >>= eCt;
2209 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"EdgeStartPoint"_ustr ) )
2210 {
2211 awt::Point aStartPoint = *o3tl::doAccess<awt::Point>(aAny);
2212 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"EdgeEndPoint"_ustr ) )
2213 {
2214 awt::Point aEndPoint = *o3tl::doAccess<awt::Point>(aAny);
2215
2216 rShapeFlags = ShapeFlag::HaveAnchor | ShapeFlag::HaveShapeProperty | ShapeFlag::Connector;
2217 rGeoRect = awt::Rectangle( aStartPoint.X, aStartPoint.Y,
2218 ( aEndPoint.X - aStartPoint.X ) + 1, ( aEndPoint.Y - aStartPoint.Y ) + 1 );
2219 // set standard's FLIP in below code
2220 if ( eCt != drawing::ConnectorType_STANDARD)
2221 {
2222 if ( rGeoRect.Height < 0 ) // justify
2223 {
2224 rShapeFlags |= ShapeFlag::FlipV;
2225 rGeoRect.Y = aEndPoint.Y;
2226 rGeoRect.Height = -rGeoRect.Height;
2227 }
2228 if ( rGeoRect.Width < 0 )
2229 {
2230 rShapeFlags |= ShapeFlag::FlipH;
2231 rGeoRect.X = aEndPoint.X;
2232 rGeoRect.Width = -rGeoRect.Width;
2233 }
2234 }
2235 sal_uInt32 nAdjustValue1, nAdjustValue2;
2236 nAdjustValue1 = nAdjustValue2 = 0x2a30;
2237
2238 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"EdgeStartConnection"_ustr ) )
2239 aAny >>= aShapeA;
2240 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"EdgeEndConnection"_ustr ) )
2241 aAny >>= aShapeB;
2242 rSolverContainer.AddConnector( rXShape, aStartPoint, aShapeA, aEndPoint, aShapeB );
2243 switch ( eCt )
2244 {
2245 case drawing::ConnectorType_CURVE :
2246 {
2247 rShapeType = ESCHER_ShpInst_CurvedConnector3;
2248 AddOpt( ESCHER_Prop_cxstyle, ESCHER_cxstyleCurved );
2249 AddOpt( ESCHER_Prop_adjustValue, nAdjustValue1 );
2250 AddOpt( ESCHER_Prop_adjust2Value, -static_cast<sal_Int32>(nAdjustValue2) );
2251 }
2252 break;
2253
2254 case drawing::ConnectorType_STANDARD :// Connector 2->5
2255 {
2256 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"PolyPolygonBezier"_ustr ) )
2257 {
2258 tools::PolyPolygon aPolyPolygon = GetPolyPolygon( aAny );
2259 tools::Polygon aPoly;
2260 if ( aPolyPolygon.Count() > 0 )
2261 {
2262 AddOpt( ESCHER_Prop_cxstyle, ESCHER_cxstyleBent );
2263 aPoly = aPolyPolygon[ 0 ];
2264 sal_Int32 nAdjCount = lcl_GetAdjustValueCount( aPoly );
2265 rShapeType = static_cast<sal_uInt16>( ESCHER_ShpInst_BentConnector2 + nAdjCount);
2266 for ( sal_Int32 i = 0 ; i < nAdjCount; ++ i)
2267 AddOpt( static_cast<sal_uInt16>( ESCHER_Prop_adjustValue+i) , lcl_GetConnectorAdjustValue( aPoly, i ) );
2268 }
2269 sal_Int32 nAngle=0;
2270 if (lcl_GetAngle(aPoly,rShapeFlags,nAngle ))
2271 {
2272 AddOpt( ESCHER_Prop_Rotation, nAngle );
2273 }
2274 }
2275 else
2276 {
2277 rShapeType = ESCHER_ShpInst_BentConnector3;
2278 AddOpt( ESCHER_Prop_cxstyle, ESCHER_cxstyleBent );
2279 }
2280 }
2281 break;
2282 default:
2283 case drawing::ConnectorType_LINE :
2284 case drawing::ConnectorType_LINES : // Connector 2->5
2285 {
2286 rShapeType = ESCHER_ShpInst_StraightConnector1;
2287 AddOpt( ESCHER_Prop_cxstyle, ESCHER_cxstyleStraight );
2288 }
2289 break;
2290 }
2291 CreateLineProperties( aXPropSet, false );
2292 bRetValue = true;
2293 }
2294 }
2295 }
2296 }
2297 }
2298 return bRetValue;
2299 }
2300
2301 void EscherPropertyContainer::CreateShadowProperties(
2302 const uno::Reference<beans::XPropertySet> & rXPropSet )
2303 {
2304 uno::Any aAny;
2305
2306 sal_uInt32 nLineFlags = 0; // default : shape has no line
2307 sal_uInt32 nFillFlags = 0x10; // shape is filled
2308
2309 GetOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags );
2310 GetOpt( ESCHER_Prop_fNoFillHitTest, nFillFlags );
2311
2312 sal_uInt32 nDummy;
2313 bool bGraphic = GetOpt( DFF_Prop_pib, nDummy ) || GetOpt( DFF_Prop_pibName, nDummy ) || GetOpt( DFF_Prop_pibFlags, nDummy );
2314
2315 sal_uInt32 nShadowFlags = 0x20000;
2316 if ( ( nLineFlags & 8 ) || ( nFillFlags & 0x10 ) || bGraphic )
2317 {
2318 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"Shadow"_ustr, true ) )
2319 {
2320 bool bHasShadow = false; // shadow is possible only if at least a fillcolor, linecolor or graphic is set
2321 if ( (aAny >>= bHasShadow) && bHasShadow )
2322 {
2323 nShadowFlags |= 2;
2324 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"ShadowColor"_ustr ) )
2325 AddOpt( ESCHER_Prop_shadowColor, ImplGetColor( *o3tl::doAccess<sal_uInt32>(aAny) ) );
2326 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"ShadowXDistance"_ustr ) )
2327 AddOpt( ESCHER_Prop_shadowOffsetX, *o3tl::doAccess<sal_Int32>(aAny) * 360 );
2328 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"ShadowYDistance"_ustr ) )
2329 AddOpt( ESCHER_Prop_shadowOffsetY, *o3tl::doAccess<sal_Int32>(aAny) * 360 );
2330 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, rXPropSet, u"ShadowTransparence"_ustr ) )
2331 AddOpt( ESCHER_Prop_shadowOpacity, 0x10000 - (static_cast<sal_uInt32>(*o3tl::doAccess<sal_uInt16>(aAny)) * 655 ) );
2332 }
2333 }
2334 }
2335 AddOpt( ESCHER_Prop_fshadowObscured, nShadowFlags );
2336 }
2337
2338 sal_Int32 EscherPropertyContainer::GetValueForEnhancedCustomShapeParameter( const drawing::EnhancedCustomShapeParameter& rParameter,
2339 const std::vector< sal_Int32 >& rEquationOrder, bool bAdjustTrans )
2340 {
2341 sal_Int32 nValue = 0;
2342 if ( rParameter.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
2343 {
2344 double fValue(0.0);
2345 if ( rParameter.Value >>= fValue )
2346 nValue = static_cast<sal_Int32>(fValue);
2347 }
2348 else
2349 rParameter.Value >>= nValue;
2350
2351 switch( rParameter.Type )
2352 {
2353 case drawing::EnhancedCustomShapeParameterType::EQUATION :
2354 {
2355 size_t nIndex = static_cast<size_t>(nValue);
2356 OSL_ASSERT(nIndex < rEquationOrder.size());
2357 if ( nIndex < rEquationOrder.size() )
2358 {
2359 nValue = static_cast<sal_uInt16>(rEquationOrder[ nIndex ]);
2360 nValue |= sal_uInt32(0x80000000);
2361 }
2362 }
2363 break;
2364 case drawing::EnhancedCustomShapeParameterType::ADJUSTMENT:
2365 {
2366 if(bAdjustTrans)
2367 {
2368 sal_uInt32 nAdjustValue = 0;
2369 bool bGot = GetOpt(static_cast<sal_uInt16>( DFF_Prop_adjustValue + nValue ), nAdjustValue);
2370 if(bGot) nValue = static_cast<sal_Int32>(nAdjustValue);
2371 }
2372 }
2373 break;
2374 case drawing::EnhancedCustomShapeParameterType::NORMAL :
2375 default:
2376 break;
2377 /* not sure if it is allowed to set following values
2378 (but they are not yet used)
2379 case drawing::EnhancedCustomShapeParameterType::BOTTOM :
2380 case drawing::EnhancedCustomShapeParameterType::RIGHT :
2381 case drawing::EnhancedCustomShapeParameterType::TOP :
2382 case drawing::EnhancedCustomShapeParameterType::LEFT :
2383 */
2384 }
2385 return nValue;
2386 }
2387
2388 static bool GetValueForEnhancedCustomShapeHandleParameter( sal_Int32& nRetValue, const drawing::EnhancedCustomShapeParameter& rParameter )
2389 {
2390 bool bSpecial = false;
2391 nRetValue = 0;
2392 if ( rParameter.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
2393 {
2394 double fValue(0.0);
2395 if ( rParameter.Value >>= fValue )
2396 nRetValue = static_cast<sal_Int32>(fValue);
2397 }
2398 else
2399 rParameter.Value >>= nRetValue;
2400
2401 switch( rParameter.Type )
2402 {
2403 case drawing::EnhancedCustomShapeParameterType::EQUATION :
2404 {
2405 nRetValue += 3;
2406 bSpecial = true;
2407 }
2408 break;
2409 case drawing::EnhancedCustomShapeParameterType::ADJUSTMENT :
2410 {
2411 nRetValue += 0x100;
2412 bSpecial = true;
2413 }
2414 break;
2415 case drawing::EnhancedCustomShapeParameterType::TOP :
2416 case drawing::EnhancedCustomShapeParameterType::LEFT :
2417 {
2418 nRetValue = 0;
2419 bSpecial = true;
2420 }
2421 break;
2422 case drawing::EnhancedCustomShapeParameterType::RIGHT :
2423 case drawing::EnhancedCustomShapeParameterType::BOTTOM :
2424 {
2425 nRetValue = 1;
2426 bSpecial = true;
2427 }
2428 break;
2429 case drawing::EnhancedCustomShapeParameterType::NORMAL :
2430 {
2431
2432 }
2433 break;
2434 }
2435 return bSpecial;
2436 }
2437
2438 static void ConvertEnhancedCustomShapeEquation(
2439 const SdrObjCustomShape& rSdrObjCustomShape,
2440 std::vector< EnhancedCustomShapeEquation >& rEquations,
2441 std::vector< sal_Int32 >& rEquationOrder )
2442 {
2443 uno::Sequence< OUString > sEquationSource;
2444 const SdrCustomShapeGeometryItem& rGeometryItem =
2445 rSdrObjCustomShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
2446 const uno::Any* pAny = rGeometryItem.GetPropertyValueByName( u"Equations"_ustr );
2447 if ( pAny )
2448 *pAny >>= sEquationSource;
2449 sal_Int32 nEquationSourceCount = sEquationSource.getLength();
2450 if ( !(nEquationSourceCount && (nEquationSourceCount <= 128)) )
2451 return;
2452
2453 sal_Int32 i;
2454 for ( i = 0; i < nEquationSourceCount; i++ )
2455 {
2456 EnhancedCustomShape2d aCustomShape2d(
2457 const_cast< SdrObjCustomShape& >(rSdrObjCustomShape));
2458 try
2459 {
2460 std::shared_ptr< EnhancedCustomShape::ExpressionNode > aExpressNode(
2461 EnhancedCustomShape::FunctionParser::parseFunction(
2462 sEquationSource[ i ], aCustomShape2d));
2463 drawing::EnhancedCustomShapeParameter aPara( aExpressNode->fillNode( rEquations, nullptr, 0 ) );
2464 if ( aPara.Type != drawing::EnhancedCustomShapeParameterType::EQUATION )
2465 {
2466 EnhancedCustomShapeEquation aEquation;
2467 aEquation.nOperation = 0;
2468 EnhancedCustomShape::FillEquationParameter( aPara, 0, aEquation );
2469 rEquations.push_back( aEquation );
2470 }
2471 }
2472 catch ( const EnhancedCustomShape::ParseError& )
2473 {
2474 EnhancedCustomShapeEquation aEquation; // ups, we should not be here,
2475 aEquation.nOperation = 0; // creating a default equation with value 1
2476 aEquation.nPara[ 0 ] = 1; // hoping that this will not break anything
2477 rEquations.push_back( aEquation );
2478 }
2479 catch ( ... )
2480 {
2481 EnhancedCustomShapeEquation aEquation; // #i112309# EnhancedCustomShape::Parse error
2482 aEquation.nOperation = 0; // not caught on linux platform
2483 aEquation.nPara[ 0 ] = 1;
2484 rEquations.push_back( aEquation );
2485 }
2486 rEquationOrder.push_back( rEquations.size() - 1 );
2487 }
2488 // now updating our old equation indices, they are marked with a bit in the hiword of nOperation
2489 for (auto & equation : rEquations)
2490 {
2491 sal_uInt32 nMask = 0x20000000;
2492 for( i = 0; i < 3; i++ )
2493 {
2494 if ( equation.nOperation & nMask )
2495 {
2496 equation.nOperation ^= nMask;
2497 const size_t nIndex(equation.nPara[ i ] & 0x3ff);
2498
2499 // #i124661# check index access, there are cases where this is out of bound leading
2500 // to errors up to crashes when executed
2501 if(nIndex < rEquationOrder.size())
2502 {
2503 equation.nPara[ i ] = rEquationOrder[ nIndex ] | 0x400;
2504 }
2505 else
2506 {
2507 OSL_ENSURE(false, "Attempted out of bound access to rEquationOrder of CustomShape (!)");
2508 }
2509 }
2510 nMask = sal_uInt32(nMask << 1);
2511 }
2512 }
2513 }
2514
2515 bool EscherPropertyContainer::IsDefaultObject(
2516 const SdrObjCustomShape& rSdrObjCustomShape,
2517 const MSO_SPT eShapeType)
2518 {
2519 switch(eShapeType)
2520 {
2521 // if the custom shape is not default shape of ppt, return false;
2522 case mso_sptTearDrop:
2523 return false;
2524
2525 default:
2526 break;
2527 }
2528
2529 return rSdrObjCustomShape.IsDefaultGeometry( SdrObjCustomShape::DefaultType::Equations )
2530 && rSdrObjCustomShape.IsDefaultGeometry( SdrObjCustomShape::DefaultType::Viewbox )
2531 && rSdrObjCustomShape.IsDefaultGeometry( SdrObjCustomShape::DefaultType::Path )
2532 && rSdrObjCustomShape.IsDefaultGeometry( SdrObjCustomShape::DefaultType::Gluepoints )
2533 && rSdrObjCustomShape.IsDefaultGeometry( SdrObjCustomShape::DefaultType::Segments )
2534 && rSdrObjCustomShape.IsDefaultGeometry( SdrObjCustomShape::DefaultType::StretchX )
2535 && rSdrObjCustomShape.IsDefaultGeometry( SdrObjCustomShape::DefaultType::StretchY )
2536 && rSdrObjCustomShape.IsDefaultGeometry( SdrObjCustomShape::DefaultType::TextFrames );
2537 }
2538
2539 void EscherPropertyContainer::LookForPolarHandles( const MSO_SPT eShapeType, sal_Int32& nAdjustmentsWhichNeedsToBeConverted )
2540 {
2541 const mso_CustomShape* pDefCustomShape = GetCustomShapeContent( eShapeType );
2542 if ( !pDefCustomShape || pDefCustomShape->pHandles.empty() )
2543 return;
2544
2545 sal_Int32 k, nkCount = pDefCustomShape->pHandles.size();
2546 for (k = 0; k < nkCount; k++)
2547 {
2548 const SvxMSDffHandle* pData = &pDefCustomShape->pHandles[k];
2549 if ( pData->nFlags & SvxMSDffHandleFlags::POLAR )
2550 {
2551 if ( ( pData->nPositionY >= 0x256 ) || ( pData->nPositionY <= 0x107 ) )
2552 nAdjustmentsWhichNeedsToBeConverted |= ( 1 << k );
2553 }
2554 }
2555 }
2556
2557 bool EscherPropertyContainer::GetAdjustmentValue( const drawing::EnhancedCustomShapeAdjustmentValue & rkProp, sal_Int32 nIndex, sal_Int32 nAdjustmentsWhichNeedsToBeConverted, sal_Int32& nValue )
2558 {
2559 if ( rkProp.State != beans::PropertyState_DIRECT_VALUE )
2560 return false;
2561
2562 bool bUseFixedFloat = ( nAdjustmentsWhichNeedsToBeConverted & ( 1 << nIndex ) ) != 0;
2563 if ( rkProp.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
2564 {
2565 double fValue(0.0);
2566 rkProp.Value >>= fValue;
2567 if ( bUseFixedFloat )
2568 fValue *= 65536.0;
2569 nValue = static_cast<sal_Int32>(fValue);
2570 }
2571 else
2572 {
2573 rkProp.Value >>= nValue;
2574 if ( bUseFixedFloat )
2575 nValue <<= 16;
2576 }
2577
2578 return true;
2579 }
2580
2581 void EscherPropertyContainer::CreateCustomShapeProperties( const MSO_SPT eShapeType, const uno::Reference< drawing::XShape > & rXShape, bool bOOXML )
2582 {
2583 uno::Reference< beans::XPropertySet > aXPropSet( rXShape, uno::UNO_QUERY );
2584 if ( !aXPropSet.is() )
2585 return;
2586
2587 SdrObjCustomShape* pSdrObjCustomShape = dynamic_cast< SdrObjCustomShape* >(SdrObject::getSdrObjectFromXShape(rXShape));
2588 if(!pSdrObjCustomShape)
2589 {
2590 return;
2591 }
2592
2593 SdrObjCustomShape& rSdrObjCustomShape = *pSdrObjCustomShape;
2594 uno::Any aGeoPropSet = aXPropSet->getPropertyValue( u"CustomShapeGeometry"_ustr );
2595 uno::Sequence< beans::PropertyValue > aGeoPropSeq;
2596 if ( !(aGeoPropSet >>= aGeoPropSeq) )
2597 return;
2598
2599 static constexpr OUStringLiteral sViewBox ( u"ViewBox" );
2600 static constexpr OUStringLiteral sTextRotateAngle ( u"TextRotateAngle" );
2601 static constexpr OUString sExtrusion ( u"Extrusion"_ustr );
2602 static constexpr OUStringLiteral sEquations ( u"Equations" );
2603 static constexpr OUStringLiteral sPath ( u"Path" );
2604 static constexpr OUString sTextPath ( u"TextPath"_ustr );
2605 static constexpr OUStringLiteral sHandles ( u"Handles" );
2606 static constexpr OUStringLiteral sAdjustmentValues ( u"AdjustmentValues" );
2607
2608 bool bAdjustmentValuesProp = false;
2609 uno::Any aAdjustmentValuesProp;
2610 bool bPathCoordinatesProp = false;
2611 uno::Any aPathCoordinatesProp;
2612
2613 sal_Int32 nAdjustmentsWhichNeedsToBeConverted = 0;
2614 uno::Sequence< beans::PropertyValues > aHandlesPropSeq;
2615 bool bPredefinedHandlesUsed = true;
2616 const bool bIsDefaultObject(
2617 IsDefaultObject(
2618 rSdrObjCustomShape,
2619 eShapeType));
2620
2621 bool bUseDefaultObject = false;
2622 if (bOOXML)
2623 {
2624 const mso_CustomShape* pDefCustomShape = GetCustomShapeContent(eShapeType);
2625 if(pDefCustomShape)
2626 bUseDefaultObject = true;
2627 }
2628
2629 // convert property "Equations" into std::vector< EnhancedCustomShapeEquationEquation >
2630 std::vector< EnhancedCustomShapeEquation > aEquations;
2631 std::vector< sal_Int32 > aEquationOrder;
2632 ConvertEnhancedCustomShapeEquation(
2633 rSdrObjCustomShape,
2634 aEquations,
2635 aEquationOrder);
2636
2637 sal_Int32 i, nCount = aGeoPropSeq.getLength();
2638 for ( i = 0; i < nCount; i++ )
2639 {
2640 const beans::PropertyValue& rProp = aGeoPropSeq[ i ];
2641 if ( rProp.Name == sViewBox )
2642 {
2643 if (!bIsDefaultObject && !bUseDefaultObject)
2644 {
2645 awt::Rectangle aViewBox;
2646 if ( rProp.Value >>= aViewBox )
2647 {
2648 AddOpt( DFF_Prop_geoLeft, aViewBox.X );
2649 AddOpt( DFF_Prop_geoTop, aViewBox.Y );
2650 AddOpt( DFF_Prop_geoRight, aViewBox.X + aViewBox.Width );
2651 AddOpt( DFF_Prop_geoBottom,aViewBox.Y + aViewBox.Height );
2652 }
2653 }
2654 }
2655 else if ( rProp.Name == sTextRotateAngle )
2656 {
2657 double f = 0;
2658 if ( rProp.Value >>= f )
2659 {
2660 double fTextRotateAngle = fmod( f, 360.0 );
2661 if ( fTextRotateAngle < 0 )
2662 fTextRotateAngle = 360 + fTextRotateAngle;
2663 if ( ( fTextRotateAngle < 271.0 ) && ( fTextRotateAngle > 269.0 ) )
2664 AddOpt( DFF_Prop_cdirFont, mso_cdir90 );
2665 else if ( ( fTextRotateAngle < 181.0 ) && ( fTextRotateAngle > 179.0 ) )
2666 AddOpt( DFF_Prop_cdirFont, mso_cdir180 );
2667 else if ( ( fTextRotateAngle < 91.0 ) && ( fTextRotateAngle > 79.0 ) )
2668 AddOpt( DFF_Prop_cdirFont, mso_cdir270 );
2669 }
2670 }
2671 else if ( rProp.Name == sExtrusion )
2672 {
2673 uno::Sequence< beans::PropertyValue > aExtrusionPropSeq;
2674 if ( rProp.Value >>= aExtrusionPropSeq )
2675 {
2676 sal_uInt32 nLightFaceFlagsOrg, nLightFaceFlags;
2677 sal_uInt32 nFillHarshFlagsOrg, nFillHarshFlags;
2678 nLightFaceFlagsOrg = nLightFaceFlags = 0x000001;
2679 nFillHarshFlagsOrg = nFillHarshFlags = 0x00001e;
2680 if ( GetOpt( DFF_Prop_fc3DLightFace, nLightFaceFlags ) )
2681 nLightFaceFlagsOrg = nLightFaceFlags;
2682 if ( GetOpt( DFF_Prop_fc3DFillHarsh, nFillHarshFlags ) )
2683 nFillHarshFlagsOrg = nFillHarshFlags;
2684
2685 sal_Int32 r, nrCount = aExtrusionPropSeq.getLength();
2686 for ( r = 0; r < nrCount; r++ )
2687 {
2688 const beans::PropertyValue& rrProp = aExtrusionPropSeq[ r ];
2689
2690 if ( rrProp.Name == sExtrusion )
2691 {
2692 bool bExtrusionOn;
2693 if ( rrProp.Value >>= bExtrusionOn )
2694 {
2695 nLightFaceFlags |= 0x80000;
2696 if ( bExtrusionOn )
2697 nLightFaceFlags |= 8;
2698 else
2699 nLightFaceFlags &=~8;
2700 }
2701 }
2702 else if ( rrProp.Name == "Brightness" )
2703 {
2704 double fExtrusionBrightness = 0;
2705 if ( rrProp.Value >>= fExtrusionBrightness )
2706 AddOpt( DFF_Prop_c3DAmbientIntensity, static_cast<sal_Int32>( fExtrusionBrightness * 655.36 ) );
2707 }
2708 else if ( rrProp.Name == "Depth" )
2709 {
2710 double fDepth = 0;
2711 double fFraction = 0;
2712 drawing::EnhancedCustomShapeParameterPair aDepthParaPair;
2713 if ( ( rrProp.Value >>= aDepthParaPair ) && ( aDepthParaPair.First.Value >>= fDepth ) && ( aDepthParaPair.Second.Value >>= fFraction ) )
2714 {
2715 double fForeDepth = fDepth * fFraction;
2716 double fBackDepth = fDepth - fForeDepth;
2717
2718 fBackDepth *= 360.0;
2719 AddOpt( DFF_Prop_c3DExtrudeBackward, static_cast<sal_Int32>(fBackDepth) );
2720
2721 if ( fForeDepth != 0.0 )
2722 {
2723 fForeDepth *= 360.0;
2724 AddOpt( DFF_Prop_c3DExtrudeForward, static_cast<sal_Int32>(fForeDepth) );
2725 }
2726 }
2727 }
2728 else if ( rrProp.Name == "Diffusion" )
2729 {
2730 double fExtrusionDiffusion = 0;
2731 if ( rrProp.Value >>= fExtrusionDiffusion )
2732 AddOpt( DFF_Prop_c3DDiffuseAmt, static_cast<sal_Int32>( fExtrusionDiffusion * 655.36 ) );
2733 }
2734 else if ( rrProp.Name == "NumberOfLineSegments" )
2735 {
2736 sal_Int32 nExtrusionNumberOfLineSegments = 0;
2737 if ( rrProp.Value >>= nExtrusionNumberOfLineSegments )
2738 AddOpt( DFF_Prop_c3DTolerance, nExtrusionNumberOfLineSegments );
2739 }
2740 else if ( rrProp.Name == "LightFace" )
2741 {
2742 bool bExtrusionLightFace;
2743 if ( rrProp.Value >>= bExtrusionLightFace )
2744 {
2745 nLightFaceFlags |= 0x10000;
2746 if ( bExtrusionLightFace )
2747 nLightFaceFlags |= 1;
2748 else
2749 nLightFaceFlags &=~1;
2750 }
2751 }
2752 else if ( rrProp.Name == "FirstLightHarsh" )
2753 {
2754 bool bExtrusionFirstLightHarsh;
2755 if ( rrProp.Value >>= bExtrusionFirstLightHarsh )
2756 {
2757 nFillHarshFlags |= 0x20000;
2758 if ( bExtrusionFirstLightHarsh )
2759 nFillHarshFlags |= 2;
2760 else
2761 nFillHarshFlags &=~2;
2762 }
2763 }
2764 else if ( rrProp.Name == "SecondLightHarsh" )
2765 {
2766 bool bExtrusionSecondLightHarsh;
2767 if ( rrProp.Value >>= bExtrusionSecondLightHarsh )
2768 {
2769 nFillHarshFlags |= 0x10000;
2770 if ( bExtrusionSecondLightHarsh )
2771 nFillHarshFlags |= 1;
2772 else
2773 nFillHarshFlags &=~1;
2774 }
2775 }
2776 else if ( rrProp.Name == "FirstLightLevel" )
2777 {
2778 double fExtrusionFirstLightLevel = 0;
2779 if ( rrProp.Value >>= fExtrusionFirstLightLevel )
2780 AddOpt( DFF_Prop_c3DKeyIntensity, static_cast<sal_Int32>( fExtrusionFirstLightLevel * 655.36 ) );
2781 }
2782 else if ( rrProp.Name == "SecondLightLevel" )
2783 {
2784 double fExtrusionSecondLightLevel = 0;
2785 if ( rrProp.Value >>= fExtrusionSecondLightLevel )
2786 AddOpt( DFF_Prop_c3DFillIntensity, static_cast<sal_Int32>( fExtrusionSecondLightLevel * 655.36 ) );
2787 }
2788 else if ( rrProp.Name == "FirstLightDirection" )
2789 {
2790 drawing::Direction3D aExtrusionFirstLightDirection;
2791 if ( rrProp.Value >>= aExtrusionFirstLightDirection )
2792 {
2793 AddOpt( DFF_Prop_c3DKeyX, static_cast<sal_Int32>(aExtrusionFirstLightDirection.DirectionX) );
2794 AddOpt( DFF_Prop_c3DKeyY, static_cast<sal_Int32>(aExtrusionFirstLightDirection.DirectionY) );
2795 AddOpt( DFF_Prop_c3DKeyZ, static_cast<sal_Int32>(aExtrusionFirstLightDirection.DirectionZ) );
2796 }
2797 }
2798 else if ( rrProp.Name == "SecondLightDirection" )
2799 {
2800 drawing::Direction3D aExtrusionSecondLightPosition;
2801 if ( rrProp.Value >>= aExtrusionSecondLightPosition )
2802 {
2803 AddOpt( DFF_Prop_c3DFillX, static_cast<sal_Int32>(aExtrusionSecondLightPosition.DirectionX) );
2804 AddOpt( DFF_Prop_c3DFillY, static_cast<sal_Int32>(aExtrusionSecondLightPosition.DirectionY) );
2805 AddOpt( DFF_Prop_c3DFillZ, static_cast<sal_Int32>(aExtrusionSecondLightPosition.DirectionZ) );
2806 }
2807 }
2808 else if ( rrProp.Name == "Metal" )
2809 {
2810 bool bExtrusionMetal;
2811 if ( rrProp.Value >>= bExtrusionMetal )
2812 {
2813 nLightFaceFlags |= 0x40000;
2814 if ( bExtrusionMetal )
2815 nLightFaceFlags |= 4;
2816 else
2817 nLightFaceFlags &=~4;
2818 }
2819 }
2820 else if ( rrProp.Name == "ShadeMode" )
2821 {
2822 drawing::ShadeMode eExtrusionShadeMode;
2823 if ( rrProp.Value >>= eExtrusionShadeMode )
2824 {
2825 sal_uInt32 nRenderMode;
2826 switch( eExtrusionShadeMode )
2827 {
2828 default:
2829 case drawing::ShadeMode_FLAT :
2830 case drawing::ShadeMode_PHONG :
2831 case drawing::ShadeMode_SMOOTH :
2832 nRenderMode = mso_FullRender;
2833 break;
2834 case drawing::ShadeMode_DRAFT :
2835 {
2836 nRenderMode = mso_Wireframe;
2837 }
2838 break;
2839 }
2840 AddOpt( DFF_Prop_c3DRenderMode, nRenderMode );
2841 }
2842 }
2843 else if ( rrProp.Name == "RotateAngle" )
2844 {
2845 double fExtrusionAngleX = 0;
2846 double fExtrusionAngleY = 0;
2847 drawing::EnhancedCustomShapeParameterPair aRotateAnglePair;
2848 if ( ( rrProp.Value >>= aRotateAnglePair ) && ( aRotateAnglePair.First.Value >>= fExtrusionAngleX ) && ( aRotateAnglePair.Second.Value >>= fExtrusionAngleY ) )
2849 {
2850 fExtrusionAngleX *= 65536;
2851 fExtrusionAngleY *= 65536;
2852 AddOpt( DFF_Prop_c3DXRotationAngle, static_cast<sal_Int32>(fExtrusionAngleX) );
2853 AddOpt( DFF_Prop_c3DYRotationAngle, static_cast<sal_Int32>(fExtrusionAngleY) );
2854 }
2855 }
2856 else if ( rrProp.Name == "RotationCenter" )
2857 {
2858 drawing::Direction3D aExtrusionRotationCenter;
2859 if ( rrProp.Value >>= aExtrusionRotationCenter )
2860 {
2861 // tdf#145904 X- and Y-component is fraction, Z-component in EMU
2862 AddOpt( DFF_Prop_c3DRotationCenterX, static_cast<sal_Int32>( aExtrusionRotationCenter.DirectionX * 65536.0 ) );
2863 AddOpt( DFF_Prop_c3DRotationCenterY, static_cast<sal_Int32>( aExtrusionRotationCenter.DirectionY * 65536.0 ) );
2864 AddOpt( DFF_Prop_c3DRotationCenterZ, static_cast<sal_Int32>( aExtrusionRotationCenter.DirectionZ * 360.0 ) );
2865 nFillHarshFlags &=~8; // don't use AutoRotationCenter;
2866 }
2867 }
2868 else if ( rrProp.Name == "Shininess" )
2869 {
2870 double fExtrusionShininess = 0;
2871 if ( rrProp.Value >>= fExtrusionShininess )
2872 {
2873 // ODF to MS Office conversion invers to msdffimp.cxx
2874 fExtrusionShininess = std::round(fExtrusionShininess / 10.0);
2875 AddOpt( DFF_Prop_c3DShininess, static_cast<sal_Int32>(fExtrusionShininess) );
2876 }
2877 }
2878 else if ( rrProp.Name == "Skew" )
2879 {
2880 double fSkewAmount = 0;
2881 double fSkewAngle = 0;
2882 drawing::EnhancedCustomShapeParameterPair aSkewParaPair;
2883 if ( ( rrProp.Value >>= aSkewParaPair ) && ( aSkewParaPair.First.Value >>= fSkewAmount ) && ( aSkewParaPair.Second.Value >>= fSkewAngle ) )
2884 {
2885 AddOpt( DFF_Prop_c3DSkewAmount, static_cast<sal_Int32>(fSkewAmount) );
2886 AddOpt( DFF_Prop_c3DSkewAngle, static_cast<sal_Int32>( fSkewAngle * 65536 ) );
2887 }
2888 }
2889 else if ( rrProp.Name == "Specularity" )
2890 {
2891 double fExtrusionSpecularity = 0;
2892 if ( rrProp.Value >>= fExtrusionSpecularity )
2893 AddOpt( DFF_Prop_c3DSpecularAmt, static_cast<sal_Int32>( fExtrusionSpecularity * 655.36 ) );
2894 }
2895 else if ( rrProp.Name == "ProjectionMode" )
2896 {
2897 drawing::ProjectionMode eExtrusionProjectionMode;
2898 if ( rrProp.Value >>= eExtrusionProjectionMode )
2899 {
2900 nFillHarshFlags |= 0x40000;
2901 if ( eExtrusionProjectionMode == drawing::ProjectionMode_PARALLEL )
2902 nFillHarshFlags |= 4;
2903 else
2904 nFillHarshFlags &=~4;
2905 }
2906 }
2907 else if ( rrProp.Name == "ViewPoint" )
2908 {
2909 drawing::Position3D aExtrusionViewPoint;
2910 if ( rrProp.Value >>= aExtrusionViewPoint )
2911 {
2912 aExtrusionViewPoint.PositionX *= 360.0;
2913 aExtrusionViewPoint.PositionY *= 360.0;
2914 aExtrusionViewPoint.PositionZ *= 360.0;
2915 AddOpt( DFF_Prop_c3DXViewpoint, static_cast<sal_Int32>(aExtrusionViewPoint.PositionX) );
2916 AddOpt( DFF_Prop_c3DYViewpoint, static_cast<sal_Int32>(aExtrusionViewPoint.PositionY) );
2917 AddOpt( DFF_Prop_c3DZViewpoint, static_cast<sal_Int32>(aExtrusionViewPoint.PositionZ) );
2918 }
2919 }
2920 else if ( rrProp.Name == "Origin" )
2921 {
2922 double fExtrusionOriginX = 0;
2923 double fExtrusionOriginY = 0;
2924 drawing::EnhancedCustomShapeParameterPair aOriginPair;
2925 if ( ( rrProp.Value >>= aOriginPair ) && ( aOriginPair.First.Value >>= fExtrusionOriginX ) && ( aOriginPair.Second.Value >>= fExtrusionOriginY ) )
2926 {
2927 AddOpt( DFF_Prop_c3DOriginX, static_cast<sal_Int32>( fExtrusionOriginX * 65536 ) );
2928 AddOpt( DFF_Prop_c3DOriginY, static_cast<sal_Int32>( fExtrusionOriginY * 65536 ) );
2929 }
2930 }
2931 else if ( rrProp.Name == "Color" )
2932 {
2933 bool bExtrusionColor;
2934 if ( rrProp.Value >>= bExtrusionColor )
2935 {
2936 nLightFaceFlags |= 0x20000;
2937 if ( bExtrusionColor )
2938 {
2939 nLightFaceFlags |= 2;
2940 uno::Any aFillColor2;
2941 if ( EscherPropertyValueHelper::GetPropertyValue( aFillColor2, aXPropSet, u"FillColor2"_ustr, true ) )
2942 {
2943 sal_uInt32 nFillColor = ImplGetColor( *o3tl::doAccess<sal_uInt32>(aFillColor2) );
2944 AddOpt( DFF_Prop_c3DExtrusionColor, nFillColor );
2945 }
2946 }
2947 else
2948 nLightFaceFlags &=~2;
2949 }
2950 }
2951 }
2952 if ( nLightFaceFlags != nLightFaceFlagsOrg )
2953 AddOpt( DFF_Prop_fc3DLightFace, nLightFaceFlags );
2954 if ( nFillHarshFlags != nFillHarshFlagsOrg )
2955 AddOpt( DFF_Prop_fc3DFillHarsh, nFillHarshFlags );
2956 }
2957 }
2958 else if ( rProp.Name == sEquations )
2959 {
2960 if (!bIsDefaultObject && !bUseDefaultObject)
2961 {
2962 sal_uInt16 nElements = static_cast<sal_uInt16>(aEquations.size());
2963 if ( nElements )
2964 {
2965 sal_uInt16 nElementSize = 8;
2966 sal_uInt32 nStreamSize = nElementSize * nElements + 6;
2967 SvMemoryStream aMemStrm( nStreamSize );
2968 aMemStrm.WriteUInt16( nElements )
2969 .WriteUInt16( nElements )
2970 .WriteUInt16( nElementSize );
2971
2972 for (auto const& equation : aEquations)
2973 {
2974 aMemStrm.WriteUInt16( equation.nOperation )
2975 .WriteInt16(
2976 std::clamp(
2977 equation.nPara[ 0 ], sal_Int32(SAL_MIN_INT16),
2978 sal_Int32(SAL_MAX_INT16)) )
2979 .WriteInt16(
2980 std::clamp(
2981 equation.nPara[ 1 ], sal_Int32(SAL_MIN_INT16),
2982 sal_Int32(SAL_MAX_INT16)) )
2983 .WriteInt16(
2984 std::clamp(
2985 equation.nPara[ 2 ], sal_Int32(SAL_MIN_INT16),
2986 sal_Int32(SAL_MAX_INT16)) );
2987 }
2988
2989 AddOpt(DFF_Prop_pFormulas, true, 6, aMemStrm);
2990 }
2991 else
2992 {
2993 AddOpt(DFF_Prop_pFormulas, 0, true);
2994 }
2995 }
2996 }
2997 else if ( rProp.Name == sPath )
2998 {
2999 uno::Sequence< beans::PropertyValue > aPathPropSeq;
3000 if ( rProp.Value >>= aPathPropSeq )
3001 {
3002 sal_uInt32 nPathFlags, nPathFlagsOrg;
3003 nPathFlagsOrg = nPathFlags = 0x39;
3004 if ( GetOpt( DFF_Prop_fFillOK, nPathFlags ) )
3005 nPathFlagsOrg = nPathFlags;
3006
3007 sal_Int32 r, nrCount = aPathPropSeq.getLength();
3008 for ( r = 0; r < nrCount; r++ )
3009 {
3010 const beans::PropertyValue& rrProp = aPathPropSeq[ r ];
3011
3012 if ( rrProp.Name == "ExtrusionAllowed" )
3013 {
3014 bool bExtrusionAllowed;
3015 if ( rrProp.Value >>= bExtrusionAllowed )
3016 {
3017 nPathFlags |= 0x100000;
3018 if ( bExtrusionAllowed )
3019 nPathFlags |= 16;
3020 else
3021 nPathFlags &=~16;
3022 }
3023 }
3024 else if ( rrProp.Name == "ConcentricGradientFillAllowed" )
3025 {
3026 bool bConcentricGradientFillAllowed;
3027 if ( rrProp.Value >>= bConcentricGradientFillAllowed )
3028 {
3029 nPathFlags |= 0x20000;
3030 if ( bConcentricGradientFillAllowed )
3031 nPathFlags |= 2;
3032 else
3033 nPathFlags &=~2;
3034 }
3035 }
3036 else if ( rrProp.Name == "TextPathAllowed" )
3037 {
3038 bool bTextPathAllowed;
3039 if ( rrProp.Value >>= bTextPathAllowed )
3040 {
3041 nPathFlags |= 0x40000;
3042 if ( bTextPathAllowed )
3043 nPathFlags |= 4;
3044 else
3045 nPathFlags &=~4;
3046 }
3047 }
3048 else if ( rrProp.Name == "Coordinates" )
3049 {
3050 if (!bIsDefaultObject && !bUseDefaultObject)
3051 {
3052 aPathCoordinatesProp = rrProp.Value;
3053 bPathCoordinatesProp = true;
3054 }
3055 }
3056 else if ( rrProp.Name == "GluePoints" )
3057 {
3058 if (!bIsDefaultObject && !bUseDefaultObject)
3059 {
3060 uno::Sequence<drawing::EnhancedCustomShapeParameterPair> aGluePoints;
3061 if ( rrProp.Value >>= aGluePoints )
3062 {
3063 // creating the vertices
3064 sal_uInt16 nElements = static_cast<sal_uInt16>(aGluePoints.getLength());
3065 if ( nElements )
3066 {
3067 sal_uInt16 j, nElementSize = 8;
3068 sal_uInt32 nStreamSize = nElementSize * nElements + 6;
3069 SvMemoryStream aMemStrm( nStreamSize );
3070 aMemStrm.WriteUInt16( nElements )
3071 .WriteUInt16( nElements )
3072 .WriteUInt16( nElementSize );
3073 for( j = 0; j < nElements; j++ )
3074 {
3075 sal_Int32 X = GetValueForEnhancedCustomShapeParameter( aGluePoints[ j ].First, aEquationOrder );
3076 sal_Int32 Y = GetValueForEnhancedCustomShapeParameter( aGluePoints[ j ].Second, aEquationOrder );
3077 aMemStrm.WriteInt32( X )
3078 .WriteInt32( Y );
3079 }
3080
3081 AddOpt(DFF_Prop_connectorPoints, true, 6, aMemStrm); // -6
3082 }
3083 else
3084 {
3085 AddOpt(DFF_Prop_connectorPoints, 0, true);
3086 }
3087 }
3088 }
3089 }
3090 else if ( rrProp.Name == "GluePointType" )
3091 {
3092 sal_Int16 nGluePointType = sal_Int16();
3093 if ( rrProp.Value >>= nGluePointType )
3094 AddOpt( DFF_Prop_connectorType, static_cast<sal_uInt16>(nGluePointType) );
3095 }
3096 else if ( rrProp.Name == "Segments" )
3097 {
3098 if (!bIsDefaultObject && !bUseDefaultObject)
3099 {
3100 uno::Sequence<drawing::EnhancedCustomShapeSegment> aSegments;
3101 if ( rrProp.Value >>= aSegments )
3102 {
3103 // creating seginfo
3104 if ( aSegments.hasElements() )
3105 {
3106 sal_uInt16 j, nElements = static_cast<sal_uInt16>(aSegments.getLength());
3107 sal_uInt16 nElementSize = 2;
3108 sal_uInt32 nStreamSize = nElementSize * nElements + 6;
3109 SvMemoryStream aMemStrm( nStreamSize );
3110 aMemStrm.WriteUInt16( nElements )
3111 .WriteUInt16( nElements )
3112 .WriteUInt16( nElementSize );
3113 for ( j = 0; j < nElements; j++ )
3114 {
3115 // The segment type is stored in the upper 3 bits
3116 // and segment count is stored in the lower 13
3117 // bits.
3118 //
3119 // If the segment type is msopathEscape, the lower 13 bits
3120 // are divided in a 5 bit escape code and 8 bit
3121 // vertex count (not segment count!)
3122 sal_uInt16 nVal = static_cast<sal_uInt16>(aSegments[ j ].Count);
3123 switch( aSegments[ j ].Command )
3124 {
3125 case drawing::EnhancedCustomShapeSegmentCommand::UNKNOWN :
3126 case drawing::EnhancedCustomShapeSegmentCommand::LINETO :
3127 break;
3128 case drawing::EnhancedCustomShapeSegmentCommand::MOVETO :
3129 nVal = (msopathMoveTo << 13);
3130 break;
3131 case drawing::EnhancedCustomShapeSegmentCommand::CURVETO :
3132 {
3133 nVal |= (msopathCurveTo << 13);
3134 }
3135 break;
3136 case drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH :
3137 {
3138 nVal = 1;
3139 nVal |= (msopathClose << 13);
3140 }
3141 break;
3142 case drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH :
3143 {
3144 nVal = (msopathEnd << 13);
3145 }
3146 break;
3147 case drawing::EnhancedCustomShapeSegmentCommand::NOFILL :
3148 {
3149 nVal = (msopathEscape << 13) | (10 << 8);
3150 }
3151 break;
3152 case drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE :
3153 {
3154 nVal = (msopathEscape << 13) | (11 << 8);
3155 }
3156 break;
3157 case drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO :
3158 {
3159 nVal *= 3;
3160 nVal |= (msopathEscape << 13) | (1 << 8);
3161 }
3162 break;
3163 case drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE :
3164 {
3165 nVal *= 3;
3166 nVal |= (msopathEscape << 13) | (2 << 8);
3167 }
3168 break;
3169 case drawing::EnhancedCustomShapeSegmentCommand::ARCTO :
3170 {
3171 nVal <<= 2;
3172 nVal |= (msopathEscape << 13) | (3 << 8);
3173 }
3174 break;
3175 case drawing::EnhancedCustomShapeSegmentCommand::ARC :
3176 {
3177 nVal <<= 2;
3178 nVal |= (msopathEscape << 13) | (4 << 8);
3179 }
3180 break;
3181 case drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO :
3182 {
3183 nVal <<= 2;
3184 nVal |= (msopathEscape << 13) | (5 << 8);
3185 }
3186 break;
3187 case drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC :
3188 {
3189 nVal <<= 2;
3190 nVal |= (msopathEscape << 13) | (6 << 8);
3191 }
3192 break;
3193 case drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX :
3194 {
3195 nVal |= (msopathEscape << 13) | (7 << 8);
3196 }
3197 break;
3198 case drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY :
3199 {
3200 nVal |= (msopathEscape << 13) | (8 << 8);
3201 }
3202 break;
3203 }
3204 aMemStrm.WriteUInt16( nVal );
3205 }
3206
3207 AddOpt(DFF_Prop_pSegmentInfo, false, 6, aMemStrm);
3208 }
3209 else
3210 {
3211 AddOpt(DFF_Prop_pSegmentInfo, 0, true);
3212 }
3213 }
3214 }
3215 }
3216 else if ( rrProp.Name == "StretchX" )
3217 {
3218 if (!bIsDefaultObject && !bUseDefaultObject)
3219 {
3220 sal_Int32 nStretchX = 0;
3221 if ( rrProp.Value >>= nStretchX )
3222 AddOpt( DFF_Prop_stretchPointX, nStretchX );
3223 }
3224 }
3225 else if ( rrProp.Name == "StretchY" )
3226 {
3227 if (!bIsDefaultObject && !bUseDefaultObject)
3228 {
3229 sal_Int32 nStretchY = 0;
3230 if ( rrProp.Value >>= nStretchY )
3231 AddOpt( DFF_Prop_stretchPointY, nStretchY );
3232 }
3233 }
3234 else if ( rrProp.Name == "TextFrames" )
3235 {
3236 if (!bIsDefaultObject && !bUseDefaultObject)
3237 {
3238 uno::Sequence<drawing::EnhancedCustomShapeTextFrame> aPathTextFrames;
3239 if ( rrProp.Value >>= aPathTextFrames )
3240 {
3241 if ( aPathTextFrames.hasElements() )
3242 {
3243 sal_uInt16 j, nElements = static_cast<sal_uInt16>(aPathTextFrames.getLength());
3244 sal_uInt16 nElementSize = 16;
3245 sal_uInt32 nStreamSize = nElementSize * nElements + 6;
3246 SvMemoryStream aMemStrm( nStreamSize );
3247 aMemStrm.WriteUInt16( nElements )
3248 .WriteUInt16( nElements )
3249 .WriteUInt16( nElementSize );
3250 for ( j = 0; j < nElements; j++ )
3251 {
3252 sal_Int32 nLeft = GetValueForEnhancedCustomShapeParameter( aPathTextFrames[ j ].TopLeft.First, aEquationOrder );
3253 sal_Int32 nTop = GetValueForEnhancedCustomShapeParameter( aPathTextFrames[ j ].TopLeft.Second, aEquationOrder );
3254 sal_Int32 nRight = GetValueForEnhancedCustomShapeParameter( aPathTextFrames[ j ].BottomRight.First, aEquationOrder );
3255 sal_Int32 nBottom = GetValueForEnhancedCustomShapeParameter( aPathTextFrames[ j ].BottomRight.Second, aEquationOrder );
3256
3257 aMemStrm.WriteInt32( nLeft )
3258 .WriteInt32( nTop )
3259 .WriteInt32( nRight )
3260 .WriteInt32( nBottom );
3261 }
3262
3263 AddOpt(DFF_Prop_textRectangles, true, 6, aMemStrm);
3264 }
3265 else
3266 {
3267 AddOpt(DFF_Prop_textRectangles, 0, true);
3268 }
3269 }
3270 }
3271 }
3272 }
3273 if ( nPathFlags != nPathFlagsOrg )
3274 AddOpt( DFF_Prop_fFillOK, nPathFlags );
3275 }
3276 }
3277 else if ( rProp.Name == sTextPath )
3278 {
3279 uno::Sequence< beans::PropertyValue > aTextPathPropSeq;
3280 if ( rProp.Value >>= aTextPathPropSeq )
3281 {
3282 sal_uInt32 nTextPathFlagsOrg, nTextPathFlags;
3283 nTextPathFlagsOrg = nTextPathFlags = 0xffff1000; // default
3284 if ( GetOpt( DFF_Prop_gtextFStrikethrough, nTextPathFlags ) )
3285 nTextPathFlagsOrg = nTextPathFlags;
3286
3287 sal_Int32 r, nrCount = aTextPathPropSeq.getLength();
3288 for ( r = 0; r < nrCount; r++ )
3289 {
3290 const beans::PropertyValue& rrProp = aTextPathPropSeq[ r ];
3291
3292 if ( rrProp.Name == sTextPath )
3293 {
3294 bool bTextPathOn;
3295 if ( rrProp.Value >>= bTextPathOn )
3296 {
3297 nTextPathFlags |= 0x40000000;
3298 if ( bTextPathOn )
3299 {
3300 nTextPathFlags |= 0x4000;
3301
3302 sal_uInt32 nPathFlags = 0x39;
3303 GetOpt( DFF_Prop_fFillOK, nPathFlags ); // SJ: can be removed if we are supporting the TextPathAllowed property in XML
3304 nPathFlags |= 0x40004;
3305 AddOpt( DFF_Prop_fFillOK, nPathFlags );
3306 }
3307 else
3308 nTextPathFlags &=~0x4000;
3309 }
3310 }
3311 else if ( rrProp.Name == "TextPathMode" )
3312 {
3313 drawing::EnhancedCustomShapeTextPathMode eTextPathMode;
3314 if ( rrProp.Value >>= eTextPathMode )
3315 {
3316 nTextPathFlags |= 0x05000000;
3317 nTextPathFlags &=~0x500; // TextPathMode_NORMAL
3318 if ( eTextPathMode == drawing::EnhancedCustomShapeTextPathMode_PATH )
3319 nTextPathFlags |= 0x100;
3320 else if ( eTextPathMode == drawing::EnhancedCustomShapeTextPathMode_SHAPE )
3321 nTextPathFlags |= 0x500;
3322 }
3323 }
3324 else if ( rrProp.Name == "ScaleX" )
3325 {
3326 bool bTextPathScaleX;
3327 if ( rrProp.Value >>= bTextPathScaleX )
3328 {
3329 nTextPathFlags |= 0x00400000;
3330 if ( bTextPathScaleX )
3331 nTextPathFlags |= 0x40;
3332 else
3333 nTextPathFlags &=~0x40;
3334 }
3335 }
3336 else if ( rrProp.Name == "SameLetterHeights" )
3337 {
3338 bool bSameLetterHeights;
3339 if ( rrProp.Value >>= bSameLetterHeights )
3340 {
3341 nTextPathFlags |= 0x00800000;
3342 if ( bSameLetterHeights )
3343 nTextPathFlags |= 0x80;
3344 else
3345 nTextPathFlags &=~0x80;
3346 }
3347 }
3348 }
3349 if ( nTextPathFlags & 0x4000 ) // Is FontWork ?
3350 {
3351 // FontWork Text
3352 OUString aText;
3353 uno::Reference< text::XSimpleText > xText( rXShape, uno::UNO_QUERY );
3354 if ( xText.is() )
3355 aText = xText->getString();
3356 if ( aText.isEmpty() )
3357 aText = "your text"; // TODO: moving into a resource
3358 AddOpt( DFF_Prop_gtextUNICODE, aText );
3359
3360 // FontWork Font
3361 OUString aFontName;
3362 uno::Any aAny = aXPropSet->getPropertyValue( u"CharFontName"_ustr );
3363 aAny >>= aFontName;
3364 if ( aFontName.isEmpty() )
3365 aFontName = "Arial Black";
3366 AddOpt( DFF_Prop_gtextFont, aFontName );
3367
3368 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"CharScaleWidth"_ustr, true ) )
3369 {
3370 sal_Int16 nCharScaleWidth = 100;
3371 if ( aAny >>= nCharScaleWidth )
3372 {
3373 if ( nCharScaleWidth != 100 )
3374 {
3375 sal_Int32 nVal = nCharScaleWidth * 655;
3376 AddOpt( DFF_Prop_gtextSpacing, nVal );
3377 }
3378 }
3379 }
3380 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"CharHeight"_ustr, true ) )
3381 {
3382 float fCharHeight = 0.0;
3383 if ( aAny >>= fCharHeight )
3384 {
3385 sal_Int32 nTextSize = static_cast< sal_Int32 > ( fCharHeight * 65536 );
3386 AddOpt(ESCHER_Prop_gtextSize, nTextSize);
3387 }
3388 }
3389 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"CharKerning"_ustr, true ) )
3390 {
3391 sal_Int16 nCharKerning = sal_Int16();
3392 if ( aAny >>= nCharKerning )
3393 {
3394 nTextPathFlags |= 0x10000000;
3395 if ( nCharKerning )
3396 nTextPathFlags |= 0x1000;
3397 else
3398 nTextPathFlags &=~0x1000;
3399 }
3400 }
3401 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"CharPosture"_ustr, true ) )
3402 {
3403 awt::FontSlant eFontSlant;
3404 if ( aAny >>= eFontSlant )
3405 {
3406 nTextPathFlags |= 0x100010;
3407 if ( eFontSlant != awt::FontSlant_NONE )
3408 nTextPathFlags |= 0x10;
3409 else
3410 nTextPathFlags &=~0x10;
3411 }
3412 }
3413 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"CharWeight"_ustr, true ) )
3414 {
3415 float fFontWidth = 0;
3416 if ( aAny >>= fFontWidth )
3417 {
3418 nTextPathFlags |= 0x200020;
3419 if ( fFontWidth > awt::FontWeight::NORMAL )
3420 nTextPathFlags |= 0x20;
3421 else
3422 nTextPathFlags &=~0x20;
3423 }
3424 }
3425 // export gTextAlign attr
3426 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, u"TextHorizontalAdjust"_ustr, true ) )
3427 {
3428 MSO_GeoTextAlign gTextAlign = mso_alignTextCenter;
3429 drawing::TextHorizontalAdjust eHA( drawing::TextHorizontalAdjust_LEFT );
3430 aAny >>= eHA;
3431 switch( eHA )
3432 {
3433 case drawing::TextHorizontalAdjust_LEFT :
3434 gTextAlign = mso_alignTextLeft;
3435 break;
3436 case drawing::TextHorizontalAdjust_CENTER:
3437 gTextAlign = mso_alignTextCenter;
3438 break;
3439 case drawing::TextHorizontalAdjust_RIGHT:
3440 gTextAlign = mso_alignTextRight;
3441 break;
3442 case drawing::TextHorizontalAdjust_BLOCK:
3443 {
3444 drawing::TextFitToSizeType const eFTS(
3445 rSdrObjCustomShape.GetMergedItem( SDRATTR_TEXT_FITTOSIZE ).GetValue() );
3446 if (eFTS == drawing::TextFitToSizeType_ALLLINES ||
3447 eFTS == drawing::TextFitToSizeType_PROPORTIONAL)
3448 {
3449 gTextAlign = mso_alignTextStretch;
3450 }
3451 else
3452 {
3453 gTextAlign = mso_alignTextWordJust;
3454 }
3455 break;
3456 }
3457 default:
3458 break;
3459 }
3460 AddOpt(DFF_Prop_gtextAlign,gTextAlign);
3461 }
3462 }
3463 if((nTextPathFlags & 0x4000) != 0) // Is Fontwork
3464 {
3465 OutlinerParaObject* pOutlinerParaObject(rSdrObjCustomShape.GetOutlinerParaObject());
3466 if ( pOutlinerParaObject && pOutlinerParaObject->IsEffectivelyVertical() )
3467 nTextPathFlags |= 0x2000;
3468 }
3469
3470 // Use gtextFStretch for Watermark like MSO does
3471 nTextPathFlags |= use_gtextFBestFit | gtextFBestFit
3472 | use_gtextFStretch | gtextFStretch
3473 | use_gtextFShrinkFit | gtextFShrinkFit;
3474
3475 if ( nTextPathFlags != nTextPathFlagsOrg )
3476 AddOpt( DFF_Prop_gtextFStrikethrough, nTextPathFlags );
3477 }
3478 }
3479 else if ( rProp.Name == sHandles )
3480 {
3481 if (!bIsDefaultObject && !bUseDefaultObject)
3482 {
3483 bPredefinedHandlesUsed = false;
3484 if ( rProp.Value >>= aHandlesPropSeq )
3485 {
3486 sal_uInt16 nElements = static_cast<sal_uInt16>(aHandlesPropSeq.getLength());
3487 if ( nElements )
3488 {
3489 sal_uInt16 k, nElementSize = 36;
3490 sal_uInt32 nStreamSize = nElementSize * nElements + 6;
3491 SvMemoryStream aMemStrm( nStreamSize );
3492 aMemStrm.WriteUInt16( nElements )
3493 .WriteUInt16( nElements )
3494 .WriteUInt16( nElementSize );
3495
3496 for ( k = 0; k < nElements; k++ )
3497 {
3498 sal_uInt32 nFlags = 0;
3499 sal_Int32 nXPosition = 0;
3500 sal_Int32 nYPosition = 0;
3501 sal_Int32 nXMap = 0;
3502 sal_Int32 nYMap = 0;
3503 sal_Int32 nXRangeMin = 0x80000000;
3504 sal_Int32 nXRangeMax = 0x7fffffff;
3505 sal_Int32 nYRangeMin = 0x80000000;
3506 sal_Int32 nYRangeMax = 0x7fffffff;
3507
3508 const uno::Sequence< beans::PropertyValue >& rPropSeq = aHandlesPropSeq[ k ];
3509 for ( const beans::PropertyValue& rPropVal: rPropSeq )
3510 {
3511 if ( rPropVal.Name == "Position" )
3512 {
3513 drawing::EnhancedCustomShapeParameterPair aPosition;
3514 if ( rPropVal.Value >>= aPosition )
3515 {
3516 GetValueForEnhancedCustomShapeHandleParameter( nXPosition, aPosition.First );
3517 GetValueForEnhancedCustomShapeHandleParameter( nYPosition, aPosition.Second );
3518 }
3519 }
3520 else if ( rPropVal.Name == "MirroredX" )
3521 {
3522 bool bMirroredX;
3523 if ( rPropVal.Value >>= bMirroredX )
3524 {
3525 if ( bMirroredX )
3526 nFlags |= 1;
3527 }
3528 }
3529 else if ( rPropVal.Name == "MirroredY" )
3530 {
3531 bool bMirroredY;
3532 if ( rPropVal.Value >>= bMirroredY )
3533 {
3534 if ( bMirroredY )
3535 nFlags |= 2;
3536 }
3537 }
3538 else if ( rPropVal.Name == "Switched" )
3539 {
3540 bool bSwitched;
3541 if ( rPropVal.Value >>= bSwitched )
3542 {
3543 if ( bSwitched )
3544 nFlags |= 4;
3545 }
3546 }
3547 else if ( rPropVal.Name == "Polar" )
3548 {
3549 drawing::EnhancedCustomShapeParameterPair aPolar;
3550 if ( rPropVal.Value >>= aPolar )
3551 {
3552 if ( GetValueForEnhancedCustomShapeHandleParameter( nXMap, aPolar.First ) )
3553 nFlags |= 0x800;
3554 if ( GetValueForEnhancedCustomShapeHandleParameter( nYMap, aPolar.Second ) )
3555 nFlags |= 0x1000;
3556 nFlags |= 8;
3557 }
3558 }
3559 else if ( rPropVal.Name == "RadiusRangeMinimum" )
3560 {
3561 nYRangeMin = sal_Int32(0xff4c0000); // the range of angles seems to be a not
3562 nYRangeMax = sal_Int32(0x00b40000); // used feature, so we are defaulting this
3563
3564 drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
3565 if ( rPropVal.Value >>= aRadiusRangeMinimum )
3566 {
3567 if ( GetValueForEnhancedCustomShapeHandleParameter( nXRangeMin, aRadiusRangeMinimum ) )
3568 nFlags |= 0x80;
3569 nFlags |= 0x2000;
3570 }
3571 }
3572 else if ( rPropVal.Name == "RadiusRangeMaximum" )
3573 {
3574 nYRangeMin = sal_Int32(0xff4c0000); // the range of angles seems to be a not
3575 nYRangeMax = sal_Int32(0x00b40000); // used feature, so we are defaulting this
3576
3577 drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
3578 if ( rPropVal.Value >>= aRadiusRangeMaximum )
3579 {
3580 if ( GetValueForEnhancedCustomShapeHandleParameter( nXRangeMax, aRadiusRangeMaximum ) )
3581 nFlags |= 0x100;
3582 nFlags |= 0x2000;
3583 }
3584 }
3585 else if ( rPropVal.Name == "RangeXMinimum" )
3586 {
3587 drawing::EnhancedCustomShapeParameter aXRangeMinimum;
3588 if ( rPropVal.Value >>= aXRangeMinimum )
3589 {
3590 if ( GetValueForEnhancedCustomShapeHandleParameter( nXRangeMin, aXRangeMinimum ) )
3591 nFlags |= 0x80;
3592 nFlags |= 0x20;
3593 }
3594 }
3595 else if ( rPropVal.Name == "RangeXMaximum" )
3596 {
3597 drawing::EnhancedCustomShapeParameter aXRangeMaximum;
3598 if ( rPropVal.Value >>= aXRangeMaximum )
3599 {
3600 if ( GetValueForEnhancedCustomShapeHandleParameter( nXRangeMax, aXRangeMaximum ) )
3601 nFlags |= 0x100;
3602 nFlags |= 0x20;
3603 }
3604 }
3605 else if ( rPropVal.Name == "RangeYMinimum" )
3606 {
3607 drawing::EnhancedCustomShapeParameter aYRangeMinimum;
3608 if ( rPropVal.Value >>= aYRangeMinimum )
3609 {
3610 if ( GetValueForEnhancedCustomShapeHandleParameter( nYRangeMin, aYRangeMinimum ) )
3611 nFlags |= 0x200;
3612 nFlags |= 0x20;
3613 }
3614 }
3615 else if ( rPropVal.Name == "RangeYMaximum" )
3616 {
3617 drawing::EnhancedCustomShapeParameter aYRangeMaximum;
3618 if ( rPropVal.Value >>= aYRangeMaximum )
3619 {
3620 if ( GetValueForEnhancedCustomShapeHandleParameter( nYRangeMax, aYRangeMaximum ) )
3621 nFlags |= 0x400;
3622 nFlags |= 0x20;
3623 }
3624 }
3625 }
3626 aMemStrm.WriteUInt32( nFlags )
3627 .WriteInt32( nXPosition )
3628 .WriteInt32( nYPosition )
3629 .WriteInt32( nXMap )
3630 .WriteInt32( nYMap )
3631 .WriteInt32( nXRangeMin )
3632 .WriteInt32( nXRangeMax )
3633 .WriteInt32( nYRangeMin )
3634 .WriteInt32( nYRangeMax );
3635
3636 if ( nFlags & 8 )
3637 nAdjustmentsWhichNeedsToBeConverted |= ( 1 << ( nYPosition - 0x100 ) );
3638 }
3639
3640 AddOpt(DFF_Prop_Handles, true, 6, aMemStrm);
3641 }
3642 else
3643 {
3644 AddOpt(DFF_Prop_Handles, 0, true);
3645 }
3646 }
3647 }
3648 }
3649 else if ( rProp.Name == sAdjustmentValues )
3650 {
3651 // it is required, that the information which handle is polar has already be read,
3652 // so we are able to change the polar value to a fixed float
3653 aAdjustmentValuesProp = rProp.Value;
3654 bAdjustmentValuesProp = true;
3655 }
3656 }
3657 if ( bAdjustmentValuesProp )
3658 {
3659 uno::Sequence<drawing::EnhancedCustomShapeAdjustmentValue> aAdjustmentSeq;
3660 if ( aAdjustmentValuesProp >>= aAdjustmentSeq )
3661 {
3662 if ( bPredefinedHandlesUsed )
3663 LookForPolarHandles( eShapeType, nAdjustmentsWhichNeedsToBeConverted );
3664
3665 sal_Int32 k, nValue = 0, nAdjustmentValues = aAdjustmentSeq.getLength();
3666 for ( k = 0; k < nAdjustmentValues; k++ )
3667 if( GetAdjustmentValue( aAdjustmentSeq[ k ], k, nAdjustmentsWhichNeedsToBeConverted, nValue ) )
3668 {
3669 if (bUseDefaultObject)
3670 nValue = 21600 * (nValue / 100000.00);
3671
3672 AddOpt( static_cast<sal_uInt16>( DFF_Prop_adjustValue + k ), static_cast<sal_uInt32>(nValue) );
3673 }
3674 }
3675 }
3676 if( !bPathCoordinatesProp )
3677 return;
3678
3679 uno::Sequence<drawing::EnhancedCustomShapeParameterPair> aCoordinates;
3680 if ( !(aPathCoordinatesProp >>= aCoordinates) )
3681 return;
3682
3683 // creating the vertices
3684 if (aCoordinates.hasElements())
3685 {
3686 sal_uInt16 j, nElements = static_cast<sal_uInt16>(aCoordinates.getLength());
3687 sal_uInt16 nElementSize = 8;
3688 sal_uInt32 nStreamSize = nElementSize * nElements + 6;
3689 SvMemoryStream aMemStrm( nStreamSize );
3690 aMemStrm.WriteUInt16( nElements )
3691 .WriteUInt16( nElements )
3692 .WriteUInt16( nElementSize );
3693 for( j = 0; j < nElements; j++ )
3694 {
3695 sal_Int32 X = GetValueForEnhancedCustomShapeParameter( aCoordinates[ j ].First, aEquationOrder, true );
3696 sal_Int32 Y = GetValueForEnhancedCustomShapeParameter( aCoordinates[ j ].Second, aEquationOrder, true );
3697 aMemStrm.WriteInt32( X )
3698 .WriteInt32( Y );
3699 }
3700
3701 AddOpt(DFF_Prop_pVertices, true, 6, aMemStrm); // -6
3702 }
3703 else
3704 {
3705 AddOpt(DFF_Prop_pVertices, 0, true);
3706 }
3707 }
3708
3709 MSO_SPT EscherPropertyContainer::GetCustomShapeType( const uno::Reference< drawing::XShape > & rXShape, ShapeFlag& nMirrorFlags, OUString& rShapeType, bool bOOXML )
3710 {
3711 MSO_SPT eShapeType = mso_sptNil;
3712 nMirrorFlags = ShapeFlag::NONE;
3713 uno::Reference< beans::XPropertySet > aXPropSet( rXShape, uno::UNO_QUERY );
3714 if ( aXPropSet.is() )
3715 {
3716 try
3717 {
3718 uno::Any aGeoPropSet = aXPropSet->getPropertyValue( u"CustomShapeGeometry"_ustr );
3719 uno::Sequence< beans::PropertyValue > aGeoPropSeq;
3720 if ( aGeoPropSet >>= aGeoPropSeq )
3721 {
3722 sal_Int32 i, nCount = aGeoPropSeq.getLength();
3723 for ( i = 0; i < nCount; i++ )
3724 {
3725 const beans::PropertyValue& rProp = aGeoPropSeq[ i ];
3726 if ( rProp.Name == "Type" )
3727 {
3728 if ( rProp.Value >>= rShapeType )
3729 {
3730 if (bOOXML)
3731 {
3732 // In case of VML export, try to handle the
3733 // ooxml- prefix in rShapeType. If that fails,
3734 // just do the same as the binary export.
3735 eShapeType = msfilter::util::GETVMLShapeType(rShapeType);
3736 if (eShapeType == mso_sptNil)
3737 eShapeType = EnhancedCustomShapeTypeNames::Get(rShapeType);
3738 }
3739 else
3740 eShapeType = EnhancedCustomShapeTypeNames::Get( rShapeType );
3741 }
3742 }
3743 else if ( rProp.Name == "MirroredX" )
3744 {
3745 bool bMirroredX;
3746 if ( ( rProp.Value >>= bMirroredX ) && bMirroredX )
3747 nMirrorFlags |= ShapeFlag::FlipH;
3748 }
3749 else if ( rProp.Name == "MirroredY" )
3750 {
3751 bool bMirroredY;
3752 if ( ( rProp.Value >>= bMirroredY ) && bMirroredY )
3753 nMirrorFlags |= ShapeFlag::FlipV;
3754 }
3755 }
3756 }
3757 }
3758 catch( const uno::Exception& )
3759 {
3760 }
3761 }
3762 return eShapeType;
3763 }
3764
3765
3766 // Implement for form control export
3767 bool EscherPropertyContainer::CreateBlipPropertiesforOLEControl(const uno::Reference<beans::XPropertySet> & rXPropSet,
3768 const uno::Reference<drawing::XShape> & rXShape)
3769 {
3770 SdrObject* pShape = SdrObject::getSdrObjectFromXShape(rXShape);
3771 if ( !pShape )
3772 return false;
3773
3774 Graphic aGraphic(SdrExchangeView::GetObjGraphic(*pShape));
3775 const GraphicObject aGraphicObject(std::move(aGraphic));
3776
3777 if (!aGraphicObject.GetUniqueID().isEmpty())
3778 {
3779 if ( pGraphicProvider && pPicOutStrm && pShapeBoundRect )
3780 {
3781 sal_uInt32 nBlibId = pGraphicProvider->GetBlibID(*pPicOutStrm, aGraphicObject);
3782 if ( nBlibId )
3783 {
3784 AddOpt( ESCHER_Prop_pib, nBlibId, true );
3785 ImplCreateGraphicAttributes( rXPropSet, nBlibId, false );
3786 return true;
3787 }
3788 }
3789 }
3790
3791 return false;
3792 }
3793
3794 EscherPersistTable::EscherPersistTable()
3795 {
3796 }
3797
3798 EscherPersistTable::~EscherPersistTable()
3799 {
3800 }
3801
3802 bool EscherPersistTable::PtIsID( sal_uInt32 nID )
3803 {
3804 return std::any_of(maPersistTable.begin(), maPersistTable.end(),
3805 [&nID](const auto& rxEntry) { return rxEntry->mnID == nID; });
3806 }
3807
3808 void EscherPersistTable::PtInsert( sal_uInt32 nID, sal_uInt32 nOfs )
3809 {
3810 maPersistTable.push_back( std::make_unique<EscherPersistEntry>( nID, nOfs ) );
3811 }
3812
3813 void EscherPersistTable::PtDelete( sal_uInt32 nID )
3814 {
3815 auto it = std::find_if(maPersistTable.begin(), maPersistTable.end(),
3816 [&nID](const std::unique_ptr<EscherPersistEntry>& rxEntry) { return rxEntry->mnID == nID; });
3817 if (it != maPersistTable.end())
3818 maPersistTable.erase( it );
3819 }
3820
3821 sal_uInt32 EscherPersistTable::PtGetOffsetByID( sal_uInt32 nID )
3822 {
3823 for(auto const & pPtr : maPersistTable) {
3824 if ( pPtr->mnID == nID ) {
3825 return pPtr->mnOffset;
3826 }
3827 }
3828 return 0;
3829 };
3830
3831 void EscherPersistTable::PtReplace( sal_uInt32 nID, sal_uInt32 nOfs )
3832 {
3833 for(auto const & pPtr : maPersistTable) {
3834 if ( pPtr->mnID == nID ) {
3835 pPtr->mnOffset = nOfs;
3836 return;
3837 }
3838 }
3839 }
3840
3841 void EscherPersistTable::PtReplaceOrInsert( sal_uInt32 nID, sal_uInt32 nOfs )
3842 {
3843 for(auto const & pPtr : maPersistTable) {
3844 if ( pPtr->mnID == nID ) {
3845 pPtr->mnOffset = nOfs;
3846 return;
3847 }
3848 }
3849 PtInsert( nID, nOfs );
3850 }
3851
3852 bool EscherPropertyValueHelper::GetPropertyValue(
3853 uno::Any& rAny,
3854 const uno::Reference<beans::XPropertySet> & rXPropSet,
3855 const OUString& rString,
3856 bool bTestPropertyAvailability)
3857 {
3858 bool bRetValue = true;
3859 if ( bTestPropertyAvailability )
3860 {
3861 bRetValue = false;
3862 try
3863 {
3864 uno::Reference<beans::XPropertySetInfo>
3865 aXPropSetInfo( rXPropSet->getPropertySetInfo() );
3866 if ( aXPropSetInfo.is() )
3867 bRetValue = aXPropSetInfo->hasPropertyByName( rString );
3868 }
3869 catch( const uno::Exception& )
3870 {
3871 bRetValue = false;
3872 }
3873 }
3874 if ( bRetValue )
3875 {
3876 try
3877 {
3878 rAny = rXPropSet->getPropertyValue( rString );
3879 if ( !rAny.hasValue() )
3880 bRetValue = false;
3881 }
3882 catch( const uno::Exception& )
3883 {
3884 bRetValue = false;
3885 }
3886 }
3887 return bRetValue;
3888 }
3889
3890 beans::PropertyState EscherPropertyValueHelper::GetPropertyState(
3891 const uno::Reference<beans::XPropertySet> & rXPropSet,
3892 const OUString& rPropertyName )
3893 {
3894 beans::PropertyState eRetValue = beans::PropertyState_AMBIGUOUS_VALUE;
3895 try
3896 {
3897 uno::Reference<beans::XPropertyState> aXPropState
3898 ( rXPropSet, uno::UNO_QUERY );
3899 if ( aXPropState.is() )
3900 eRetValue = aXPropState->getPropertyState( rPropertyName );
3901 }
3902 catch( const uno::Exception& )
3903 {
3904 }
3905 return eRetValue;
3906 }
3907
3908 EscherBlibEntry::EscherBlibEntry( sal_uInt32 nPictureOffset, const GraphicObject& rObject, const OString& rId,
3909 const GraphicAttr* pGraphicAttr ) :
3910 maPrefMapMode ( rObject.GetPrefMapMode() ),
3911 maPrefSize ( rObject.GetPrefSize() ),
3912 mnPictureOffset ( nPictureOffset ),
3913 mnRefCount ( 1 ),
3914 mnSizeExtra ( 0 ),
3915 mbIsEmpty ( true )
3916 {
3917 mbIsNativeGraphicPossible = ( pGraphicAttr == nullptr );
3918 meBlibType = UNKNOWN;
3919 mnSize = 0;
3920
3921 sal_uInt32 nLen = static_cast<sal_uInt32>(rId.getLength());
3922 const char* pData = rId.getStr();
3923 GraphicType eType( rObject.GetType() );
3924 if (!(nLen && (eType != GraphicType::NONE)))
3925 return;
3926
3927 mnIdentifier[ 0 ] = rtl_crc32( 0,pData, nLen );
3928 mnIdentifier[ 1 ] = 0;
3929
3930 if ( pGraphicAttr )
3931 {
3932 if ( pGraphicAttr->IsSpecialDrawMode()
3933 || pGraphicAttr->IsMirrored()
3934 || pGraphicAttr->IsCropped()
3935 || pGraphicAttr->IsRotated()
3936 || pGraphicAttr->IsTransparent()
3937 || pGraphicAttr->IsAdjusted() )
3938 {
3939 SvMemoryStream aSt( sizeof( GraphicAttr ) );
3940 aSt.WriteUInt16( static_cast<sal_uInt16>(pGraphicAttr->GetDrawMode()) )
3941 .WriteUInt32( static_cast<sal_uInt32>(pGraphicAttr->GetMirrorFlags()) )
3942 .WriteInt32( pGraphicAttr->GetLeftCrop() )
3943 .WriteInt32( pGraphicAttr->GetTopCrop() )
3944 .WriteInt32( pGraphicAttr->GetRightCrop() )
3945 .WriteInt32( pGraphicAttr->GetBottomCrop() )
3946 .WriteUInt16( pGraphicAttr->GetRotation().get() )
3947 .WriteInt16( pGraphicAttr->GetLuminance() )
3948 .WriteInt16( pGraphicAttr->GetContrast() )
3949 .WriteInt16( pGraphicAttr->GetChannelR() )
3950 .WriteInt16( pGraphicAttr->GetChannelG() )
3951 .WriteInt16( pGraphicAttr->GetChannelB() )
3952 .WriteDouble( pGraphicAttr->GetGamma() );
3953 aSt.WriteBool( pGraphicAttr->IsInvert() )
3954 .WriteUChar( 255 - pGraphicAttr->GetAlpha() ); // transparency
3955 mnIdentifier[ 1 ] = rtl_crc32( 0, aSt.GetData(), aSt.Tell() );
3956 }
3957 else
3958 mbIsNativeGraphicPossible = true;
3959 }
3960 sal_uInt32 i, nTmp, n1, n2;
3961 n1 = n2 = 0;
3962 for ( i = 0; i < nLen; i++ )
3963 {
3964 nTmp = n2 >> 28; // rotating 4 bit
3965 n2 <<= 4;
3966 n2 |= n1 >> 28;
3967 n1 <<= 4;
3968 n1 |= nTmp;
3969 n1 ^= *pData++ - '0';
3970 }
3971 mnIdentifier[ 2 ] = n1;
3972 mnIdentifier[ 3 ] = n2;
3973 mbIsEmpty = false;
3974 };
3975
3976 void EscherBlibEntry::WriteBlibEntry( SvStream& rSt, bool bWritePictureOffset, sal_uInt32 nResize )
3977 {
3978 sal_uInt32 nPictureOffset = bWritePictureOffset ? mnPictureOffset : 0;
3979
3980 rSt.WriteUInt32( ( ESCHER_BSE << 16 ) | ( ( static_cast<sal_uInt16>(meBlibType) << 4 ) | 2 ) )
3981 .WriteUInt32( 36 + nResize )
3982 .WriteUChar( meBlibType );
3983
3984 switch ( meBlibType )
3985 {
3986 case EMF :
3987 case WMF : // converting EMF/WMF on OS2 to Pict
3988 rSt.WriteUChar( PICT );
3989 break;
3990 default:
3991 rSt.WriteUChar( meBlibType );
3992 }
3993
3994 rSt.WriteBytes(&mnIdentifier[0], 16);
3995 rSt.WriteUInt16( 0 )
3996 .WriteUInt32( mnSize + mnSizeExtra )
3997 .WriteUInt32( mnRefCount )
3998 .WriteUInt32( nPictureOffset )
3999 .WriteUInt32( 0 );
4000 }
4001
4002 EscherBlibEntry::~EscherBlibEntry()
4003 {
4004 };
4005
4006 bool EscherBlibEntry::operator==( const EscherBlibEntry& rEscherBlibEntry ) const
4007 {
4008 for ( int i = 0; i < 3; i++ )
4009 {
4010 if ( mnIdentifier[ i ] != rEscherBlibEntry.mnIdentifier[ i ] )
4011 return false;
4012 }
4013 return true;
4014 }
4015
4016 EscherGraphicProvider::EscherGraphicProvider( EscherGraphicProviderFlags nFlags ) :
4017 mnFlags ( nFlags )
4018 {
4019 }
4020
4021 EscherGraphicProvider::~EscherGraphicProvider()
4022 {
4023 }
4024
4025 void EscherGraphicProvider::SetNewBlipStreamOffset( sal_Int32 nOffset )
4026 {
4027 for( size_t i = 0; i < mvBlibEntrys.size(); i++ )
4028 {
4029 mvBlibEntrys[ i ]->mnPictureOffset += nOffset;
4030 }
4031 }
4032
4033 sal_uInt32 EscherGraphicProvider::ImplInsertBlib( EscherBlibEntry* p_EscherBlibEntry )
4034 {
4035 mvBlibEntrys.push_back( std::unique_ptr<EscherBlibEntry>(p_EscherBlibEntry) );
4036 return mvBlibEntrys.size();
4037 }
4038
4039 sal_uInt32 EscherGraphicProvider::GetBlibStoreContainerSize( SvStream const * pMergePicStreamBSE ) const
4040 {
4041 sal_uInt32 nSize = 44 * mvBlibEntrys.size() + 8;
4042 if ( pMergePicStreamBSE )
4043 {
4044 for ( size_t i = 0; i < mvBlibEntrys.size(); i++ )
4045 nSize += mvBlibEntrys[ i ]->mnSize + mvBlibEntrys[ i ]->mnSizeExtra;
4046 }
4047 return nSize;
4048 }
4049
4050 void EscherGraphicProvider::WriteBlibStoreEntry(SvStream& rSt,
4051 sal_uInt32 nBlipId, sal_uInt32 nResize)
4052 {
4053 if (nBlipId > mvBlibEntrys.size() || nBlipId == 0)
4054 return;
4055 mvBlibEntrys[nBlipId-1]->WriteBlibEntry(rSt, true/*bWritePictureOffSet*/, nResize);
4056 }
4057
4058 void EscherGraphicProvider::WriteBlibStoreContainer( SvStream& rSt, SvStream* pMergePicStreamBSE )
4059 {
4060 sal_uInt32 nSize = GetBlibStoreContainerSize( pMergePicStreamBSE );
4061 if ( !nSize )
4062 return;
4063
4064 rSt.WriteUInt32( ( ESCHER_BstoreContainer << 16 ) | 0x1f )
4065 .WriteUInt32( nSize - 8 );
4066
4067 if ( pMergePicStreamBSE )
4068 {
4069 sal_uInt32 nBlipSize;
4070 sal_uInt64 nOldPos = pMergePicStreamBSE->Tell();
4071 const sal_uInt32 nBuf = 0x40000; // 256KB buffer
4072 std::unique_ptr<sal_uInt8[]> pBuf(new sal_uInt8[ nBuf ]);
4073
4074 for ( size_t i = 0; i < mvBlibEntrys.size(); i++ )
4075 {
4076 EscherBlibEntry* pBlibEntry = mvBlibEntrys[ i ].get();
4077
4078 ESCHER_BlibType nBlibType = pBlibEntry->meBlibType;
4079 nBlipSize = pBlibEntry->mnSize + pBlibEntry->mnSizeExtra;
4080 pBlibEntry->WriteBlibEntry( rSt, false, nBlipSize );
4081
4082 // BLIP
4083 pMergePicStreamBSE->Seek( pBlibEntry->mnPictureOffset );
4084 sal_uInt16 n16;
4085 // record version and instance
4086 pMergePicStreamBSE->ReadUInt16( n16 );
4087 rSt.WriteUInt16( n16 );
4088 // record type
4089 pMergePicStreamBSE->ReadUInt16( n16 );
4090 rSt.WriteUInt16( ESCHER_BlipFirst + nBlibType );
4091 DBG_ASSERT( n16 == ESCHER_BlipFirst + nBlibType , "EscherGraphicProvider::WriteBlibStoreContainer: BLIP record types differ" );
4092 sal_uInt32 n32;
4093 // record size
4094 pMergePicStreamBSE->ReadUInt32( n32 );
4095 nBlipSize -= 8;
4096 rSt.WriteUInt32( nBlipSize );
4097 DBG_ASSERT( nBlipSize == n32, "EscherGraphicProvider::WriteBlibStoreContainer: BLIP sizes differ" );
4098 // record
4099 while ( nBlipSize )
4100 {
4101 sal_uInt32 nBytes = std::min( nBlipSize, nBuf );
4102 pMergePicStreamBSE->ReadBytes(pBuf.get(), nBytes);
4103 rSt.WriteBytes(pBuf.get(), nBytes);
4104 nBlipSize -= nBytes;
4105 }
4106 }
4107 pMergePicStreamBSE->Seek( nOldPos );
4108 }
4109 else
4110 {
4111 for ( size_t i = 0; i < mvBlibEntrys.size(); i++ )
4112 mvBlibEntrys[ i ]->WriteBlibEntry( rSt, true );
4113 }
4114 }
4115
4116 bool EscherGraphicProvider::GetPrefSize( const sal_uInt32 nBlibId, Size& rPrefSize, MapMode& rPrefMapMode )
4117 {
4118 bool bInRange = nBlibId && ( ( nBlibId - 1 ) < mvBlibEntrys.size() );
4119 if ( bInRange )
4120 {
4121 EscherBlibEntry* pEntry = mvBlibEntrys[ nBlibId - 1 ].get();
4122 rPrefSize = pEntry->maPrefSize;
4123 rPrefMapMode = pEntry->maPrefMapMode;
4124 }
4125 return bInRange;
4126 }
4127
4128 sal_uInt32 EscherGraphicProvider::GetBlibID( SvStream& rPicOutStrm, GraphicObject const & rGraphicObject,
4129 const awt::Rectangle* pVisArea,
4130 const GraphicAttr* pGraphicAttr, const bool bOOxmlExport )
4131 {
4132 sal_uInt32 nBlibId = 0;
4133
4134 std::unique_ptr<EscherBlibEntry> p_EscherBlibEntry( new EscherBlibEntry( rPicOutStrm.Tell(), rGraphicObject, rGraphicObject.GetUniqueID(), pGraphicAttr ) );
4135 if ( !p_EscherBlibEntry->IsEmpty() )
4136 {
4137 for ( size_t i = 0; i < mvBlibEntrys.size(); i++ )
4138 {
4139 if ( *( mvBlibEntrys[ i ] ) == *p_EscherBlibEntry )
4140 {
4141 mvBlibEntrys[ i ]->mnRefCount++;
4142 return i + 1;
4143 }
4144 }
4145
4146 bool bUseNativeGraphic( false );
4147
4148 Graphic aGraphic(rGraphicObject.GetTransformedGraphic(pGraphicAttr));
4149 GfxLink aGraphicLink;
4150 SvMemoryStream aStream;
4151
4152 const sal_uInt8* pGraphicAry = nullptr;
4153
4154 if ( p_EscherBlibEntry->mbIsNativeGraphicPossible && aGraphic.IsGfxLink() )
4155 {
4156 aGraphicLink = aGraphic.GetGfxLink();
4157
4158 p_EscherBlibEntry->mnSize = aGraphicLink.GetDataSize();
4159 pGraphicAry = aGraphicLink.GetData();
4160
4161 if ( p_EscherBlibEntry->mnSize && pGraphicAry )
4162 {
4163 switch ( aGraphicLink.GetType() )
4164 {
4165 case GfxLinkType::NativeJpg : p_EscherBlibEntry->meBlibType = PEG; break;
4166 case GfxLinkType::NativePng : p_EscherBlibEntry->meBlibType = PNG; break;
4167
4168 // #i15508# added BMP type for better exports; need to check this
4169 // checked - does not work that way, so keep out for now. It may
4170 // work somehow with direct DIB data, but that would need to be checked
4171 // carefully
4172 // for more comments please check RtfAttributeOutput::FlyFrameGraphic
4173 //
4174 // case GfxLinkType::NativeBmp : p_EscherBlibEntry->meBlibType = DIB; break;
4175
4176 case GfxLinkType::NativeWmf :
4177 {
4178 if ( aGraphicLink.IsEMF() )
4179 {
4180 p_EscherBlibEntry->meBlibType = EMF;
4181 }
4182 else if ( pGraphicAry && ( p_EscherBlibEntry->mnSize > 0x2c ) )
4183 {
4184 p_EscherBlibEntry->meBlibType = WMF;
4185 if ( ( pGraphicAry[ 0 ] == 0xd7 ) && ( pGraphicAry[ 1 ] == 0xcd )
4186 && ( pGraphicAry[ 2 ] == 0xc6 ) && ( pGraphicAry[ 3 ] == 0x9a ) )
4187 { // we have to get rid of the metafileheader
4188 pGraphicAry += 22;
4189 p_EscherBlibEntry->mnSize -= 22;
4190 }
4191 }
4192 }
4193 break;
4194 default: break;
4195 }
4196 if ( p_EscherBlibEntry->meBlibType != UNKNOWN )
4197 bUseNativeGraphic = true;
4198 }
4199 }
4200 if ( !bUseNativeGraphic )
4201 {
4202 GraphicType eGraphicType = aGraphic.GetType();
4203 if ( ( eGraphicType == GraphicType::Bitmap ) || ( eGraphicType == GraphicType::GdiMetafile ) )
4204 {
4205 ErrCode nErrCode;
4206 if ( !aGraphic.IsAnimated() )
4207 nErrCode = GraphicConverter::Export( aStream, aGraphic, ( eGraphicType == GraphicType::Bitmap ) ? ConvertDataFormat::PNG : ConvertDataFormat::EMF );
4208 else
4209 { // to store an animation, a gif has to be included into the msOG chunk of a png #I5583#
4210 GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();
4211 SvMemoryStream aGIFStream;
4212 const char* const pString = "MSOFFICE9.0";
4213 aGIFStream.WriteBytes(pString, strlen(pString));
4214 nErrCode = rFilter.ExportGraphic( aGraphic, u"", aGIFStream,
4215 rFilter.GetExportFormatNumberForShortName( u"GIF" ) );
4216 SAL_WARN_IF(
4217 nErrCode != ERRCODE_NONE, "filter.ms",
4218 "ExportGraphic to GIF failed with " << nErrCode);
4219 if (nErrCode == ERRCODE_NONE)
4220 {
4221 sal_uInt32 nGIFSreamLen = aGIFStream.Tell();
4222 uno::Sequence<sal_Int8> aGIFSeq( nGIFSreamLen );
4223 sal_Int8* pSeq = aGIFSeq.getArray();
4224 aGIFStream.Seek( STREAM_SEEK_TO_BEGIN );
4225 aGIFStream.ReadBytes(pSeq, nGIFSreamLen);
4226 beans::PropertyValue aChunkProp, aFilterProp;
4227 aChunkProp.Name = "msOG";
4228 aChunkProp.Value <<= aGIFSeq;
4229 uno::Sequence<beans::PropertyValue> aAdditionalChunkSequence{ std::move(aChunkProp) };
4230 aFilterProp.Name = "AdditionalChunks";
4231 aFilterProp.Value <<= aAdditionalChunkSequence;
4232 uno::Sequence<beans::PropertyValue> aFilterData{ std::move(aFilterProp) };
4233 nErrCode = rFilter.ExportGraphic( aGraphic, u"", aStream,
4234 rFilter.GetExportFormatNumberForShortName( u"PNG" ), &aFilterData );
4235 }
4236 }
4237 if ( nErrCode == ERRCODE_NONE )
4238 {
4239 p_EscherBlibEntry->meBlibType = ( eGraphicType == GraphicType::Bitmap ) ? PNG : EMF;
4240 p_EscherBlibEntry->mnSize = aStream.TellEnd();
4241 pGraphicAry = static_cast<sal_uInt8 const *>(aStream.GetData());
4242 }
4243 }
4244 }
4245
4246 ESCHER_BlibType eBlibType = p_EscherBlibEntry->meBlibType;
4247 if ( p_EscherBlibEntry->mnSize && pGraphicAry && ( eBlibType != UNKNOWN ) )
4248 {
4249 sal_uInt32 nExtra, nAtomSize = 0;
4250 sal_uInt32 nInstance, nUncompressedSize = p_EscherBlibEntry->mnSize;
4251
4252 if ( mnFlags & EscherGraphicProviderFlags::UseInstances )
4253 {
4254 rPicOutStrm.WriteUInt32( 0x7f90000 | static_cast<sal_uInt16>( mvBlibEntrys.size() << 4 ) )
4255 .WriteUInt32( 0 );
4256 nAtomSize = rPicOutStrm.Tell();
4257 if ( eBlibType == PNG )
4258 rPicOutStrm.WriteUInt16( 0x0606 );
4259 else if ( eBlibType == WMF )
4260 rPicOutStrm.WriteUInt16( 0x0403 );
4261 else if ( eBlibType == EMF )
4262 rPicOutStrm.WriteUInt16( 0x0402 );
4263 else if ( eBlibType == PEG )
4264 rPicOutStrm.WriteUInt16( 0x0505 );
4265 }
4266
4267 // fdo#69607 do not compress WMF files if we are in OOXML export
4268 if ( ( eBlibType == PEG ) || ( eBlibType == PNG ) // || ( eBlibType == DIB )) // #i15508#
4269 || ( ( ( eBlibType == WMF ) || ( eBlibType == EMF ) ) && bOOxmlExport ) )
4270 {
4271 nExtra = 17;
4272 p_EscherBlibEntry->mnSizeExtra = nExtra + 8;
4273
4274 // #i15508# type see SvxMSDffManager::GetBLIPDirect (checked, does not work this way)
4275 // see RtfAttributeOutput::FlyFrameGraphic for more comments
4276 // maybe it would work with direct DIB data, but that would need thorough testing
4277 if( eBlibType == PNG )
4278 {
4279 nInstance = 0xf01e6e00;
4280 }
4281 else // if( eBlibType == PEG )
4282 {
4283 nInstance = 0xf01d46a0;
4284 }
4285 //else // eBlibType == DIB
4286 //{
4287 // nInstance = 0xf01d7A80;
4288 //}
4289
4290 // #i15508#
4291 //nInstance = ( eBlibType == PNG ) ? 0xf01e6e00 : 0xf01d46a0;
4292
4293
4294 rPicOutStrm.WriteUInt32( nInstance ).WriteUInt32( p_EscherBlibEntry->mnSize + nExtra );
4295 rPicOutStrm.WriteBytes(p_EscherBlibEntry->mnIdentifier, 16);
4296 rPicOutStrm.WriteUChar( 0xff );
4297 rPicOutStrm.WriteBytes(pGraphicAry, p_EscherBlibEntry->mnSize);
4298 }
4299 else
4300 {
4301 ZCodec aZCodec( 0x8000, 0x8000 );
4302 aZCodec.BeginCompression();
4303 SvMemoryStream aDestStrm;
4304 aZCodec.Write( aDestStrm, pGraphicAry, p_EscherBlibEntry->mnSize );
4305 aZCodec.EndCompression();
4306 p_EscherBlibEntry->mnSize = aDestStrm.TellEnd();
4307 pGraphicAry = static_cast<sal_uInt8 const *>(aDestStrm.GetData());
4308 if ( p_EscherBlibEntry->mnSize && pGraphicAry )
4309 {
4310 nExtra = eBlibType == WMF ? 0x42 : 0x32; // !EMF -> no change
4311 p_EscherBlibEntry->mnSizeExtra = nExtra + 8;
4312 nInstance = ( eBlibType == WMF ) ? 0xf01b2170 : 0xf01a3d40; // !EMF -> no change
4313 rPicOutStrm.WriteUInt32( nInstance ).WriteUInt32( p_EscherBlibEntry->mnSize + nExtra );
4314 if ( eBlibType == WMF ) // !EMF -> no change
4315 rPicOutStrm.WriteBytes(p_EscherBlibEntry->mnIdentifier, 16);
4316 rPicOutStrm.WriteBytes(p_EscherBlibEntry->mnIdentifier, 16);
4317
4318 /*
4319 ##913##
4320 For Word the stored size of the graphic is critical the
4321 metafile boundaries must match the actual graphics
4322 boundaries, and the width and height must be in EMU's
4323
4324 If you don't do it this way then objects edited in the
4325 msoffice app may show strange behaviour as the size jumps
4326 around, and the original size and scaling factor in word
4327 will be a very strange figure
4328 */
4329 sal_uInt32 nPrefWidth = p_EscherBlibEntry->maPrefSize.Width();
4330 sal_uInt32 nPrefHeight = p_EscherBlibEntry->maPrefSize.Height();
4331 sal_uInt32 nWidth, nHeight;
4332 if ( pVisArea )
4333 {
4334 nWidth = pVisArea->Width * 360;
4335 nHeight = pVisArea->Height * 360;
4336 }
4337 else
4338 {
4339 Size aPrefSize(lcl_SizeToEmu(p_EscherBlibEntry->maPrefSize, p_EscherBlibEntry->maPrefMapMode));
4340 nWidth = aPrefSize.Width() * 360;
4341 nHeight = aPrefSize.Height() * 360;
4342 }
4343 rPicOutStrm.WriteUInt32( nUncompressedSize ) // WMFSize without FileHeader
4344 .WriteInt32( 0 ) // since we can't find out anymore what the original size of
4345 .WriteInt32( 0 ) // the WMF (without Fileheader) was we write 10cm / x
4346 .WriteUInt32( nPrefWidth )
4347 .WriteUInt32( nPrefHeight )
4348 .WriteUInt32( nWidth )
4349 .WriteUInt32( nHeight )
4350 .WriteUInt32( p_EscherBlibEntry->mnSize )
4351 .WriteUInt16( 0xfe00 ); // compression Flags
4352 rPicOutStrm.WriteBytes(pGraphicAry, p_EscherBlibEntry->mnSize);
4353 }
4354 }
4355 if ( nAtomSize )
4356 {
4357 sal_uInt64 nPos = rPicOutStrm.Tell();
4358 rPicOutStrm.Seek( nAtomSize - 4 );
4359 rPicOutStrm.WriteUInt32( nPos - nAtomSize );
4360 rPicOutStrm.Seek( nPos );
4361 }
4362 nBlibId = ImplInsertBlib( p_EscherBlibEntry.release() );
4363 }
4364 }
4365 return nBlibId;
4366 }
4367
4368 namespace {
4369
4370 struct EscherConnectorRule
4371 {
4372 sal_uInt32 nRuleId;
4373 sal_uInt32 nShapeA; // SPID of shape A
4374 sal_uInt32 nShapeB; // SPID of shape B
4375 sal_uInt32 nShapeC; // SPID of connector shape
4376 sal_uInt32 ncptiA; // Connection site Index of shape A
4377 sal_uInt32 ncptiB; // Connection site Index of shape B
4378 };
4379
4380 }
4381
4382 struct EscherShapeListEntry
4383 {
4384 uno::Reference<drawing::XShape>aXShape;
4385 sal_uInt32 n_EscherId;
4386
4387 EscherShapeListEntry(uno::Reference<drawing::XShape> xShape, sal_uInt32 nId)
4388 : aXShape(std::move(xShape))
4389 , n_EscherId(nId)
4390 {}
4391 };
4392
4393 sal_uInt32 EscherConnectorListEntry::GetClosestPoint( const tools::Polygon& rPoly, const awt::Point& rPoint )
4394 {
4395 sal_uInt16 nCount = rPoly.GetSize();
4396 sal_uInt16 nClosest = nCount;
4397 double fDist = sal_uInt32(0xffffffff);
4398 while( nCount-- )
4399 {
4400 double fDistance = hypot( rPoint.X - rPoly[ nCount ].X(), rPoint.Y - rPoly[ nCount ].Y() );
4401 if ( fDistance < fDist )
4402 {
4403 nClosest = nCount;
4404 fDist = fDistance;
4405 }
4406 }
4407 return nClosest;
4408 };
4409
4410
4411 // for rectangles for ellipses for polygons
4412 //
4413 // nRule = 0 ->Top 0 ->Top nRule = index to a (Poly)Polygon point
4414 // 1 ->Left 2 ->Left
4415 // 2 ->Bottom 4 ->Bottom
4416 // 3 ->Right 6 ->Right
4417
4418 sal_uInt32 EscherConnectorListEntry::GetConnectorRule( bool bFirst )
4419 {
4420 sal_uInt32 nRule = 0;
4421
4422 uno::Any aAny;
4423 awt::Point aRefPoint( bFirst ? maPointA : maPointB );
4424 uno::Reference<drawing::XShape>
4425 aXShape( bFirst ? mXConnectToA : mXConnectToB );
4426
4427 OUString aString(aXShape->getShapeType());
4428 OStringBuffer aBuf(OUStringToOString(aString, RTL_TEXTENCODING_UTF8));
4429 aBuf.remove( 0, 13 ); // removing "com.sun.star."
4430 sal_Int16 nPos = aBuf.toString().indexOf("Shape");
4431 aBuf.remove(nPos, 5);
4432 OString aType = aBuf.makeStringAndClear();
4433
4434 uno::Reference<beans::XPropertySet>
4435 aPropertySet( aXShape, uno::UNO_QUERY );
4436
4437 if ((aType == "drawing.PolyPolygon") || (aType == "drawing.PolyLine"))
4438 {
4439 if ( aPropertySet.is() )
4440 {
4441 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aPropertySet, u"PolyPolygon"_ustr ) )
4442 {
4443 auto pSourcePolyPolygon =
4444 o3tl::doAccess<drawing::PointSequenceSequence>(aAny);
4445 sal_Int32 nOuterSequenceCount = pSourcePolyPolygon->getLength();
4446 drawing::PointSequence const * pOuterSequence = pSourcePolyPolygon->getConstArray();
4447
4448 if ( pOuterSequence )
4449 {
4450 sal_Int32 a, b, nIndex = 0;
4451 sal_uInt32 nDistance = 0xffffffff;
4452 for( a = 0; a < nOuterSequenceCount; a++ )
4453 {
4454 drawing::PointSequence const * pInnerSequence = pOuterSequence++;
4455 if ( pInnerSequence )
4456 {
4457 awt::Point const * pArray = pInnerSequence->getConstArray();
4458 if ( pArray )
4459 {
4460 for ( b = 0; b < pInnerSequence->getLength(); b++, nIndex++, pArray++ )
4461 {
4462 sal_uInt32 nDist = static_cast<sal_uInt32>(hypot( aRefPoint.X - pArray->X, aRefPoint.Y - pArray->Y ));
4463 if ( nDist < nDistance )
4464 {
4465 nRule = nIndex;
4466 nDistance = nDist;
4467 }
4468 }
4469 }
4470 }
4471 }
4472 }
4473 }
4474 }
4475 }
4476 else if ((aType == "drawing.OpenBezier") || (aType == "drawing.OpenFreeHand") || (aType == "drawing.PolyLinePath")
4477 || (aType == "drawing.ClosedBezier") || ( aType == "drawing.ClosedFreeHand") || (aType == "drawing.PolyPolygonPath") )
4478 {
4479 uno::Reference<beans::XPropertySet>
4480 aPropertySet2( aXShape, uno::UNO_QUERY );
4481 if ( aPropertySet2.is() )
4482 {
4483 if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aPropertySet2, u"PolyPolygonBezier"_ustr ) )
4484 {
4485 auto pSourcePolyPolygon =
4486 o3tl::doAccess<drawing::PolyPolygonBezierCoords>(aAny);
4487 sal_Int32 nOuterSequenceCount = pSourcePolyPolygon->Coordinates.getLength();
4488
4489 // get pointer of inner sequences
4490 drawing::PointSequence const * pOuterSequence =
4491 pSourcePolyPolygon->Coordinates.getConstArray();
4492 drawing::FlagSequence const * pOuterFlags =
4493 pSourcePolyPolygon->Flags.getConstArray();
4494
4495 if ( pOuterSequence && pOuterFlags )
4496 {
4497 sal_Int32 a, b, nIndex = 0;
4498 sal_uInt32 nDistance = 0xffffffff;
4499
4500 for ( a = 0; a < nOuterSequenceCount; a++ )
4501 {
4502 drawing::PointSequence const * pInnerSequence = pOuterSequence++;
4503 drawing::FlagSequence const * pInnerFlags = pOuterFlags++;
4504 if ( pInnerSequence && pInnerFlags )
4505 {
4506 awt::Point const * pArray = pInnerSequence->getConstArray();
4507 drawing::PolygonFlags const * pFlags = pInnerFlags->getConstArray();
4508 if ( pArray && pFlags )
4509 {
4510 for ( b = 0; b < pInnerSequence->getLength(); b++, pArray++ )
4511 {
4512 drawing::PolygonFlags ePolyFlags = *pFlags++;
4513 if ( ePolyFlags == drawing::PolygonFlags_CONTROL )
4514 continue;
4515 sal_uInt32 nDist = static_cast<sal_uInt32>(hypot( aRefPoint.X - pArray->X, aRefPoint.Y - pArray->Y ));
4516 if ( nDist < nDistance )
4517 {
4518 nRule = nIndex;
4519 nDistance = nDist;
4520 }
4521 nIndex++;
4522 }
4523 }
4524 }
4525 }
4526 }
4527 }
4528 }
4529 }
4530 else
4531 {
4532 bool bRectangularConnection = true;
4533
4534 if (aType == "drawing.Custom")
4535 {
4536 if (auto pSdrObjCustomShape = dynamic_cast< SdrObjCustomShape* >(SdrObject::getSdrObjectFromXShape(aXShape)))
4537 {
4538 const SdrCustomShapeGeometryItem& rGeometryItem =
4539 pSdrObjCustomShape->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
4540
4541 OUString sShapeType;
4542 const uno::Any* pType = rGeometryItem.GetPropertyValueByName( u"Type"_ustr );
4543 if ( pType )
4544 *pType >>= sShapeType;
4545 MSO_SPT eSpType = EnhancedCustomShapeTypeNames::Get( sShapeType );
4546
4547 const uno::Any* pGluePointType = rGeometryItem.GetPropertyValueByName( u"Path"_ustr, u"GluePointType"_ustr );
4548
4549 sal_Int16 nGluePointType = sal_Int16();
4550 if ( !( pGluePointType &&
4551 ( *pGluePointType >>= nGluePointType ) ) )
4552 nGluePointType = GetCustomShapeConnectionTypeDefault( eSpType );
4553
4554 if ( nGluePointType == drawing::EnhancedCustomShapeGluePointType::CUSTOM )
4555 {
4556 const SdrGluePointList* pList = pSdrObjCustomShape->GetGluePointList();
4557 if ( pList )
4558 {
4559 tools::Polygon aPoly;
4560 sal_uInt16 nNum, nCnt = pList->GetCount();
4561 if ( nCnt )
4562 {
4563 for ( nNum = 0; nNum < nCnt; nNum++ )
4564 {
4565 const SdrGluePoint& rGP = (*pList)[ nNum ];
4566 Point aPt(rGP.GetAbsolutePos(*pSdrObjCustomShape));
4567 aPoly.Insert( POLY_APPEND, aPt );
4568 }
4569 nRule = GetClosestPoint( aPoly, aRefPoint );
4570 bRectangularConnection = false;
4571 }
4572 }
4573 }
4574 else if ( nGluePointType == drawing::EnhancedCustomShapeGluePointType::SEGMENTS )
4575 {
4576 tools::PolyPolygon aPolyPoly;
4577 rtl::Reference<SdrObject> pTemporaryConvertResultObject(pSdrObjCustomShape->DoConvertToPolyObj(true, true));
4578 SdrPathObj* pSdrPathObj(dynamic_cast< SdrPathObj* >(pTemporaryConvertResultObject.get()));
4579
4580 if(pSdrPathObj)
4581 {
4582 // #i74631# use explicit constructor here. Also XPolyPolygon is not necessary,
4583 // reducing to PolyPolygon
4584 aPolyPoly = tools::PolyPolygon(pSdrPathObj->GetPathPoly());
4585 }
4586
4587 // do *not* forget to delete the temporary used SdrObject - possible memory leak (!)
4588 pTemporaryConvertResultObject.clear();
4589 pSdrPathObj = nullptr;
4590
4591 if(0 != aPolyPoly.Count())
4592 {
4593 sal_Int16 nIndex = 0;
4594 sal_uInt16 a, b;
4595 sal_uInt32 nDistance = 0xffffffff;
4596
4597 for ( a = 0; a < aPolyPoly.Count(); a++ )
4598 {
4599 const tools::Polygon& rPoly = aPolyPoly.GetObject( a );
4600 for ( b = 0; b < rPoly.GetSize(); b++ )
4601 {
4602 if ( rPoly.GetFlags( b ) != PolyFlags::Normal )
4603 continue;
4604 const Point& rPt = rPoly[ b ];
4605 sal_uInt32 nDist = static_cast<sal_uInt32>(hypot( aRefPoint.X - rPt.X(), aRefPoint.Y - rPt.Y() ));
4606 if ( nDist < nDistance )
4607 {
4608 nRule = nIndex;
4609 nDistance = nDist;
4610 }
4611 nIndex++;
4612 }
4613 }
4614
4615 if ( nDistance != 0xffffffff )
4616 bRectangularConnection = false;
4617 }
4618 }
4619 }
4620 }
4621 if ( bRectangularConnection )
4622 {
4623 awt::Point aPoint( aXShape->getPosition() );
4624 awt::Size aSize( aXShape->getSize() );
4625
4626 tools::Rectangle aRect( Point( aPoint.X, aPoint.Y ), Size( aSize.Width, aSize.Height ) );
4627 Point aCenter( aRect.Center() );
4628 tools::Polygon aPoly( 4 );
4629
4630 aPoly[ 0 ] = Point( aCenter.X(), aRect.Top() );
4631 aPoly[ 1 ] = Point( aRect.Left(), aCenter.Y() );
4632 aPoly[ 2 ] = Point( aCenter.X(), aRect.Bottom() );
4633 aPoly[ 3 ] = Point( aRect.Right(), aCenter.Y() );
4634
4635 sal_Int32 nAngle = ( EscherPropertyValueHelper::GetPropertyValue( aAny, aPropertySet, u"RotateAngle"_ustr, true ) )
4636 ? *o3tl::doAccess<sal_Int32>(aAny) : 0;
4637 if ( nAngle )
4638 aPoly.Rotate( aRect.TopLeft(), Degree10(static_cast<sal_Int16>( ( nAngle + 5 ) / 10 )) );
4639 nRule = GetClosestPoint( aPoly, aRefPoint );
4640
4641 if (aType == "drawing.Ellipse")
4642 nRule <<= 1; // In PPT an ellipse has 8 ways to connect
4643 }
4644 }
4645 return nRule;
4646 }
4647
4648 EscherSolverContainer::EscherSolverContainer()
4649 {
4650 }
4651
4652 EscherSolverContainer::~EscherSolverContainer()
4653 {
4654 }
4655
4656 void EscherSolverContainer::AddShape( const uno::Reference<drawing::XShape> & rXShape, sal_uInt32 nId )
4657 {
4658 maShapeList.push_back( std::make_unique<EscherShapeListEntry>( rXShape, nId ) );
4659 }
4660
4661 void EscherSolverContainer::AddConnector(
4662 const uno::Reference<drawing::XShape> & rConnector,
4663 const awt::Point& rPA,
4664 uno::Reference<drawing::XShape> const & rConA,
4665 const awt::Point& rPB,
4666 uno::Reference<drawing::XShape> const & rConB
4667 )
4668 {
4669 maConnectorList.push_back( std::make_unique<EscherConnectorListEntry>( rConnector, rPA, rConA, rPB, rConB ) );
4670 }
4671
4672 sal_uInt32 EscherSolverContainer::GetShapeId( const uno::Reference<drawing::XShape> & rXShape ) const
4673 {
4674 for (auto const & pPtr : maShapeList)
4675 {
4676 if ( rXShape == pPtr->aXShape )
4677 return pPtr->n_EscherId;
4678 }
4679 return 0;
4680 }
4681
4682 void EscherSolverContainer::WriteSolver( SvStream& rStrm )
4683 {
4684 sal_uInt32 nCount = maConnectorList.size();
4685 if ( !nCount )
4686 return;
4687
4688 sal_uInt32 nRecHdPos, nCurrentPos, nSize;
4689 rStrm .WriteUInt16( ( nCount << 4 ) | 0xf ) // open an ESCHER_SolverContainer
4690 .WriteUInt16( ESCHER_SolverContainer )
4691 .WriteUInt32( 0 );
4692
4693 nRecHdPos = rStrm.Tell() - 4;
4694
4695 EscherConnectorRule aConnectorRule;
4696 aConnectorRule.nRuleId = 2;
4697 for (auto const & pPtr : maConnectorList)
4698 {
4699 aConnectorRule.ncptiA = aConnectorRule.ncptiB = 0xffffffff;
4700 aConnectorRule.nShapeC = GetShapeId( pPtr->mXConnector );
4701 aConnectorRule.nShapeA = GetShapeId( pPtr->mXConnectToA );
4702 aConnectorRule.nShapeB = GetShapeId( pPtr->mXConnectToB );
4703
4704 if ( aConnectorRule.nShapeC )
4705 {
4706 if ( aConnectorRule.nShapeA )
4707 aConnectorRule.ncptiA = pPtr->GetConnectorRule( true );
4708 if ( aConnectorRule.nShapeB )
4709 aConnectorRule.ncptiB = pPtr->GetConnectorRule( false );
4710 }
4711 rStrm .WriteUInt32( ( ESCHER_ConnectorRule << 16 ) | 1 ) // atom hd
4712 .WriteUInt32( 24 )
4713 .WriteUInt32( aConnectorRule.nRuleId )
4714 .WriteUInt32( aConnectorRule.nShapeA )
4715 .WriteUInt32( aConnectorRule.nShapeB )
4716 .WriteUInt32( aConnectorRule.nShapeC )
4717 .WriteUInt32( aConnectorRule.ncptiA )
4718 .WriteUInt32( aConnectorRule.ncptiB );
4719
4720 aConnectorRule.nRuleId += 2;
4721 }
4722
4723 nCurrentPos = rStrm.Tell(); // close the ESCHER_SolverContainer
4724 nSize = ( nCurrentPos - nRecHdPos ) - 4;
4725 rStrm.Seek( nRecHdPos );
4726 rStrm.WriteUInt32( nSize );
4727 rStrm.Seek( nCurrentPos );
4728 }
4729
4730 EscherExGlobal::EscherExGlobal() :
4731 EscherGraphicProvider( EscherGraphicProviderFlags::NONE ),
4732 mpPicStrm( nullptr ),
4733 mbHasDggCont( false ),
4734 mbPicStrmQueried( false )
4735 {
4736 }
4737
4738 EscherExGlobal::~EscherExGlobal()
4739 {
4740 }
4741
4742 sal_uInt32 EscherExGlobal::GenerateDrawingId()
4743 {
4744 // new drawing starts a new cluster in the cluster table (cluster identifiers are one-based)
4745 sal_uInt32 nClusterId = static_cast< sal_uInt32 >( maClusterTable.size() + 1 );
4746 // drawing identifiers are one-based
4747 sal_uInt32 nDrawingId = static_cast< sal_uInt32 >( maDrawingInfos.size() + 1 );
4748 // prepare new entries in the tables
4749 maClusterTable.emplace_back( nDrawingId );
4750 maDrawingInfos.emplace_back( nClusterId );
4751 // return the new drawing identifier
4752 return nDrawingId;
4753 }
4754
4755 sal_uInt32 EscherExGlobal::GenerateShapeId( sal_uInt32 nDrawingId, bool bIsInSpgr )
4756 {
4757 // drawing identifier is one-based
4758 // make sure the drawing is valid (bnc#656503)
4759 if ( nDrawingId == 0 )
4760 return 0;
4761 // create index from the identifier
4762 size_t nDrawingIdx = nDrawingId - 1;
4763 OSL_ENSURE( nDrawingIdx < maDrawingInfos.size(), "EscherExGlobal::GenerateShapeId - invalid drawing ID" );
4764 if( nDrawingIdx >= maDrawingInfos.size() )
4765 return 0;
4766 DrawingInfo& rDrawingInfo = maDrawingInfos[ nDrawingIdx ];
4767
4768 // cluster identifier in drawing info struct is one-based
4769 ClusterEntry* pClusterEntry = &maClusterTable[ rDrawingInfo.mnClusterId - 1 ];
4770
4771 // check cluster overflow, create new cluster entry
4772 if( pClusterEntry->mnNextShapeId == DFF_DGG_CLUSTER_SIZE )
4773 {
4774 // start a new cluster in the cluster table
4775 maClusterTable.emplace_back( nDrawingId );
4776 pClusterEntry = &maClusterTable.back();
4777 // new size of maClusterTable is equal to one-based identifier of the new cluster
4778 rDrawingInfo.mnClusterId = static_cast< sal_uInt32 >( maClusterTable.size() );
4779 }
4780
4781 // build shape identifier from cluster identifier and next free cluster shape identifier
4782 rDrawingInfo.mnLastShapeId = static_cast< sal_uInt32 >( rDrawingInfo.mnClusterId * DFF_DGG_CLUSTER_SIZE + pClusterEntry->mnNextShapeId );
4783 // update free shape identifier in cluster entry
4784 ++pClusterEntry->mnNextShapeId;
4785 /* Old code has counted the shapes only, if we are in a SPGRCONTAINER. Is
4786 this really intended? Maybe it's always true... */
4787 if( bIsInSpgr )
4788 ++rDrawingInfo.mnShapeCount;
4789
4790 // return the new shape identifier
4791 return rDrawingInfo.mnLastShapeId;
4792 }
4793
4794 sal_uInt32 EscherExGlobal::GetDrawingShapeCount( sal_uInt32 nDrawingId ) const
4795 {
4796 size_t nDrawingIdx = nDrawingId - 1;
4797 OSL_ENSURE( nDrawingIdx < maDrawingInfos.size(), "EscherExGlobal::GetDrawingShapeCount - invalid drawing ID" );
4798 return (nDrawingIdx < maDrawingInfos.size()) ? maDrawingInfos[ nDrawingIdx ].mnShapeCount : 0;
4799 }
4800
4801 sal_uInt32 EscherExGlobal::GetLastShapeId( sal_uInt32 nDrawingId ) const
4802 {
4803 size_t nDrawingIdx = nDrawingId - 1;
4804 OSL_ENSURE( nDrawingIdx < maDrawingInfos.size(), "EscherExGlobal::GetLastShapeId - invalid drawing ID" );
4805 return (nDrawingIdx < maDrawingInfos.size()) ? maDrawingInfos[ nDrawingIdx ].mnLastShapeId : 0;
4806 }
4807
4808 sal_uInt32 EscherExGlobal::GetDggAtomSize() const
4809 {
4810 // 8 bytes header, 16 bytes fixed DGG data, 8 bytes for each cluster
4811 return static_cast< sal_uInt32 >( 24 + 8 * maClusterTable.size() );
4812 }
4813
4814 void EscherExGlobal::WriteDggAtom( SvStream& rStrm ) const
4815 {
4816 sal_uInt32 nDggSize = GetDggAtomSize();
4817
4818 // write the DGG record header (do not include the 8 bytes of the header in the data size)
4819 rStrm.WriteUInt32( ESCHER_Dgg << 16 ).WriteUInt32( nDggSize - 8 );
4820
4821 // calculate and write the fixed DGG data
4822 sal_uInt32 nShapeCount = 0;
4823 sal_uInt32 nLastShapeId = 0;
4824 for (auto const& drawingInfo : maDrawingInfos)
4825 {
4826 nShapeCount += drawingInfo.mnShapeCount;
4827 nLastShapeId = ::std::max( nLastShapeId, drawingInfo.mnLastShapeId );
4828 }
4829 // the non-existing cluster with index #0 is counted too
4830 sal_uInt32 nClusterCount = static_cast< sal_uInt32 >( maClusterTable.size() + 1 );
4831 sal_uInt32 nDrawingCount = static_cast< sal_uInt32 >( maDrawingInfos.size() );
4832 rStrm.WriteUInt32( nLastShapeId ).WriteUInt32( nClusterCount ).WriteUInt32( nShapeCount ).WriteUInt32( nDrawingCount );
4833
4834 // write the cluster table
4835 for (auto const& elem : maClusterTable)
4836 rStrm.WriteUInt32( elem.mnDrawingId ).WriteUInt32( elem.mnNextShapeId );
4837 }
4838
4839 SvStream* EscherExGlobal::QueryPictureStream()
4840 {
4841 if( !mbPicStrmQueried )
4842 {
4843 mpPicStrm = ImplQueryPictureStream();
4844 mbPicStrmQueried = true;
4845 }
4846 return mpPicStrm;
4847 }
4848
4849 SvStream* EscherExGlobal::ImplQueryPictureStream()
4850 {
4851 return nullptr;
4852 }
4853
4854 namespace {
4855
4856 // Implementation of an empty stream that silently succeeds, but does nothing.
4857 //
4858 // In fact, this is a hack. The right solution is to abstract EscherEx to be
4859 // able to work without SvStream; but at the moment it is better to live with
4860 // this I guess.
4861 class SvNullStream : public SvStream
4862 {
4863 protected:
4864 virtual std::size_t GetData( void* pData, std::size_t nSize ) override { memset( pData, 0, nSize ); return nSize; }
4865 virtual std::size_t PutData( const void*, std::size_t nSize ) override { return nSize; }
4866 virtual sal_uInt64 SeekPos( sal_uInt64 nPos ) override { return nPos; }
4867 virtual void SetSize( sal_uInt64 ) override {}
4868 virtual void FlushData() override {}
4869
4870 public:
4871 SvNullStream() {}
4872 };
4873
4874 }
4875
4876 EscherEx::EscherEx(std::shared_ptr<EscherExGlobal> xGlobal, SvStream* pOutStrm, bool bOOXML)
4877 : mxGlobal(std::move(xGlobal))
4878 , mpOutStrm(pOutStrm)
4879 , mnCurrentDg(0)
4880 , mnCountOfs(0)
4881 , mnGroupLevel(0)
4882 , mnHellLayerId(SDRLAYER_NOTFOUND)
4883 , mnHeaderFooterHellLayerId(SDRLAYER_NOTFOUND)
4884 , mbEscherSpgr(false)
4885 , mbEscherDg(false)
4886 , mbOOXML(bOOXML)
4887 {
4888 if (!mpOutStrm)
4889 {
4890 mxOwnStrm = std::make_unique<SvNullStream>();
4891 mpOutStrm = mxOwnStrm.get();
4892 }
4893 mnStrmStartOfs = mpOutStrm->Tell();
4894 mpImplEESdrWriter.reset( new ImplEESdrWriter( *this ) );
4895 }
4896
4897 EscherEx::~EscherEx()
4898 {
4899 }
4900
4901 void EscherEx::Flush( SvStream* pPicStreamMergeBSE /* = NULL */ )
4902 {
4903 if ( !mxGlobal->HasDggContainer() )
4904 return;
4905
4906 // store the current stream position at ESCHER_Persist_CurrentPosition key
4907 PtReplaceOrInsert( ESCHER_Persist_CurrentPosition, mpOutStrm->Tell() );
4908 if ( DoSeek( ESCHER_Persist_Dgg ) )
4909 {
4910 /* The DGG record is still not written. ESCHER_Persist_Dgg seeks
4911 to the place where the complete record has to be inserted. */
4912 InsertAtCurrentPos( mxGlobal->GetDggAtomSize() );
4913 mxGlobal->WriteDggAtom( *mpOutStrm );
4914
4915 if ( mxGlobal->HasGraphics() )
4916 {
4917 /* Calculate the total size of the BSTORECONTAINER including
4918 all BSE records containing the picture data contained in
4919 the passed in pPicStreamMergeBSE. */
4920 sal_uInt32 nBSCSize = mxGlobal->GetBlibStoreContainerSize( pPicStreamMergeBSE );
4921 if ( nBSCSize > 0 )
4922 {
4923 InsertAtCurrentPos( nBSCSize );
4924 mxGlobal->WriteBlibStoreContainer( *mpOutStrm, pPicStreamMergeBSE );
4925 }
4926 }
4927
4928 /* Forget the stream position stored for the DGG which is invalid
4929 after the call to InsertAtCurrentPos() anyway. */
4930 PtDelete( ESCHER_Persist_Dgg );
4931 }
4932 // seek to initial position (may be different due to inserted DGG and BLIPs)
4933 mpOutStrm->Seek( PtGetOffsetByID( ESCHER_Persist_CurrentPosition ) );
4934 }
4935
4936 void EscherEx::InsertAtCurrentPos( sal_uInt32 nBytes )
4937 {
4938 sal_uInt32 nSize, nType, nSource, nBufSize, nToCopy;
4939 sal_uInt64 nCurPos = mpOutStrm->Tell();
4940
4941 // adjust persist table
4942 for(auto const & pPtr : maPersistTable) {
4943 sal_uInt32 nOfs = pPtr->mnOffset;
4944 if ( nOfs >= nCurPos ) {
4945 pPtr->mnOffset += nBytes;
4946 }
4947 }
4948
4949 // adapt container and atom sizes
4950 mpOutStrm->Seek( mnStrmStartOfs );
4951 while ( mpOutStrm->Tell() < nCurPos )
4952 {
4953 mpOutStrm->ReadUInt32( nType ).ReadUInt32( nSize );
4954 sal_uInt64 nEndOfRecord = mpOutStrm->Tell() + nSize;
4955 bool bContainer = (nType & 0x0F) == 0x0F;
4956 /* Expand the record, if the insertion position is inside, or if the
4957 position is at the end of a container (expands always), or at the
4958 end of an atom and bExpandEndOfAtom is set. */
4959 if ( (nCurPos < nEndOfRecord) || ((nCurPos == nEndOfRecord) && bContainer) )
4960 {
4961 mpOutStrm->SeekRel( -4 );
4962 mpOutStrm->WriteUInt32( nSize + nBytes );
4963 if ( !bContainer )
4964 mpOutStrm->SeekRel( nSize );
4965 }
4966 else
4967 mpOutStrm->SeekRel( nSize );
4968 }
4969 for (auto & offset : mOffsets)
4970 {
4971 if ( offset > nCurPos )
4972 offset += nBytes;
4973 }
4974 nSource = mpOutStrm->TellEnd();
4975 nToCopy = nSource - nCurPos; // increase the size of the stream by nBytes
4976 std::unique_ptr<sal_uInt8[]> pBuf(new sal_uInt8[ 0x40000 ]); // 256KB Buffer
4977 while ( nToCopy )
4978 {
4979 nBufSize = ( nToCopy >= 0x40000 ) ? 0x40000 : nToCopy;
4980 nToCopy -= nBufSize;
4981 nSource -= nBufSize;
4982 mpOutStrm->Seek( nSource );
4983 mpOutStrm->ReadBytes(pBuf.get(), nBufSize);
4984 mpOutStrm->Seek( nSource + nBytes );
4985 mpOutStrm->WriteBytes(pBuf.get(), nBufSize);
4986 }
4987 mpOutStrm->Seek( nCurPos );
4988 }
4989
4990 void EscherEx::InsertPersistOffset( sal_uInt32 nKey, sal_uInt32 nOffset )
4991 {
4992 PtInsert( ESCHER_Persist_PrivateEntry | nKey, nOffset );
4993 }
4994
4995 void EscherEx::ReplacePersistOffset( sal_uInt32 nKey, sal_uInt32 nOffset )
4996 {
4997 PtReplace( ESCHER_Persist_PrivateEntry | nKey, nOffset );
4998 }
4999
5000 void EscherEx::SetEditAs( const OUString& rEditAs )
5001 {
5002 mEditAs = rEditAs;
5003 }
5004
5005 sal_uInt32 EscherEx::GetPersistOffset( sal_uInt32 nKey )
5006 {
5007 return PtGetOffsetByID( ESCHER_Persist_PrivateEntry | nKey );
5008 }
5009
5010 bool EscherEx::DoSeek( sal_uInt32 nKey )
5011 {
5012 sal_uInt32 nPos = PtGetOffsetByID( nKey );
5013 if ( nPos )
5014 mpOutStrm->Seek( nPos );
5015 else
5016 {
5017 if (! PtIsID( nKey ) )
5018 return false;
5019 mpOutStrm->Seek( 0 );
5020 }
5021 return true;
5022 }
5023
5024 bool EscherEx::SeekToPersistOffset( sal_uInt32 nKey )
5025 {
5026 return DoSeek( ESCHER_Persist_PrivateEntry | nKey );
5027 }
5028
5029 void EscherEx::InsertAtPersistOffset( sal_uInt32 nKey, sal_uInt32 nValue )
5030 {
5031 sal_uInt64 nOldPos = mpOutStrm->Tell();
5032 bool bRetValue = SeekToPersistOffset( nKey );
5033 if ( bRetValue )
5034 {
5035 mpOutStrm->WriteUInt32( nValue );
5036 mpOutStrm->Seek( nOldPos );
5037 }
5038 }
5039
5040 void EscherEx::OpenContainer( sal_uInt16 nEscherContainer, int nRecInstance )
5041 {
5042 mpOutStrm->WriteUInt16( ( nRecInstance << 4 ) | 0xf ).WriteUInt16( nEscherContainer ).WriteUInt32( 0 );
5043 mOffsets.push_back( mpOutStrm->Tell() - 4 );
5044 mRecTypes.push_back( nEscherContainer );
5045 switch( nEscherContainer )
5046 {
5047 case ESCHER_DggContainer :
5048 {
5049 mxGlobal->SetDggContainer();
5050 mnCurrentDg = 0;
5051 /* Remember the current position as start position of the DGG
5052 record and BSTORECONTAINER, but do not write them actually.
5053 This will be done later in Flush() when the number of drawings,
5054 the size and contents of the FIDCL cluster table, and the size
5055 of the BLIP container are known. */
5056 PtReplaceOrInsert( ESCHER_Persist_Dgg, mpOutStrm->Tell() );
5057 }
5058 break;
5059
5060 case ESCHER_DgContainer :
5061 {
5062 if ( mxGlobal->HasDggContainer() )
5063 {
5064 if ( !mbEscherDg )
5065 {
5066 mbEscherDg = true;
5067 mnCurrentDg = mxGlobal->GenerateDrawingId();
5068 AddAtom( 8, ESCHER_Dg, 0, mnCurrentDg );
5069 PtReplaceOrInsert( ESCHER_Persist_Dg | mnCurrentDg, mpOutStrm->Tell() );
5070 mpOutStrm->WriteUInt32( 0 ) // The number of shapes in this drawing
5071 .WriteUInt32( 0 ); // The last MSOSPID given to an SP in this DG
5072 }
5073 }
5074 }
5075 break;
5076
5077 case ESCHER_SpgrContainer :
5078 {
5079 if ( mbEscherDg )
5080 {
5081 mbEscherSpgr = true;
5082 }
5083 }
5084 break;
5085
5086 case ESCHER_SpContainer :
5087 {
5088 }
5089 break;
5090
5091 default:
5092 break;
5093 }
5094 }
5095
5096 void EscherEx::CloseContainer()
5097 {
5098 sal_uInt64 nPos = mpOutStrm->Tell();
5099 sal_uInt32 nSize = ( nPos - mOffsets.back() ) - 4;
5100 mpOutStrm->Seek( mOffsets.back() );
5101 mpOutStrm->WriteUInt32( nSize );
5102
5103 switch( mRecTypes.back() )
5104 {
5105 case ESCHER_DgContainer :
5106 {
5107 if ( mbEscherDg )
5108 {
5109 mbEscherDg = false;
5110 if ( DoSeek( ESCHER_Persist_Dg | mnCurrentDg ) )
5111 mpOutStrm->WriteUInt32( mxGlobal->GetDrawingShapeCount( mnCurrentDg ) ).WriteUInt32( mxGlobal->GetLastShapeId( mnCurrentDg ) );
5112 }
5113 }
5114 break;
5115
5116 case ESCHER_SpgrContainer :
5117 {
5118 if ( mbEscherSpgr )
5119 {
5120 mbEscherSpgr = false;
5121
5122 }
5123 }
5124 break;
5125
5126 default:
5127 break;
5128 }
5129 mOffsets.pop_back();
5130 mRecTypes.pop_back();
5131 mpOutStrm->Seek( nPos );
5132 }
5133
5134 void EscherEx::BeginAtom()
5135 {
5136 mnCountOfs = mpOutStrm->Tell();
5137 mpOutStrm->WriteUInt32( 0 ).WriteUInt32( 0 ); // record header will be written later
5138 }
5139
5140 void EscherEx::EndAtom( sal_uInt16 nRecType, int nRecVersion, int nRecInstance )
5141 {
5142 sal_uInt64 nOldPos = mpOutStrm->Tell();
5143 mpOutStrm->Seek( mnCountOfs );
5144 sal_uInt32 nSize = nOldPos - mnCountOfs;
5145 mpOutStrm->WriteUInt16( ( nRecInstance << 4 ) | ( nRecVersion & 0xf ) ).WriteUInt16( nRecType ).WriteUInt32( nSize - 8 );
5146 mpOutStrm->Seek( nOldPos );
5147 }
5148
5149 void EscherEx::AddAtom( sal_uInt32 nAtomSize, sal_uInt16 nRecType, int nRecVersion, int nRecInstance )
5150 {
5151 mpOutStrm->WriteUInt16( ( nRecInstance << 4 ) | ( nRecVersion & 0xf ) ).WriteUInt16( nRecType ).WriteUInt32( nAtomSize );
5152 }
5153
5154 void EscherEx::AddChildAnchor( const tools::Rectangle& rRect )
5155 {
5156 AddAtom( 16, ESCHER_ChildAnchor );
5157 mpOutStrm ->WriteInt32( rRect.Left() )
5158 .WriteInt32( rRect.Top() )
5159 .WriteInt32( rRect.Right() )
5160 .WriteInt32( rRect.Bottom() );
5161 }
5162
5163 void EscherEx::AddClientAnchor( const tools::Rectangle& rRect )
5164 {
5165 AddAtom( 8, ESCHER_ClientAnchor );
5166 mpOutStrm->WriteInt16( rRect.Top() )
5167 .WriteInt16( rRect.Left() )
5168 .WriteInt16( rRect.GetWidth() + rRect.Left() )
5169 .WriteInt16( rRect.GetHeight() + rRect.Top() );
5170 }
5171
5172 EscherExHostAppData* EscherEx::EnterAdditionalTextGroup()
5173 {
5174 return nullptr;
5175 }
5176
5177 sal_uInt32 EscherEx::EnterGroup( const OUString& rShapeName, const tools::Rectangle* pBoundRect )
5178 {
5179 tools::Rectangle aRect;
5180 if( pBoundRect )
5181 aRect = *pBoundRect;
5182
5183 OpenContainer( ESCHER_SpgrContainer );
5184 OpenContainer( ESCHER_SpContainer );
5185 AddAtom( 16, ESCHER_Spgr, 1 );
5186 PtReplaceOrInsert( ESCHER_Persist_Grouping_Snap | mnGroupLevel,
5187 mpOutStrm->Tell() );
5188 mpOutStrm ->WriteInt32( aRect.Left() ) // Bounding box for the grouped shapes to which they will be attached
5189 .WriteInt32( aRect.Top() )
5190 .WriteInt32( aRect.IsWidthEmpty() ? aRect.Left() : aRect.Right() )
5191 .WriteInt32( aRect.IsHeightEmpty() ? aRect.Top() : aRect.Bottom() );
5192
5193 sal_uInt32 nShapeId = GenerateShapeId();
5194 if ( !mnGroupLevel )
5195 AddShape( ESCHER_ShpInst_Min, ShapeFlag::Group | ShapeFlag::Patriarch, nShapeId );
5196 else
5197 {
5198 AddShape( ESCHER_ShpInst_Min, ShapeFlag::Group | ShapeFlag::HaveAnchor, nShapeId );
5199 EscherPropertyContainer aPropOpt;
5200 aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x00040004 );
5201 aPropOpt.AddOpt( ESCHER_Prop_dxWrapDistLeft, 0 );
5202 aPropOpt.AddOpt( ESCHER_Prop_dxWrapDistRight, 0 );
5203
5204 // #i51348# shape name
5205 if( rShapeName.getLength() > 0 )
5206 aPropOpt.AddOpt( ESCHER_Prop_wzName, rShapeName );
5207
5208 Commit( aPropOpt, aRect );
5209 if ( mnGroupLevel > 1 )
5210 AddChildAnchor( aRect );
5211
5212 EscherExHostAppData* pAppData = mpImplEESdrWriter->ImplGetHostData();
5213 if( pAppData )
5214 {
5215 if ( mnGroupLevel <= 1 )
5216 pAppData->WriteClientAnchor( *this, aRect );
5217 pAppData->WriteClientData( *this );
5218 }
5219 }
5220 CloseContainer(); // ESCHER_SpContainer
5221 mnGroupLevel++;
5222 return nShapeId;
5223 }
5224
5225 sal_uInt32 EscherEx::EnterGroup( const tools::Rectangle* pBoundRect )
5226 {
5227 return EnterGroup( OUString(), pBoundRect );
5228 }
5229
5230 void EscherEx::SetGroupSnapRect( sal_uInt32 nGroupLevel, const tools::Rectangle& rRect )
5231 {
5232 if ( nGroupLevel )
5233 {
5234 sal_uInt64 nCurrentPos = mpOutStrm->Tell();
5235 if ( DoSeek( ESCHER_Persist_Grouping_Snap | ( nGroupLevel - 1 ) ) )
5236 {
5237 mpOutStrm ->WriteInt32( rRect.Left() ) // Bounding box for the grouped shapes to which they will be attached
5238 .WriteInt32( rRect.Top() )
5239 .WriteInt32( rRect.Right() )
5240 .WriteInt32( rRect.Bottom() );
5241 mpOutStrm->Seek( nCurrentPos );
5242 }
5243 }
5244 }
5245
5246 void EscherEx::SetGroupLogicRect( sal_uInt32 nGroupLevel, const tools::Rectangle& rRect )
5247 {
5248 if ( nGroupLevel )
5249 {
5250 sal_uInt64 nCurrentPos = mpOutStrm->Tell();
5251 if ( DoSeek( ESCHER_Persist_Grouping_Logic | ( nGroupLevel - 1 ) ) )
5252 {
5253 mpOutStrm->WriteInt16( rRect.Top() ).WriteInt16( rRect.Left() ).WriteInt16( rRect.Right() ).WriteInt16( rRect.Bottom() );
5254 mpOutStrm->Seek( nCurrentPos );
5255 }
5256 }
5257 }
5258
5259 void EscherEx::LeaveGroup()
5260 {
5261 --mnGroupLevel;
5262 PtDelete( ESCHER_Persist_Grouping_Snap | mnGroupLevel );
5263 PtDelete( ESCHER_Persist_Grouping_Logic | mnGroupLevel );
5264 CloseContainer();
5265 }
5266
5267 void EscherEx::AddShape( sal_uInt32 nShpInstance, ShapeFlag nFlags, sal_uInt32 nShapeID )
5268 {
5269 AddAtom( 8, ESCHER_Sp, 2, nShpInstance );
5270
5271 if ( !nShapeID )
5272 nShapeID = GenerateShapeId();
5273
5274 if (nFlags ^ ShapeFlag::Group) // no pure group shape
5275 {
5276 if ( mnGroupLevel > 1 )
5277 nFlags |= ShapeFlag::Child; // this not a topmost shape
5278 }
5279 mpOutStrm->WriteUInt32( nShapeID ).WriteUInt32( static_cast<sal_uInt32>(nFlags) );
5280 }
5281
5282 void EscherEx::Commit( EscherPropertyContainer& rProps, const tools::Rectangle& )
5283 {
5284 rProps.Commit( GetStream() );
5285 }
5286
5287 sal_uInt32 EscherEx::GetColor( const sal_uInt32 nSOColor )
5288 {
5289 sal_uInt32 nColor = nSOColor & 0xff00; // Green
5290 nColor |= static_cast<sal_uInt8>(nSOColor) << 16; // Red
5291 nColor |= static_cast<sal_uInt8>( nSOColor >> 16 ); // Blue
5292 return nColor;
5293 }
5294
5295 sal_uInt32 EscherEx::GetColor( const Color& rSOColor )
5296 {
5297 sal_uInt32 nColor = ( rSOColor.GetRed() << 16 );
5298 nColor |= ( rSOColor.GetGreen() << 8 );
5299 nColor |= rSOColor.GetBlue();
5300 nColor = GetColor( nColor );
5301 return nColor;
5302 }
5303
5304 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE