LibreOffice Module svx (master)  1
EnhancedCustomShape2d.cxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
20 #include <sal/config.h>
21 
22 #include <o3tl/string_view.hxx>
23 #include <svx/EnhancedCustomShape2d.hxx>
24 #include <svx/EnhancedCustomShapeGeometry.hxx>
25 #include <svx/EnhancedCustomShapeTypeNames.hxx>
26 #include <svx/svdoashp.hxx>
27 #include <svx/svdtrans.hxx>
28 #include <svx/svdogrp.hxx>
29 #include <svx/svdopath.hxx>
30 #include <svx/svdorect.hxx>
31 #include <svx/svdpage.hxx>
32 #include <svx/xflclit.hxx>
33 #include <svx/xfillit0.hxx>
34 #include <svx/xlineit0.hxx>
35 #include <svx/xlnstit.hxx>
36 #include <svx/xlnedit.hxx>
37 #include <svx/xlnstwit.hxx>
38 #include <svx/xlnedwit.hxx>
39 #include <svx/xlnstcit.hxx>
40 #include <svx/xlnedcit.hxx>
41 #include <svx/xflgrit.hxx>
42 #include <svx/xflhtit.hxx>
43 #include <svx/xbtmpit.hxx>
44 #include <svx/xgrad.hxx>
45 #include <svx/xhatch.hxx>
46 #include <svx/sdshitm.hxx>
47 #include <com/sun/star/awt/Size.hpp>
48 #include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
49 #include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
50 #include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
51 #include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
52 #include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
53 #include <basegfx/numeric/ftools.hxx>
54 #include <basegfx/color/bcolortools.hxx>
55 #include <basegfx/polygon/b2dpolygon.hxx>
56 #include <basegfx/polygon/b2dpolygontools.hxx>
57 #include <basegfx/matrix/b2dhommatrixtools.hxx>
58 #include <sal/log.hxx>
59 
60 #include <algorithm>
61 #include <cstdlib>
62 #include <string_view>
63 #include <unordered_set>
64 
65 using namespace ::com::sun::star;
66 using namespace ::com::sun::star::uno;
67 using namespace ::com::sun::star::drawing;
68 using namespace ::com::sun::star::drawing::EnhancedCustomShapeSegmentCommand;
69 
70 void EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( EnhancedCustomShapeParameter& rParameter, const sal_Int32 nValue )
71 {
72  sal_uInt32 nDat = static_cast<sal_uInt32>(nValue);
73  sal_Int32 nNewValue = nValue;
74 
75  // check if this is a special point
76  if ( ( nDat >> 16 ) == 0x8000 )
77  {
78  nNewValue = static_cast<sal_uInt16>(nDat);
79  rParameter.Type = EnhancedCustomShapeParameterType::EQUATION;
80  }
81  else
82  rParameter.Type = EnhancedCustomShapeParameterType::NORMAL;
83  rParameter.Value <<= nNewValue;
84 }
85 
86 OUString EnhancedCustomShape2d::GetEquation( const sal_uInt16 nFlags, sal_Int32 nP1, sal_Int32 nP2, sal_Int32 nP3 )
87 {
88  OUString aEquation;
89  bool b1Special = ( nFlags & 0x2000 ) != 0;
90  bool b2Special = ( nFlags & 0x4000 ) != 0;
91  bool b3Special = ( nFlags & 0x8000 ) != 0;
92  switch( nFlags & 0xff )
93  {
94  case 0 :
95  case 14 :
96  {
97  sal_Int32 nOptimize = 0;
98  if ( nP1 )
99  nOptimize |= 1;
100  if ( nP2 )
101  nOptimize |= 2;
102  if ( b1Special )
103  nOptimize |= 4;
104  if ( b2Special )
105  nOptimize |= 8;
106  switch( nOptimize )
107  {
108  case 0 :
109  break;
110  case 1 :
111  case 4 :
112  case 5 :
113  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
114  break;
115  case 2 :
116  case 8 :
117  case 10:
118  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
119  break;
120  default :
121  {
122  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
123  aEquation += "+";
124  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
125  }
126  break;
127  }
128  if ( b3Special || nP3 )
129  {
130  aEquation += "-";
131  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
132  }
133  }
134  break;
135  case 1 :
136  {
137  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
138  if ( b2Special || ( nP2 != 1 ) )
139  {
140  aEquation += "*";
141  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
142  }
143  if ( b3Special || ( ( nP3 != 1 ) && ( nP3 != 0 ) ) )
144  {
145  aEquation += "/";
146  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
147  }
148  }
149  break;
150  case 2 :
151  {
152  aEquation += "(";
153  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
154  aEquation += "+";
155  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
156  aEquation += ")/2";
157  }
158  break;
159  case 3 :
160  {
161  aEquation += "abs(";
162  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
163  aEquation += ")";
164  }
165  break;
166  case 4 :
167  {
168  aEquation += "min(";
169  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
170  aEquation += ",";
171  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
172  aEquation += ")";
173  }
174  break;
175  case 5 :
176  {
177  aEquation += "max(";
178  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
179  aEquation += ",";
180  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
181  aEquation += ")";
182  }
183  break;
184  case 6 :
185  {
186  aEquation += "if(";
187  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
188  aEquation += ",";
189  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
190  aEquation += ",";
191  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
192  aEquation += ")";
193  }
194  break;
195  case 7 :
196  {
197  aEquation += "sqrt(";
198  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
199  aEquation += "*";
200  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
201  aEquation += "+";
202  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
203  aEquation += "*";
204  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
205  aEquation += "+";
206  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
207  aEquation += "*";
208  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
209  aEquation += ")";
210  }
211  break;
212  case 8 :
213  {
214  aEquation += "atan2(";
215  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
216  aEquation += ",";
217  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
218  aEquation += ")/(pi/180)";
219  }
220  break;
221  case 9 :
222  {
223  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
224  aEquation += "*sin(";
225  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
226  aEquation += "*(pi/180))";
227  }
228  break;
229  case 10 :
230  {
231  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
232  aEquation += "*cos(";
233  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
234  aEquation += "*(pi/180))";
235  }
236  break;
237  case 11 :
238  {
239  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
240  aEquation += "*cos(atan2(";
241  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
242  aEquation += ",";
243  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
244  aEquation += "))";
245  }
246  break;
247  case 12 :
248  {
249  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
250  aEquation += "*sin(atan2(";
251  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
252  aEquation += ",";
253  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
254  aEquation += "))";
255  }
256  break;
257  case 13 :
258  {
259  aEquation += "sqrt(";
260  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
261  aEquation += ")";
262  }
263  break;
264  case 15 :
265  {
266  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
267  aEquation += "*sqrt(1-(";
268  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
269  aEquation += "/";
270  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
271  aEquation += ")"
272  "*(";
273  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
274  aEquation += "/";
275  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
276  aEquation += "))";
277  }
278  break;
279  case 16 :
280  {
281  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
282  aEquation += "*tan(";
283  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
284  aEquation += ")";
285  }
286  break;
287  case 0x80 :
288  {
289  aEquation += "sqrt(";
290  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
291  aEquation += "*";
292  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
293  aEquation += "-";
294  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
295  aEquation += "*";
296  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
297  aEquation += ")";
298  }
299  break;
300  case 0x81 :
301  {
302  aEquation += "(cos(";
303  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
304  aEquation += "*(pi/180))*(";
305  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
306  aEquation += "-10800)+sin(";
307  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
308  aEquation += "*(pi/180))*(";
309  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
310  aEquation += "-10800))+10800";
311  }
312  break;
313  case 0x82 :
314  {
315  aEquation += "-(sin(";
316  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
317  aEquation += "*(pi/180))*(";
318  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP1, b1Special );
319  aEquation += "-10800)-cos(";
320  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP3, b3Special );
321  aEquation += "*(pi/180))*(";
322  EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( aEquation, nP2, b2Special );
323  aEquation += "-10800))+10800";
324  }
325  break;
326  }
327  return aEquation;
328 }
329 
330 void EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter( OUString& rParameter, const sal_Int32 nPara, const bool bIsSpecialValue )
331 {
332  if ( bIsSpecialValue )
333  {
334  if ( nPara & 0x400 )
335  {
336  rParameter += "?";
337  rParameter += OUString::number( nPara & 0xff );
338  rParameter += " ";
339  }
340  else
341  {
342  switch( nPara )
343  {
344  case DFF_Prop_adjustValue :
345  case DFF_Prop_adjust2Value :
346  case DFF_Prop_adjust3Value :
347  case DFF_Prop_adjust4Value :
348  case DFF_Prop_adjust5Value :
349  case DFF_Prop_adjust6Value :
350  case DFF_Prop_adjust7Value :
351  case DFF_Prop_adjust8Value :
352  case DFF_Prop_adjust9Value :
353  case DFF_Prop_adjust10Value :
354  {
355  rParameter += "$";
356  rParameter += OUString::number( nPara - DFF_Prop_adjustValue );
357  rParameter += " ";
358  }
359  break;
360  case DFF_Prop_geoLeft :
361  {
362  rParameter += "left";
363  }
364  break;
365  case DFF_Prop_geoTop :
366  {
367  rParameter += "top";
368  }
369  break;
370  case DFF_Prop_geoRight :
371  {
372  rParameter += "right";
373  }
374  break;
375  case DFF_Prop_geoBottom :
376  {
377  rParameter += "bottom";
378  }
379  break;
380  }
381  }
382  }
383  else
384  {
385  rParameter += OUString::number( nPara );
386  }
387 }
388 
389 void EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( EnhancedCustomShapeParameter& rParameter, const sal_Int32 nPara, const bool bIsSpecialValue, bool bHorz )
390 {
391  sal_Int32 nValue = 0;
392  if ( bIsSpecialValue )
393  {
394  if ( ( nPara >= 0x100 ) && ( nPara <= 0x107 ) )
395  {
396  nValue = nPara & 0xff;
397  rParameter.Type = EnhancedCustomShapeParameterType::ADJUSTMENT;
398  }
399  else if ( ( nPara >= 3 ) && ( nPara <= 0x82 ) )
400  {
401  nValue = nPara - 3;
402  rParameter.Type = EnhancedCustomShapeParameterType::EQUATION;
403  }
404  else if ( nPara == 0 )
405  {
406  nValue = 0;
407  if ( bHorz )
408  rParameter.Type = EnhancedCustomShapeParameterType::LEFT;
409  else
410  rParameter.Type = EnhancedCustomShapeParameterType::TOP;
411  }
412  else if ( nPara == 1 )
413  {
414  nValue = 0;
415  if ( bHorz )
416  rParameter.Type = EnhancedCustomShapeParameterType::RIGHT;
417  else
418  rParameter.Type = EnhancedCustomShapeParameterType::BOTTOM;
419  }
420  else if ( nPara == 2 ) // means to be centered, but should not be
421  { // used in our implementation
422  nValue = 5600;
423  rParameter.Type = EnhancedCustomShapeParameterType::NORMAL;
424  }
425  else
426  {
427  nValue = nPara;
428  rParameter.Type = EnhancedCustomShapeParameterType::NORMAL;
429  }
430  }
431  else
432  {
433  nValue = nPara;
434  rParameter.Type = EnhancedCustomShapeParameterType::NORMAL;
435  }
436  rParameter.Value <<= nValue;
437 }
438 
439 bool EnhancedCustomShape2d::ConvertSequenceToEnhancedCustomShape2dHandle(
440  const css::beans::PropertyValues& rHandleProperties,
441  EnhancedCustomShape2d::Handle& rDestinationHandle )
442 {
443  bool bRetValue = false;
444  if ( rHandleProperties.hasElements() )
445  {
446  rDestinationHandle.nFlags = HandleFlags::NONE;
447  for ( const css::beans::PropertyValue& rPropVal : rHandleProperties )
448  {
449  if ( rPropVal.Name == "Position" )
450  {
451  if ( rPropVal.Value >>= rDestinationHandle.aPosition )
452  bRetValue = true;
453  }
454  else if ( rPropVal.Name == "MirroredX" )
455  {
456  bool bMirroredX;
457  if ( rPropVal.Value >>= bMirroredX )
458  {
459  if ( bMirroredX )
460  rDestinationHandle.nFlags |= HandleFlags::MIRRORED_X;
461  }
462  }
463  else if ( rPropVal.Name == "MirroredY" )
464  {
465  bool bMirroredY;
466  if ( rPropVal.Value >>= bMirroredY )
467  {
468  if ( bMirroredY )
469  rDestinationHandle.nFlags |= HandleFlags::MIRRORED_Y;
470  }
471  }
472  else if ( rPropVal.Name == "Switched" )
473  {
474  bool bSwitched;
475  if ( rPropVal.Value >>= bSwitched )
476  {
477  if ( bSwitched )
478  rDestinationHandle.nFlags |= HandleFlags::SWITCHED;
479  }
480  }
481  else if ( rPropVal.Name == "Polar" )
482  {
483  if ( rPropVal.Value >>= rDestinationHandle.aPolar )
484  rDestinationHandle.nFlags |= HandleFlags::POLAR;
485  }
486  else if ( rPropVal.Name == "RefX" )
487  {
488  if ( rPropVal.Value >>= rDestinationHandle.nRefX )
489  rDestinationHandle.nFlags |= HandleFlags::REFX;
490  }
491  else if ( rPropVal.Name == "RefY" )
492  {
493  if ( rPropVal.Value >>= rDestinationHandle.nRefY )
494  rDestinationHandle.nFlags |= HandleFlags::REFY;
495  }
496  else if ( rPropVal.Name == "RefAngle" )
497  {
498  if ( rPropVal.Value >>= rDestinationHandle.nRefAngle )
499  rDestinationHandle.nFlags |= HandleFlags::REFANGLE;
500  }
501  else if ( rPropVal.Name == "RefR" )
502  {
503  if ( rPropVal.Value >>= rDestinationHandle.nRefR )
504  rDestinationHandle.nFlags |= HandleFlags::REFR;
505  }
506  else if ( rPropVal.Name == "RadiusRangeMinimum" )
507  {
508  if ( rPropVal.Value >>= rDestinationHandle.aRadiusRangeMinimum )
509  rDestinationHandle.nFlags |= HandleFlags::RADIUS_RANGE_MINIMUM;
510  }
511  else if ( rPropVal.Name == "RadiusRangeMaximum" )
512  {
513  if ( rPropVal.Value >>= rDestinationHandle.aRadiusRangeMaximum )
514  rDestinationHandle.nFlags |= HandleFlags::RADIUS_RANGE_MAXIMUM;
515  }
516  else if ( rPropVal.Name == "RangeXMinimum" )
517  {
518  if ( rPropVal.Value >>= rDestinationHandle.aXRangeMinimum )
519  rDestinationHandle.nFlags |= HandleFlags::RANGE_X_MINIMUM;
520  }
521  else if ( rPropVal.Name == "RangeXMaximum" )
522  {
523  if ( rPropVal.Value >>= rDestinationHandle.aXRangeMaximum )
524  rDestinationHandle.nFlags |= HandleFlags::RANGE_X_MAXIMUM;
525  }
526  else if ( rPropVal.Name == "RangeYMinimum" )
527  {
528  if ( rPropVal.Value >>= rDestinationHandle.aYRangeMinimum )
529  rDestinationHandle.nFlags |= HandleFlags::RANGE_Y_MINIMUM;
530  }
531  else if ( rPropVal.Name == "RangeYMaximum" )
532  {
533  if ( rPropVal.Value >>= rDestinationHandle.aYRangeMaximum )
534  rDestinationHandle.nFlags |= HandleFlags::RANGE_Y_MAXIMUM;
535  }
536  }
537  }
538  return bRetValue;
539 }
540 
541 void EnhancedCustomShape2d::ApplyShapeAttributes( const SdrCustomShapeGeometryItem& rGeometryItem )
542 {
543  // AdjustmentValues
544  const Any* pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( "AdjustmentValues" );
545  if ( pAny )
546  *pAny >>= seqAdjustmentValues;
547 
548 
549  // Coordsize
550  const Any* pViewBox = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( "ViewBox" );
551  css::awt::Rectangle aViewBox;
552  if ( pViewBox && (*pViewBox >>= aViewBox ) )
553  {
554  nCoordLeft = aViewBox.X;
555  nCoordTop = aViewBox.Y;
556  nCoordWidthG = std::abs( aViewBox.Width );
557  nCoordHeightG = std::abs( aViewBox.Height);
558  }
559  static const OUStringLiteral sPath( u"Path" );
560 
561 
562  // Path/Coordinates
563  pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( sPath, "Coordinates" );
564  if ( pAny )
565  *pAny >>= seqCoordinates;
566 
567 
568  // Path/GluePoints
569  pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( sPath, "GluePoints" );
570  if ( pAny )
571  *pAny >>= seqGluePoints;
572 
573 
574  // Path/Segments
575  pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( sPath, "Segments" );
576  if ( pAny )
577  *pAny >>= seqSegments;
578 
579 
580  // Path/SubViewSize
581  pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( sPath, "SubViewSize" );
582  if ( pAny )
583  *pAny >>= seqSubViewSize;
584 
585 
586  // Path/StretchX
587  pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( sPath, "StretchX" );
588  if ( pAny )
589  {
590  sal_Int32 nStretchX = 0;
591  if ( *pAny >>= nStretchX )
592  nXRef = nStretchX;
593  }
594 
595 
596  // Path/StretchY
597  pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( sPath, "StretchY" );
598  if ( pAny )
599  {
600  sal_Int32 nStretchY = 0;
601  if ( *pAny >>= nStretchY )
602  nYRef = nStretchY;
603  }
604 
605 
606  // Path/TextFrames
607  pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( sPath, "TextFrames" );
608  if ( pAny )
609  *pAny >>= seqTextFrames;
610 
611 
612  // Equations
613  pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( "Equations" );
614  if ( pAny )
615  *pAny >>= seqEquations;
616 
617 
618  // Handles
619  pAny = const_cast<SdrCustomShapeGeometryItem&>(rGeometryItem).GetPropertyValueByName( "Handles" );
620  if ( pAny )
621  *pAny >>= seqHandles;
622 }
623 
624 EnhancedCustomShape2d::~EnhancedCustomShape2d()
625 {
626 }
627 
628 void EnhancedCustomShape2d::SetPathSize( sal_Int32 nIndex )
629 {
630  sal_Int32 nWidth = 0;
631  sal_Int32 nHeight = 0;
632 
633  if ( seqSubViewSize.hasElements() && nIndex < seqSubViewSize.getLength() ) {
634  nWidth = seqSubViewSize[ nIndex ].Width;
635  nHeight = seqSubViewSize[ nIndex ].Height;
636  SAL_INFO(
637  "svx",
638  "set subpath " << nIndex << " size: " << nWidth << " x "
639  << nHeight);
640  }
641 
642  if ( nWidth && nHeight ) {
643  nCoordWidth = nWidth;
644  nCoordHeight = nHeight;
645  } else {
646  nCoordWidth = nCoordWidthG;
647  nCoordHeight = nCoordHeightG;
648  }
649 
650  fXScale = nCoordWidth == 0 ? 0.0 : static_cast<double>(aLogicRect.GetWidth()) / static_cast<double>(nCoordWidth);
651  fYScale = nCoordHeight == 0 ? 0.0 : static_cast<double>(aLogicRect.GetHeight()) / static_cast<double>(nCoordHeight);
652  if ( bOOXMLShape )
653  {
654  SAL_INFO(
655  "svx",
656  "ooxml shape, path width: " << nCoordWidth << " height: "
657  << nCoordHeight);
658 
659  // Try to set up scale separately, if given only width or height
660  // This is possible case in OOXML when only width or height is non-zero
661  if ( nCoordWidth == 0 )
662  {
663  if ( nWidth )
664  fXScale = static_cast<double>(aLogicRect.GetWidth()) / static_cast<double>(nWidth);
665  else
666  fXScale = 1.0;
667  }
668  if ( nCoordHeight == 0 )
669  {
670  if ( nHeight )
671  fYScale = static_cast<double>(aLogicRect.GetHeight()) / static_cast<double>(nHeight);
672  else
673  fYScale = 1.0;
674  }
675  }
676  if ( static_cast<sal_uInt32>(nXRef) != 0x80000000 && aLogicRect.GetHeight() )
677  {
678  fXRatio = static_cast<double>(aLogicRect.GetWidth()) / static_cast<double>(aLogicRect.GetHeight());
679  if ( fXRatio > 1 )
680  fXScale /= fXRatio;
681  else
682  fXRatio = 1.0;
683  }
684  else
685  fXRatio = 1.0;
686  if ( static_cast<sal_uInt32>(nYRef) != 0x80000000 && aLogicRect.GetWidth() )
687  {
688  fYRatio = static_cast<double>(aLogicRect.GetHeight()) / static_cast<double>(aLogicRect.GetWidth());
689  if ( fYRatio > 1 )
690  fYScale /= fYRatio;
691  else
692  fYRatio = 1.0;
693  }
694  else
695  fYRatio = 1.0;
696 }
697 
698 EnhancedCustomShape2d::EnhancedCustomShape2d(SdrObjCustomShape& rSdrObjCustomShape)
699 : SfxItemSet ( rSdrObjCustomShape.GetMergedItemSet() ),
700  mrSdrObjCustomShape ( rSdrObjCustomShape ),
701  eSpType ( mso_sptNil ),
702  nCoordLeft ( 0 ),
703  nCoordTop ( 0 ),
704  nCoordWidthG ( 21600 ),
705  nCoordHeightG ( 21600 ),
706  bOOXMLShape ( false ),
707  nXRef ( 0x80000000 ),
708  nYRef ( 0x80000000 ),
709  nColorData ( 0 ),
710  bFilled ( rSdrObjCustomShape.GetMergedItem( XATTR_FILLSTYLE ).GetValue() != drawing::FillStyle_NONE ),
711  bStroked ( rSdrObjCustomShape.GetMergedItem( XATTR_LINESTYLE ).GetValue() != drawing::LineStyle_NONE ),
712  bFlipH ( false ),
713  bFlipV ( false )
714 {
715  // bTextFlow needs to be set before clearing the TextDirection Item
716 
717  ClearItem( SDRATTR_TEXTDIRECTION ); //SJ: vertical writing is not required, by removing this item no outliner is created
718 
719  // #i105323# For 2D AutoShapes, the shadow attribute does not need to be applied to any
720  // of the constructed helper SdrObjects. This would lead to problems since the shadow
721  // of one helper object would fall on one helper object behind it (e.g. with the
722  // eyes of the smiley shape). This is not wanted; instead a single shadow 'behind'
723  // the AutoShape visualisation is wanted. This is done with primitive functionality
724  // now in SdrCustomShapePrimitive2D::create2DDecomposition, but only for 2D objects
725  // (see there and in EnhancedCustomShape3d::Create3DObject to read more).
726  // This exception may be removed later when AutoShapes will create primitives directly.
727  // So, currently remove the ShadowAttribute from the ItemSet to not apply it to any
728  // 2D helper shape.
729  ClearItem(SDRATTR_SHADOW);
730 
731  Point aP( mrSdrObjCustomShape.GetSnapRect().Center() );
732  Size aS( mrSdrObjCustomShape.GetLogicRect().GetSize() );
733  aP.AdjustX( -(aS.Width() / 2) );
734  aP.AdjustY( -(aS.Height() / 2) );
735  aLogicRect = tools::Rectangle( aP, aS );
736 
737  OUString sShapeType;
738  const SdrCustomShapeGeometryItem& rGeometryItem(mrSdrObjCustomShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ));
739  const Any* pAny = rGeometryItem.GetPropertyValueByName( "Type" );
740  if ( pAny ) {
741  *pAny >>= sShapeType;
742  bOOXMLShape = sShapeType.startsWith("ooxml-");
743  SAL_INFO("svx", "shape type: " << sShapeType << " " << bOOXMLShape);
744  }
745  eSpType = EnhancedCustomShapeTypeNames::Get( sShapeType );
746 
747  pAny = rGeometryItem.GetPropertyValueByName( "MirroredX" );
748  if ( pAny )
749  *pAny >>= bFlipH;
750  pAny = rGeometryItem.GetPropertyValueByName( "MirroredY" );
751  if ( pAny )
752  *pAny >>= bFlipV;
753 
754  nRotateAngle = Degree100(static_cast<sal_Int32>(mrSdrObjCustomShape.GetObjectRotation() * 100.0));
755 
756  /*const sal_Int32* pDefData =*/ ApplyShapeAttributes( rGeometryItem );
757  SetPathSize();
758 
759  switch( eSpType )
760  {
761  case mso_sptCan : nColorData = 0x20400000; break;
762  case mso_sptCube : nColorData = 0x302e0000; break;
763  case mso_sptActionButtonBlank : nColorData = 0x502ce400; break;
764  case mso_sptActionButtonHome : nColorData = 0x702ce4ce; break;
765  case mso_sptActionButtonHelp : nColorData = 0x602ce4c0; break;
766  case mso_sptActionButtonInformation : nColorData = 0x702ce4c5; break;
767  case mso_sptActionButtonBackPrevious : nColorData = 0x602ce4c0; break;
768  case mso_sptActionButtonForwardNext : nColorData = 0x602ce4c0; break;
769  case mso_sptActionButtonBeginning : nColorData = 0x602ce4c0; break;
770  case mso_sptActionButtonEnd : nColorData = 0x602ce4c0; break;
771  case mso_sptActionButtonReturn : nColorData = 0x602ce4c0; break;
772  case mso_sptActionButtonDocument : nColorData = 0x702ce4ec; break;
773  case mso_sptActionButtonSound : nColorData = 0x602ce4c0; break;
774  case mso_sptActionButtonMovie : nColorData = 0x602ce4c0; break;
775  case mso_sptBevel : nColorData = 0x502ce400; break;
776  case mso_sptFoldedCorner : nColorData = 0x20e00000; break;
777  case mso_sptSmileyFace : nColorData = 0x20e00000; break;
778  case mso_sptNil :
779  {
780  if( sShapeType.getLength() > 4 &&
781  sShapeType.match( "col-" ))
782  {
783  nColorData = sShapeType.copy( 4 ).toUInt32( 16 );
784  }
785  }
786  break;
787  case mso_sptCurvedLeftArrow :
788  case mso_sptCurvedRightArrow :
789  case mso_sptCurvedUpArrow :
790  case mso_sptCurvedDownArrow : nColorData = 0x20d00000; break;
791  case mso_sptRibbon2 : nColorData = 0x30ee0000; break;
792  case mso_sptRibbon : nColorData = 0x30ee0000; break;
793 
794  case mso_sptEllipseRibbon2 : nColorData = 0x30ee0000; break;
795  case mso_sptEllipseRibbon : nColorData = 0x30ee0000; break;
796 
797  case mso_sptVerticalScroll : nColorData = 0x30ee0000; break;
798  case mso_sptHorizontalScroll : nColorData = 0x30ee0000; break;
799  default:
800  break;
801  }
802 
803  sal_Int32 nLength = seqEquations.getLength();
804 
805  if ( !nLength )
806  return;
807 
808  vNodesSharedPtr.resize( nLength );
809  vEquationResults.resize( nLength );
810  for ( sal_Int32 i = 0; i < nLength; i++ )
811  {
812  vEquationResults[ i ].bReady = false;
813  try
814  {
815  vNodesSharedPtr[ i ] = EnhancedCustomShape::FunctionParser::parseFunction( seqEquations[ i ], *this );
816  }
817  catch ( EnhancedCustomShape::ParseError& )
818  {
819  SAL_INFO(
820  "svx",
821  "error: equation number: " << i << ", parser failed ("
822  << seqEquations[i] << ")");
823  }
824  }
825 }
826 
827 using EnhancedCustomShape::ExpressionFunct;
828 
829 double EnhancedCustomShape2d::GetEnumFunc( const ExpressionFunct eFunc ) const
830 {
831  double fRet = 0.0;
832  switch( eFunc )
833  {
834  case ExpressionFunct::EnumPi : fRet = F_PI; break;
835  case ExpressionFunct::EnumLeft : fRet = static_cast<double>(nCoordLeft); break;
836  case ExpressionFunct::EnumTop : fRet = static_cast<double>(nCoordTop); break;
837  case ExpressionFunct::EnumRight : fRet = (static_cast<double>(nCoordLeft) + static_cast<double>(nCoordWidth)) * fXRatio; break;
838  case ExpressionFunct::EnumBottom : fRet = (static_cast<double>(nCoordTop) + static_cast<double>(nCoordHeight)) * fYRatio; break;
839  case ExpressionFunct::EnumXStretch : fRet = nXRef; break;
840  case ExpressionFunct::EnumYStretch : fRet = nYRef; break;
841  case ExpressionFunct::EnumHasStroke : fRet = bStroked ? 1.0 : 0.0; break;
842  case ExpressionFunct::EnumHasFill : fRet = bFilled ? 1.0 : 0.0; break;
843  case ExpressionFunct::EnumWidth : fRet = nCoordWidth; break;
844  case ExpressionFunct::EnumHeight : fRet = nCoordHeight; break;
845  case ExpressionFunct::EnumLogWidth : fRet = aLogicRect.GetWidth(); break;
846  case ExpressionFunct::EnumLogHeight : fRet = aLogicRect.GetHeight(); break;
847  default: break;
848  }
849  return fRet;
850 }
851 double EnhancedCustomShape2d::GetAdjustValueAsDouble( const sal_Int32 nIndex ) const
852 {
853  double fNumber = 0.0;
854  if ( nIndex < seqAdjustmentValues.getLength() )
855  {
856  if ( seqAdjustmentValues[ nIndex ].Value.getValueTypeClass() == TypeClass_DOUBLE )
857  seqAdjustmentValues[ nIndex ].Value >>= fNumber;
858  else
859  {
860  sal_Int32 nNumber = 0;
861  seqAdjustmentValues[ nIndex ].Value >>= nNumber;
862  fNumber = static_cast<double>(nNumber);
863  }
864  }
865  return fNumber;
866 }
867 double EnhancedCustomShape2d::GetEquationValueAsDouble( const sal_Int32 nIndex ) const
868 {
869  double fNumber = 0.0;
870  static sal_uInt32 nLevel = 0;
871  if ( nIndex < static_cast<sal_Int32>(vNodesSharedPtr.size()) )
872  {
873  if ( vNodesSharedPtr[ nIndex ] ) {
874  nLevel ++;
875  try
876  {
877  if ( vEquationResults[ nIndex ].bReady )
878  fNumber = vEquationResults[ nIndex ].fValue;
879  else {
880  // cast to non const, so that we can optimize by caching
881  // equation results, without changing all the const in the stack
882  struct EquationResult &aResult = const_cast<EnhancedCustomShape2d*>(this)->vEquationResults[ nIndex ];
883 
884  fNumber = aResult.fValue = (*vNodesSharedPtr[ nIndex ])();
885  aResult.bReady = true;
886 
887  SAL_INFO("svx", "equation " << nLevel << " (level: " << seqEquations[nIndex] << "): "
888  << fNumber << " --> " << 180.0*fNumber/10800000.0);
889  }
890  if ( !std::isfinite( fNumber ) )
891  fNumber = 0.0;
892  }
893  catch ( ... )
894  {
895  SAL_WARN("svx", "EnhancedCustomShape2d::GetEquationValueAsDouble failed");
896  }
897  nLevel --;
898  }
899  SAL_INFO(
900  "svx",
901  "?" << nIndex << " --> " << fNumber << " (angle: "
902  << 180.0*fNumber/10800000.0 << ")");
903  }
904 
905  return fNumber;
906 }
907 
908 bool EnhancedCustomShape2d::SetAdjustValueAsDouble( const double& rValue, const sal_Int32 nIndex )
909 {
910  bool bRetValue = false;
911  if ( nIndex < seqAdjustmentValues.getLength() )
912  {
913  // updating our local adjustment sequence
914  seqAdjustmentValues[ nIndex ].Value <<= rValue;
915  seqAdjustmentValues[ nIndex ].State = css::beans::PropertyState_DIRECT_VALUE;
916  bRetValue = true;
917  }
918  return bRetValue;
919 }
920 
921 basegfx::B2DPoint EnhancedCustomShape2d::GetPointAsB2DPoint( const css::drawing::EnhancedCustomShapeParameterPair& rPair,
922  const bool bScale, const bool bReplaceGeoSize ) const
923 {
924  double fValX, fValY;
925  // width
926  GetParameter(fValX, rPair.First, bReplaceGeoSize, false);
927  fValX -= nCoordLeft;
928  if (bScale)
929  {
930  fValX *= fXScale;
931  }
932  // height
933  GetParameter(fValY, rPair.Second, false, bReplaceGeoSize);
934  fValY -= nCoordTop;
935  if (bScale)
936  {
937  fValY *= fYScale;
938  }
939  return basegfx::B2DPoint(fValX,fValY);
940 }
941 
942 Point EnhancedCustomShape2d::GetPoint( const css::drawing::EnhancedCustomShapeParameterPair& rPair,
943  const bool bScale, const bool bReplaceGeoSize ) const
944 {
945  basegfx::B2DPoint aPoint(GetPointAsB2DPoint(rPair, bScale, bReplaceGeoSize));
946  return Point(static_cast<tools::Long>(aPoint.getX()), static_cast<tools::Long>(aPoint.getY()));
947 }
948 
949 void EnhancedCustomShape2d::GetParameter( double& rRetValue, const EnhancedCustomShapeParameter& rParameter,
950  const bool bReplaceGeoWidth, const bool bReplaceGeoHeight ) const
951 {
952  rRetValue = 0.0;
953  switch ( rParameter.Type )
954  {
955  case EnhancedCustomShapeParameterType::ADJUSTMENT :
956  {
957  sal_Int32 nAdjustmentIndex = 0;
958  if ( rParameter.Value >>= nAdjustmentIndex )
959  {
960  rRetValue = GetAdjustValueAsDouble( nAdjustmentIndex );
961  }
962  }
963  break;
964  case EnhancedCustomShapeParameterType::EQUATION :
965  {
966  sal_Int32 nEquationIndex = 0;
967  if ( rParameter.Value >>= nEquationIndex )
968  {
969  rRetValue = GetEquationValueAsDouble( nEquationIndex );
970  }
971  }
972  break;
973  case EnhancedCustomShapeParameterType::NORMAL :
974  {
975  if ( rParameter.Value.getValueTypeClass() == TypeClass_DOUBLE )
976  {
977  double fValue(0.0);
978  if ( rParameter.Value >>= fValue )
979  {
980  rRetValue = fValue;
981  }
982  }
983  else
984  {
985  sal_Int32 nValue = 0;
986  if ( rParameter.Value >>= nValue )
987  {
988  rRetValue = nValue;
989  if ( bReplaceGeoWidth && ( nValue == nCoordWidth ) )
990  rRetValue *= fXRatio;
991  else if ( bReplaceGeoHeight && ( nValue == nCoordHeight ) )
992  rRetValue *= fYRatio;
993  }
994  }
995  }
996  break;
997  case EnhancedCustomShapeParameterType::LEFT :
998  {
999  rRetValue = 0.0;
1000  }
1001  break;
1002  case EnhancedCustomShapeParameterType::TOP :
1003  {
1004  rRetValue = 0.0;
1005  }
1006  break;
1007  case EnhancedCustomShapeParameterType::RIGHT :
1008  {
1009  rRetValue = nCoordWidth;
1010  }
1011  break;
1012  case EnhancedCustomShapeParameterType::BOTTOM :
1013  {
1014  rRetValue = nCoordHeight;
1015  }
1016  break;
1017  }
1018 }
1019 
1020 // nLumDat 28-31 = number of luminance entries in nLumDat
1021 // nLumDat 27-24 = nLumDatEntry 0
1022 // nLumDat 23-20 = nLumDatEntry 1 ...
1023 // each 4bit entry is to be interpreted as a 10 percent signed luminance changing
1024 sal_Int32 EnhancedCustomShape2d::GetLuminanceChange( sal_uInt32 nIndex ) const
1025 {
1026  const sal_uInt32 nCount = nColorData >> 28;
1027  if ( !nCount )
1028  return 0;
1029 
1030  if ( nIndex >= nCount )
1031  nIndex = nCount - 1;
1032 
1033  const sal_Int32 nLumDat = nColorData << ( ( 1 + nIndex ) << 2 );
1034  return ( nLumDat >> 28 ) * 10;
1035 }
1036 
1037 Color EnhancedCustomShape2d::GetColorData( const Color& rFillColor, sal_uInt32 nIndex, double dBrightness ) const
1038 {
1039  if ( bOOXMLShape || ( mso_sptMin == eSpType /* ODF "non-primitive" */ ) )
1040  { //do LibreOffice way, using dBrightness
1041  if ( dBrightness == 0.0)
1042  {
1043  return rFillColor;
1044  }
1045  else
1046  {
1047  if (dBrightness >=0.0)
1048  { //lighten, blending with white
1049  return Color( static_cast<sal_uInt8>(static_cast< sal_Int32 >( std::clamp(rFillColor.GetRed() * (1.0-dBrightness) + dBrightness * 255.0, 0.0, 255.0) )),
1050  static_cast<sal_uInt8>(static_cast< sal_Int32 >( std::clamp(rFillColor.GetGreen() * (1.0-dBrightness) + dBrightness * 255.0, 0.0, 255.0) )),
1051  static_cast<sal_uInt8>(static_cast< sal_Int32 >( std::clamp(rFillColor.GetBlue() * (1.0-dBrightness) + dBrightness * 255.0, 0.0, 255.0) )) );
1052  }
1053  else
1054  { //darken (indicated by negative sign), blending with black
1055  return Color( static_cast<sal_uInt8>(static_cast< sal_Int32 >( std::clamp(rFillColor.GetRed() * (1.0+dBrightness), 0.0, 255.0) )),
1056  static_cast<sal_uInt8>(static_cast< sal_Int32 >( std::clamp(rFillColor.GetGreen() * (1.0+dBrightness), 0.0, 255.0) )),
1057  static_cast<sal_uInt8>(static_cast< sal_Int32 >( std::clamp(rFillColor.GetBlue() * (1.0+dBrightness), 0.0, 255.0) )) );
1058  }
1059  }
1060  }
1061  else
1062  { //do OpenOffice way, using nColorData
1063  const sal_Int32 nLuminance = GetLuminanceChange(nIndex);
1064  if( !nLuminance )
1065  return rFillColor;
1066 
1067  basegfx::BColor aHSVColor=
1068  basegfx::utils::rgb2hsv(
1069  basegfx::BColor(rFillColor.GetRed()/255.0,
1070  rFillColor.GetGreen()/255.0,
1071  rFillColor.GetBlue()/255.0));
1072 
1073  if( nLuminance > 0 )
1074  {
1075  aHSVColor.setGreen(
1076  aHSVColor.getGreen() * (1.0-nLuminance/100.0));
1077  aHSVColor.setBlue(
1078  nLuminance/100.0 +
1079  (1.0-nLuminance/100.0)*aHSVColor.getBlue());
1080  }
1081  else if( nLuminance < 0 )
1082  {
1083  aHSVColor.setBlue(
1084  (1.0+nLuminance/100.0)*aHSVColor.getBlue());
1085  }
1086 
1087  aHSVColor = basegfx::utils::hsv2rgb(aHSVColor);
1088  return Color( static_cast<sal_uInt8>(static_cast< sal_Int32 >( std::clamp(aHSVColor.getRed(),0.0,1.0) * 255.0 + 0.5 )),
1089  static_cast<sal_uInt8>(static_cast< sal_Int32 >( std::clamp(aHSVColor.getGreen(),0.0,1.0) * 255.0 + 0.5 )),
1090  static_cast<sal_uInt8>(static_cast< sal_Int32 >( std::clamp(aHSVColor.getBlue(),0.0,1.0) * 255.0 + 0.5 )) );
1091  }
1092 }
1093 
1094 tools::Rectangle EnhancedCustomShape2d::GetTextRect() const
1095 {
1096  if ( !seqTextFrames.hasElements() )
1097  return aLogicRect;
1098  sal_Int32 nIndex = 0;
1099  Point aTopLeft( GetPoint( seqTextFrames[ nIndex ].TopLeft, !bOOXMLShape, true ) );
1100  Point aBottomRight( GetPoint( seqTextFrames[ nIndex ].BottomRight, !bOOXMLShape, true ) );
1101  tools::Rectangle aRect( aTopLeft, aBottomRight );
1102  if ( bFlipH )
1103  {
1104  aRect.SetLeft(aLogicRect.GetWidth() - 1 - aBottomRight.X());
1105  aRect.SetRight( aLogicRect.GetWidth() - 1 - aTopLeft.X());
1106  }
1107  if ( bFlipV )
1108  {
1109  aRect.SetTop(aLogicRect.GetHeight() - 1 - aBottomRight.Y());
1110  aRect.SetBottom(aLogicRect.GetHeight() - 1 - aTopLeft.Y());
1111  }
1112  SAL_INFO("svx", aRect.GetWidth() << " x " << aRect.GetHeight());
1113  if( aRect.GetWidth() <= 1 || aRect.GetHeight() <= 1 )
1114  return aLogicRect;
1115  aRect.Move( aLogicRect.Left(), aLogicRect.Top() );
1116  aRect.Justify();
1117  return aRect;
1118 }
1119 
1120 sal_uInt32 EnhancedCustomShape2d::GetHdlCount() const
1121 {
1122  return seqHandles.getLength();
1123 }
1124 
1125 bool EnhancedCustomShape2d::GetHandlePosition( const sal_uInt32 nIndex, Point& rReturnPosition ) const
1126 {
1127  bool bRetValue = false;
1128  if ( nIndex < GetHdlCount() )
1129  {
1130  Handle aHandle;
1131  if ( ConvertSequenceToEnhancedCustomShape2dHandle( seqHandles[ nIndex ], aHandle ) )
1132  {
1133  if ( aHandle.nFlags & HandleFlags::POLAR )
1134  {
1135  Point aReferencePoint( GetPoint( aHandle.aPolar ) );
1136 
1137  double fAngle;
1138  double fRadius;
1139  GetParameter( fRadius, aHandle.aPosition.First, false, false );
1140  GetParameter( fAngle, aHandle.aPosition.Second, false, false );
1141 
1142  double a = basegfx::deg2rad(360.0 - fAngle);
1143  double dx = fRadius * fXScale;
1144  double fX = dx * cos( a );
1145  double fY =-dx * sin( a );
1146  rReturnPosition =
1147  Point(
1148  FRound( fX + aReferencePoint.X() ),
1149  basegfx::fTools::equalZero(fXScale) ? aReferencePoint.Y() :
1150  FRound( ( fY * fYScale ) / fXScale + aReferencePoint.Y() ) );
1151  }
1152  else
1153  {
1154  if ( aHandle.nFlags & HandleFlags::SWITCHED )
1155  {
1156  if ( aLogicRect.GetHeight() > aLogicRect.GetWidth() )
1157  {
1158  css::drawing::EnhancedCustomShapeParameter aFirst = aHandle.aPosition.First;
1159  css::drawing::EnhancedCustomShapeParameter aSecond = aHandle.aPosition.Second;
1160  aHandle.aPosition.First = aSecond;
1161  aHandle.aPosition.Second = aFirst;
1162  }
1163  }
1164  if (bOOXMLShape)
1165  rReturnPosition = GetPoint(aHandle.aPosition, false /*bScale*/);
1166  else
1167  rReturnPosition = GetPoint(aHandle.aPosition, true /*bScale*/);
1168  }
1169  const GeoStat aGeoStat(mrSdrObjCustomShape.GetGeoStat());
1170  if ( aGeoStat.nShearAngle )
1171  {
1172  double nTan = aGeoStat.mfTanShearAngle;
1173  if (bFlipV != bFlipH)
1174  nTan = -nTan;
1175  ShearPoint( rReturnPosition, Point( aLogicRect.GetWidth() / 2, aLogicRect.GetHeight() / 2 ), nTan );
1176  }
1177  if ( nRotateAngle )
1178  {
1179  double a = toRadians(nRotateAngle);
1180  RotatePoint( rReturnPosition, Point( aLogicRect.GetWidth() / 2, aLogicRect.GetHeight() / 2 ), sin( a ), cos( a ) );
1181  }
1182  if ( bFlipH )
1183  rReturnPosition.setX( aLogicRect.GetWidth() - rReturnPosition.X() );
1184  if ( bFlipV )
1185  rReturnPosition.setY( aLogicRect.GetHeight() - rReturnPosition.Y() );
1186  rReturnPosition.Move( aLogicRect.Left(), aLogicRect.Top() );
1187  bRetValue = true;
1188  }
1189  }
1190  return bRetValue;
1191 }
1192 
1193 static double lcl_getXAdjustmentValue(std::u16string_view rShapeType, const sal_uInt32 nHandleIndex,
1194  const double fX, const double fW, const double fH)
1195 {
1196  // degenerated shapes are not worth to calculate special case for each shape type
1197  if (fW <= 0.0 || fH <= 0.0)
1198  return 50000;
1199 
1200  // pattern (w - x) / ss * 100000 or (r - x) / ss * 100000
1201  if ((rShapeType == u"ooxml-bentArrow" && nHandleIndex == 2) || (rShapeType == u"ooxml-chevron")
1202  || (rShapeType == u"ooxml-curvedRightArrow") || (rShapeType == u"ooxml-foldedCorner")
1203  || (rShapeType == u"ooxml-homePlate") || (rShapeType == u"ooxml-notchedRightArrow")
1204  || (rShapeType == u"ooxml-nonIsoscelesTrapezoid" && nHandleIndex == 1)
1205  || (rShapeType == u"ooxml-rightArrow")
1206  || (rShapeType == u"ooxml-rightArrowCallout" && nHandleIndex == 2)
1207  || (rShapeType == u"ooxml-round1Rect")
1208  || (rShapeType == u"ooxml-round2DiagRect" && nHandleIndex == 1)
1209  || (rShapeType == u"ooxml-round2SameRect" && nHandleIndex == 0)
1210  || (rShapeType == u"ooxml-snip1Rect")
1211  || (rShapeType == u"ooxml-snip2DiagRect" && nHandleIndex == 1)
1212  || (rShapeType == u"ooxml-snip2SameRect" && nHandleIndex == 0)
1213  || (rShapeType == u"ooxml-snipRoundRect" && nHandleIndex == 1)
1214  || (rShapeType == u"ooxml-swooshArrow") || (rShapeType == u"ooxml-stripedRightArrow"))
1215  return (fW - fX) / std::min(fW, fH) * 100000.0;
1216 
1217  // pattern x / ss * 100000 or (x - l) / ss * 100000
1218  if ((rShapeType == u"ooxml-bentArrow" && nHandleIndex == 0)
1219  || (rShapeType == u"ooxml-bentArrow" && nHandleIndex == 3)
1220  || (rShapeType == u"ooxml-corner")
1221  || (rShapeType == u"ooxml-curvedDownArrow") || (rShapeType == u"ooxml-curvedLeftArrow")
1222  || (rShapeType == u"ooxml-curvedUpArrow") || (rShapeType == u"ooxml-leftArrow")
1223  || (rShapeType == u"ooxml-leftArrowCallout" && nHandleIndex == 2)
1224  || (rShapeType == u"ooxml-leftRightArrow")
1225  || (rShapeType == u"ooxml-leftRightArrowCallout" && nHandleIndex == 2)
1226  || (rShapeType == u"ooxml-leftRightRibbon")
1227  || (rShapeType == u"ooxml-nonIsoscelesTrapezoid" && nHandleIndex == 0)
1228  || (rShapeType == u"ooxml-parallelogram")
1229  || (rShapeType == u"ooxml-round2DiagRect" && nHandleIndex == 0)
1230  || (rShapeType == u"ooxml-round2SameRect" && nHandleIndex == 1)
1231  || (rShapeType == u"ooxml-roundRect")
1232  || (rShapeType == u"ooxml-snip2DiagRect" && nHandleIndex == 0)
1233  || (rShapeType == u"ooxml-snip2SameRect" && nHandleIndex == 1)
1234  || (rShapeType == u"ooxml-snipRoundRect" && nHandleIndex == 0)
1235  || (rShapeType == u"ooxml-uturnArrow" && nHandleIndex == 0)
1236  || (rShapeType == u"ooxml-uturnArrow" && nHandleIndex == 3))
1237  return fX / std::min(fW, fH) * 100000.0;
1238 
1239  // pattern (hc - x) / ss * 200000
1240  if ((rShapeType == u"ooxml-downArrowCallout" && nHandleIndex == 0)
1241  || (rShapeType == u"ooxml-leftRightUpArrow" && nHandleIndex == 0)
1242  || (rShapeType == u"ooxml-quadArrow" && nHandleIndex == 0)
1243  || (rShapeType == u"ooxml-quadArrowCallout" && nHandleIndex == 0)
1244  || (rShapeType == u"ooxml-upArrowCallout" && nHandleIndex == 0)
1245  || (rShapeType == u"ooxml-upDownArrowCallout" && nHandleIndex == 0))
1246  return (fW / 2.0 - fX) / std::min(fW, fH) * 200000.0;
1247 
1248  // pattern (hc - x) / ss * 100000
1249  if ((rShapeType == u"ooxml-downArrowCallout" && nHandleIndex == 1)
1250  || (rShapeType == u"ooxml-leftRightUpArrow" && nHandleIndex == 1)
1251  || (rShapeType == u"ooxml-quadArrow" && nHandleIndex == 1)
1252  || (rShapeType == u"ooxml-quadArrowCallout" && nHandleIndex == 1)
1253  || (rShapeType == u"ooxml-upArrowCallout" && nHandleIndex == 1)
1254  || (rShapeType == u"ooxml-upDownArrowCallout" && nHandleIndex == 1))
1255  return (fW / 2.0 - fX) / std::min(fW, fH) * 100000.0;
1256 
1257  // pattern (w - x) / ss * 50000 or (r - x) / ss * 50000
1258  if ((rShapeType == u"ooxml-bentUpArrow") || (rShapeType == u"ooxml-leftUpArrow")
1259  || (rShapeType == u"ooxml-uturnArrow" && nHandleIndex == 1))
1260  return (fW - fX) / std::min(fW, fH) * 50000.0;
1261 
1262  // pattern x / ss * 200000
1263  if (rShapeType == u"ooxml-nonIsoscelesTrapezoid" && nHandleIndex == 0)
1264  return fX / std::min(fW, fH) * 200000.0;
1265 
1266  // pattern (hc - x) / w * 200000
1267  if ((rShapeType == u"ooxml-downArrow" && nHandleIndex == 0)
1268  || (rShapeType == u"ooxml-ellipseRibbon") || (rShapeType == u"ooxml-ellipseRibbon2")
1269  || (rShapeType == u"ooxml-leftRightArrowCallout" && nHandleIndex == 3)
1270  || (rShapeType == u"ooxml-ribbon") || (rShapeType == u"ooxml-ribbon2")
1271  || (rShapeType == u"ooxml-upArrow" && nHandleIndex == 0)
1272  || (rShapeType == u"ooxml-upDownArrow" && nHandleIndex == 0))
1273  return (fW / 2.0 - fX) / fW * 200000.0;
1274 
1275  // pattern (x - hc) / w * 100000
1276  if ((rShapeType == u"ooxml-cloudCallout") || (rShapeType == u"ooxml-doubleWave")
1277  || (rShapeType == u"ooxml-wave") || (rShapeType == u"ooxml-wedgeEllipseCallout")
1278  || (rShapeType == u"ooxml-wedgeRectCallout")
1279  || (rShapeType == u"ooxml-wedgeRoundRectCallout"))
1280  return (fX - fW / 2.0) / fW * 100000.0;
1281 
1282  // pattern (x - hc) / w * 200000
1283  if (rShapeType == u"ooxml-teardrop")
1284  return (fX - fW / 2.0) / fW * 200000.0;
1285 
1286  // pattern (w - x) / w * 100000 or (r - x) / w * 100000
1287  if (rShapeType == u"ooxml-leftArrowCallout" && nHandleIndex == 3)
1288  return (fW - fX) / fW * 100000.0;
1289 
1290  // pattern (hc - x) / h * 100000
1291  if (rShapeType == u"ooxml-mathDivide")
1292  return (fW / 2.0 - fX) / fH * 100000.0;
1293 
1294  // pattern x / w * 100000, simple scaling
1295  if (o3tl::starts_with(rShapeType, u"ooxml-"))
1296  return fX / fW * 100000.0;
1297 
1298  return fX; // method is unknown
1299 }
1300 
1301 static double lcl_getYAdjustmentValue(std::u16string_view rShapeType, const sal_uInt32 nHandleIndex,
1302  const double fY, const double fW, const double fH)
1303 {
1304  // degenerated shapes are not worth to calculate a special case for each shape type
1305  if (fW <= 0.0 || fH <= 0.0)
1306  return 50000;
1307 
1308  // pattern (vc - y) / ss * 100000
1309  if ((rShapeType == u"ooxml-leftArrowCallout" && nHandleIndex == 1)
1310  || (rShapeType == u"ooxml-leftRightArrowCallout" && nHandleIndex == 1)
1311  || (rShapeType == u"ooxml-rightArrowCallout" && nHandleIndex == 1))
1312  return (fH / 2.0 - fY) / std::min(fW, fH) * 100000.0;
1313 
1314  // pattern (vc - y) / ss * 200000
1315  if ((rShapeType == u"ooxml-curvedLeftArrow") || (rShapeType == u"ooxml-curvedRightArrow")
1316  || (rShapeType == u"ooxml-leftArrowCallout" && nHandleIndex == 0)
1317  || (rShapeType == u"ooxml-leftRightArrowCallout" && nHandleIndex == 0)
1318  || (rShapeType == u"ooxml-mathPlus")
1319  || (rShapeType == u"ooxml-rightArrowCallout" && nHandleIndex == 0))
1320  return (fH / 2.0 - fY) / std::min(fW, fH) * 200000.0;
1321 
1322  // pattern (h - y) / ss * 100000 or (b - y) / ss * 100000
1323  if ((rShapeType == u"ooxml-bentUpArrow" && nHandleIndex == 0) || (rShapeType == u"ooxml-corner")
1324  || (rShapeType == u"ooxml-curvedDownArrow") || (rShapeType == u"ooxml-downArrow")
1325  || (rShapeType == u"ooxml-downArrowCallout" && nHandleIndex == 2)
1326  || (rShapeType == u"ooxml-uturnArrow" && nHandleIndex == 2))
1327  return (fH - fY) / std::min(fW, fH) * 100000.0;
1328 
1329  // pattern (h - y) / ss * 200000 or (b - y) / ss * 200000
1330  if (rShapeType == u"ooxml-leftUpArrow" && nHandleIndex == 0) // - adj2 * 2 outside
1331  return (fH - fY) / std::min(fW, fH) * 200000.0;
1332 
1333  // pattern y / ss * 100000 or (y - t) / ss * 100000
1334  if ((rShapeType == u"ooxml-bentUpArrow" && nHandleIndex == 2)
1335  || (rShapeType == u"ooxml-bracePair") || (rShapeType == u"ooxml-bracketPair")
1336  || (rShapeType == u"ooxml-can") || (rShapeType == u"ooxml-cube")
1337  || (rShapeType == u"ooxml-curvedUpArrow") || (rShapeType == u"ooxml-halfFrame")
1338  || (rShapeType == u"ooxml-leftBrace" && nHandleIndex == 0)
1339  || (rShapeType == u"ooxml-leftBracket") || (rShapeType == u"ooxml-leftRightUpArrow")
1340  || (rShapeType == u"ooxml-leftUpArrow" && nHandleIndex == 2)
1341  || (rShapeType == u"ooxml-mathMultiply") || (rShapeType == u"ooxml-quadArrow")
1342  || (rShapeType == u"ooxml-quadArrowCallout" && nHandleIndex == 2)
1343  || (rShapeType == u"ooxml-rightBrace" && nHandleIndex == 0)
1344  || (rShapeType == u"ooxml-rightBracket") || (rShapeType == u"ooxml-upArrow")
1345  || (rShapeType == u"ooxml-upArrowCallout" && nHandleIndex == 2)
1346  || (rShapeType == u"ooxml-upDownArrow")
1347  || (rShapeType == u"ooxml-upDownArrowCallout" && nHandleIndex == 2)
1348  || (rShapeType == u"ooxml-verticalScroll"))
1349  return fY / std::min(fW, fH) * 100000.0;
1350 
1351  // pattern y / ss * 50000
1352  if (rShapeType == u"ooxml-bentArrow")
1353  return fY / std::min(fW, fH) * 50000.0;
1354 
1355  // pattern (vc - y) / h * 100000
1356  if ((rShapeType == u"ooxml-mathDivide" && nHandleIndex == 1) // -adj1 / 2 - adj3 outside
1357  || (rShapeType == u"ooxml-mathEqual" && nHandleIndex == 0) // -adj2 / 2 outside
1358  || (rShapeType == u"ooxml-mathNotEqual" && nHandleIndex == 0) // -adj3 / 2 outside
1359  || (rShapeType == u"ooxml-star4") || (rShapeType == u"ooxml-star6")
1360  || (rShapeType == u"ooxml-star8") || (rShapeType == u"ooxml-star10")
1361  || (rShapeType == u"ooxml-star12") || (rShapeType == u"ooxml-star16")
1362  || (rShapeType == u"ooxml-star24") || (rShapeType == u"ooxml-star32"))
1363  return (fH / 2.0 - fY) / fH * 100000.0;
1364 
1365  // pattern (vc - y) / h * 200000
1366  if ((rShapeType == u"ooxml-leftArrow") || (rShapeType == u"ooxml-leftRightArrow")
1367  || (rShapeType == u"ooxml-mathDivide" && nHandleIndex == 0)
1368  || (rShapeType == u"ooxml-mathEqual" && nHandleIndex == 1)
1369  || (rShapeType == u"ooxml-mathMinus") || (rShapeType == u"ooxml-notchedRightArrow")
1370  || (rShapeType == u"ooxml-mathNotEqual" && nHandleIndex == 2)
1371  || (rShapeType == u"ooxml-quadArrowCallout" && nHandleIndex == 3)
1372  || (rShapeType == u"ooxml-rightArrow") || (rShapeType == u"ooxml-stripedRightArrow")
1373  || (rShapeType == u"ooxml-upDownArrowCallout" && nHandleIndex == 3))
1374  return (fH / 2.0 - fY) / fH * 200000.0;
1375 
1376  // pattern (y - vc) / h * 100000
1377  if ((rShapeType == u"ooxml-cloudCallout") || (rShapeType == u"ooxml-wedgeEllipseCallout")
1378  || (rShapeType == u"ooxml-wedgeRectCallout")
1379  || (rShapeType == u"ooxml-wedgeRoundRectCallout"))
1380  return (fY - fH / 2.0) / fH * 100000.0;
1381 
1382  // pattern (h - y) / h * 100000 or (b - y) / h * 100000
1383  if ((rShapeType == u"ooxml-ellipseRibbon" && nHandleIndex == 2)
1384  || (rShapeType == u"ooxml-ellipseRibbon2" && nHandleIndex == 0)
1385  || (rShapeType == u"ooxml-ribbon2")
1386  || (rShapeType == u"ooxml-upArrowCallout" && nHandleIndex == 3))
1387  return (fH - fY) / fH * 100000.0;
1388 
1389  // special pattern smiley
1390  if (rShapeType == u"ooxml-smileyFace")
1391  return (fY - fH * 16515.0 / 21600.0) / fH * 100000.0;
1392 
1393  // special pattern for star with odd number of tips, because center of star not center of shape
1394  if (rShapeType == u"ooxml-star5")
1395  return (fH / 2.0 - fY * 100000.0 / 110557.0) / fH * 100000.0;
1396  if (rShapeType == u"ooxml-star7")
1397  return (fH / 2.0 - fY * 100000.0 / 105210.0) / fH * 100000.0;
1398 
1399  // special pattern swooshArrow
1400  if (rShapeType == u"ooxml-swooshArrow")
1401  return (fY - std::min(fW, fH) / 8.0) / fH * 100000.0;
1402 
1403  // special pattern leftRightRibbon
1404  if (rShapeType == u"ooxml-leftRightRibbon")
1405  return fY / fH * 200000 - 100000;
1406 
1407  // pattern y / h * 100000, simple scaling
1408  if (o3tl::starts_with(rShapeType, u"ooxml-"))
1409  return fY / fH * 100000.0;
1410 
1411  return fY; // method is unknown
1412 }
1413 
1414 static double lcl_getAngleInOOXMLUnit(double fDY, double fDX)
1415 {
1416  if (fDX != 0.0 || fDY != 0.0)
1417  {
1418  double fAngleRad(atan2(fDY, fDX));
1419  double fAngle = basegfx::rad2deg(fAngleRad);
1420  // atan2 returns angle in ]-pi; pi], OOXML preset shapes use [0;360[.
1421  if (fAngle < 0.0)
1422  fAngle += 360.0;
1423  // OOXML uses angle unit 1/60000 degree.
1424  fAngle *= 60000.0;
1425  return fAngle;
1426  }
1427  return 0.0; // no angle defined for origin in polar coordinate system
1428 }
1429 
1430 static double lcl_getRadiusDistance(double fWR, double fHR, double fX, double fY)
1431 {
1432  // Get D so, that point (fX|fY) is on the ellipse, that has width fWR-D and
1433  // height fHR-D and center in origin.
1434  // Get solution of ellipse equation (fX/(fWR-D))^2 + (fY/(fHR-D)^2 = 1 by solving
1435  // fX^2*(fHR-D)^2 + fY^2*(fWR-D)^2 - (fWR-D)^2 * (fHR-D)^2 = 0 with Newton-method.
1436  if (fX == 0.0)
1437  return std::min(fHR - fY, fWR);
1438  else if (fY == 0.0)
1439  return std::min(fWR - fX, fHR);
1440 
1441  double fD = std::min(fWR, fHR) - sqrt(fX * fX + fY * fY); // iteration start value
1442  sal_uInt8 nIter(0);
1443  bool bFound(false);
1444  do
1445  {
1446  ++nIter;
1447  const double fOldD(fD);
1448  const double fWRmD(fWR - fD);
1449  const double fHRmD(fHR - fD);
1450  double fNumerator
1451  = fX * fX * fHRmD * fHRmD + fY * fY * fWRmD * fWRmD - fWRmD * fWRmD * fHRmD * fHRmD;
1452  double fDenominator
1453  = 2.0 * (fHRmD * (fWRmD * fWRmD - fX * fX) + fWRmD * (fHRmD * fHRmD - fY * fY));
1454  if (fDenominator != 0.0)
1455  {
1456  fD = fD - fNumerator / fDenominator;
1457  bFound = fabs(fOldD - fD) < 1.0E-12;
1458  }
1459  else
1460  fD = fD * 0.9; // new start value
1461  } while (nIter < 50 && !bFound);
1462  return fD;
1463 }
1464 
1465 bool EnhancedCustomShape2d::SetHandleControllerPosition( const sal_uInt32 nIndex, const css::awt::Point& rPosition )
1466 {
1467  // The method name is misleading. Essentially it calculates the adjustment values from a given
1468  // handle position.
1469 
1470  // For ooxml-foo shapes, the way to calculate the adjustment value from the handle position depends on
1471  // the type of the shape, therefore need 'Type'.
1472  OUString sShapeType("non-primitive"); // default for ODF
1473  const SdrCustomShapeGeometryItem& rGeometryItem(mrSdrObjCustomShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ));
1474  const Any* pAny = rGeometryItem.GetPropertyValueByName("Type");
1475  if (pAny)
1476  *pAny >>= sShapeType;
1477 
1478  bool bRetValue = false;
1479  if ( nIndex < GetHdlCount() )
1480  {
1481  Handle aHandle;
1482  if ( ConvertSequenceToEnhancedCustomShape2dHandle( seqHandles[ nIndex ], aHandle ) )
1483  {
1484  Point aP( rPosition.X, rPosition.Y );
1485  // apply the negative object rotation to the controller position
1486 
1487  aP.Move( -aLogicRect.Left(), -aLogicRect.Top() );
1488  if ( bFlipH )
1489  aP.setX( aLogicRect.GetWidth() - aP.X() );
1490  if ( bFlipV )
1491  aP.setY( aLogicRect.GetHeight() - aP.Y() );
1492  if ( nRotateAngle )
1493  {
1494  double a = -toRadians(nRotateAngle);
1495  RotatePoint( aP, Point( aLogicRect.GetWidth() / 2, aLogicRect.GetHeight() / 2 ), sin( a ), cos( a ) );
1496  }
1497  const GeoStat aGeoStat(mrSdrObjCustomShape.GetGeoStat());
1498  if ( aGeoStat.nShearAngle )
1499  {
1500  double nTan = -aGeoStat.mfTanShearAngle;
1501  if (bFlipV != bFlipH)
1502  nTan = -nTan;
1503  ShearPoint( aP, Point( aLogicRect.GetWidth() / 2, aLogicRect.GetHeight() / 2 ), nTan );
1504  }
1505 
1506  double fPos1 = aP.X(); //( bFlipH ) ? aLogicRect.GetWidth() - aP.X() : aP.X();
1507  double fPos2 = aP.Y(); //( bFlipV ) ? aLogicRect.GetHeight() -aP.Y() : aP.Y();
1508  fPos1 = !basegfx::fTools::equalZero(fXScale) ? (fPos1 / fXScale) : SAL_MAX_INT32;
1509  fPos2 = !basegfx::fTools::equalZero(fYScale) ? (fPos2 / fYScale) : SAL_MAX_INT32;
1510  // revert -nCoordLeft and -nCoordTop aus GetPoint()
1511  fPos1 += nCoordLeft;
1512  fPos2 += nCoordTop;
1513 
1514  // Used for scaling the adjustment values based on handle positions
1515  double fWidth;
1516  double fHeight;
1517 
1518  if ( nCoordWidth || nCoordHeight )
1519  {
1520  fWidth = nCoordWidth;
1521  fHeight = nCoordHeight;
1522  }
1523  else
1524  {
1525  fWidth = aLogicRect.GetWidth();
1526  fHeight = aLogicRect.GetHeight();
1527  }
1528 
1529  if ( aHandle.nFlags & HandleFlags::SWITCHED )
1530  {
1531  if ( aLogicRect.GetHeight() > aLogicRect.GetWidth() )
1532  {
1533  double fX = fPos1;
1534  double fY = fPos2;
1535  double fTmp = fWidth;
1536  fPos1 = fY;
1537  fPos2 = fX;
1538  fHeight = fWidth;
1539  fWidth = fTmp;
1540  }
1541  }
1542 
1543  sal_Int32 nFirstAdjustmentValue = -1, nSecondAdjustmentValue = -1;
1544 
1545  // ODF shapes are expected to use a direct binding between position and adjustment
1546  // values. OOXML preset shapes use known formulas. These are calculated backward to
1547  // get the adjustment values. So far we do not have a general method to calculate
1548  // the adjustment values for any shape from the handle position.
1549  if ( aHandle.aPosition.First.Type == EnhancedCustomShapeParameterType::ADJUSTMENT )
1550  aHandle.aPosition.First.Value >>= nFirstAdjustmentValue;
1551  if ( aHandle.aPosition.Second.Type == EnhancedCustomShapeParameterType::ADJUSTMENT )
1552  aHandle.aPosition.Second.Value>>= nSecondAdjustmentValue;
1553 
1554  if ( aHandle.nFlags & ( HandleFlags::POLAR | HandleFlags::REFR | HandleFlags::REFANGLE))
1555  { // Polar-Handle
1556 
1557  if (aHandle.nFlags & HandleFlags::REFR)
1558  nFirstAdjustmentValue = aHandle.nRefR;
1559  if (aHandle.nFlags & HandleFlags::REFANGLE)
1560  nSecondAdjustmentValue = aHandle.nRefAngle;
1561 
1562  double fAngle(0.0);
1563  double fRadius(0.0);
1564  // 'then' treats only shapes of type "ooxml-foo", fontwork shapes have been mapped
1565  // to MS binary import and will be treated in 'else'.
1566  if (bOOXMLShape)
1567  {
1568  // DrawingML polar handles set REFR or REFANGLE instead of POLAR
1569  // use the shape center instead.
1570  double fDX = fPos1 - fWidth / 2.0;
1571  double fDY = fPos2 - fHeight / 2.0;
1572 
1573  // There exists no common pattern. 'radius' or 'angle' might have special meaning.
1574  if (sShapeType == "ooxml-blockArc" && nIndex == 1)
1575  {
1576  // usual angle, special radius
1577  fAngle = lcl_getAngleInOOXMLUnit(fDY, fDX);
1578  // The value connected to REFR is the _difference_ between the outer
1579  // ellipse given by shape width and height and the inner ellipse through
1580  // the handle position.
1581  double fRadiusDifference
1582  = lcl_getRadiusDistance(fWidth / 2.0, fHeight / 2.0, fDX, fDY);
1583  double fss(std::min(fWidth, fHeight));
1584  if (fss != 0)
1585  fRadius = fRadiusDifference * 100000.0 / fss;
1586  }
1587  else if (sShapeType == "ooxml-donut" || sShapeType == "ooxml-noSmoking")
1588  {
1589  // no angle adjustment, radius bound to x-coordinate of handle
1590  double fss(std::min(fWidth, fHeight));
1591  if (fss != 0.0)
1592  fRadius = fPos1 * 100000.0 / fss;
1593  }
1594  else if ((sShapeType == "ooxml-circularArrow"
1595  || sShapeType == "ooxml-leftRightCircularArrow"
1596  || sShapeType == "ooxml-leftCircularArrow")
1597  && nIndex == 0)
1598  {
1599  // The value adj2 is the increase compared to the angle in adj3
1600  double fHandleAngle = lcl_getAngleInOOXMLUnit(fDY, fDX);
1601  if (sShapeType == "ooxml-leftCircularArrow")
1602  fAngle = GetAdjustValueAsDouble(2) - fHandleAngle;
1603  else
1604  fAngle = fHandleAngle - GetAdjustValueAsDouble(2);
1605  if (fAngle < 0.0) // 0deg to 360deg cut
1606  fAngle += 21600000.0;
1607  // no REFR
1608  }
1609  else if ((sShapeType == "ooxml-circularArrow"
1610  || sShapeType == "ooxml-leftCircularArrow"
1611  || sShapeType == "ooxml-leftRightCircularArrow")
1612  && nIndex == 2)
1613  {
1614  // The value adj1 connected to REFR is the thickness of the arc. The adjustvalue adj5
1615  // has the _difference_ between the outer ellipse given by shape width and height
1616  // and the middle ellipse of the arc. The handle is on the outer side of the
1617  // arc. So we calculate the difference between the ellipse through the handle
1618  // and the outer ellipse and subtract then.
1619  double fRadiusDifferenceHandle
1620  = lcl_getRadiusDistance(fWidth / 2.0, fHeight / 2.0, fDX, fDY);
1621  double fadj5(GetAdjustValueAsDouble(4));
1622  double fss(std::min(fWidth, fHeight));
1623  if (fss != 0.0)
1624  {
1625  fadj5 = fadj5 * fss / 100000.0;
1626  fRadius = 2.0 * (fadj5 - fRadiusDifferenceHandle);
1627  fRadius = fRadius * 100000.0 / fss;
1628  }
1629  // ToDo: Get angle adj3 exact. Use approximation for now
1630  fAngle = lcl_getAngleInOOXMLUnit(fDY, fDX);
1631  }
1632  else if ((sShapeType == "ooxml-circularArrow"
1633  || sShapeType == "ooxml-leftCircularArrow"
1634  || sShapeType == "ooxml-leftRightCircularArrow")
1635  && nIndex == 3)
1636  {
1637  // ToDo: Getting handle position from adjustment value adj5 is complex.
1638  // Analytical or numerical solution for backward calculation is missing.
1639  // Approximation for now, using a line from center through handle position.
1640  double fAngleRad(0.0);
1641  if (fDX != 0.0 || fDY != 0.0)
1642  fAngleRad = atan2(fDY, fDX);
1643  double fHelpX = cos(fAngleRad) * fHeight / 2.0;
1644  double fHelpY = sin(fAngleRad) * fWidth / 2.0;
1645  if (fHelpX != 0.0 || fHelpY != 0.0)
1646  {
1647  double fHelpAngle = atan2(fHelpY, fHelpX);
1648  double fOuterX = fWidth / 2.0 * cos(fHelpAngle);
1649  double fOuterY = fHeight / 2.0 * sin(fHelpAngle);
1650  double fOuterRadius = sqrt(fOuterX * fOuterX + fOuterY * fOuterY);
1651  double fHandleRadius = sqrt(fDX * fDX + fDY * fDY);
1652  fRadius = (fOuterRadius - fHandleRadius) / 2.0;
1653  double fss(std::min(fWidth, fHeight));
1654  if (fss != 0.0)
1655  fRadius = fRadius * 100000.0 / fss;
1656  }
1657  // no REFANGLE
1658  }
1659  else if (sShapeType == "ooxml-mathNotEqual" && nIndex == 1)
1660  {
1661  double fadj1(GetAdjustValueAsDouble(0));
1662  double fadj3(GetAdjustValueAsDouble(2));
1663  fadj1 = fadj1 * fHeight / 100000.0;
1664  fadj3 = fadj3 * fHeight / 100000.0;
1665  double fDYRefHorizBar = fDY + fadj1 + fadj3;
1666  if (fDX != 0.0 || fDYRefHorizBar != 0.0)
1667  {
1668  double fRawAngleDeg = basegfx::rad2deg(atan2(fDYRefHorizBar, fDX));
1669  fAngle = (fRawAngleDeg + 180.0) * 60000.0;
1670  }
1671  // no REFR
1672  }
1673  else
1674  {
1675  // no special meaning of radius or angle, suitable for "ooxml-arc",
1676  // "ooxml-chord", "ooxml-pie" and circular arrows value adj4.
1677  fAngle = lcl_getAngleInOOXMLUnit(fDY, fDX);
1678  fRadius = sqrt(fDX * fDX + fDY * fDY);
1679  double fss(std::min(fWidth, fHeight));
1680  if (fss != 0.0)
1681  fRadius = fRadius * 100000.0 / fss;
1682  }
1683  }
1684  else // e.g. shapes from ODF, MS binary import or shape type "fontwork-foo"
1685  {
1686  double fXRef, fYRef;
1687  if (aHandle.nFlags & HandleFlags::POLAR)
1688  {
1689  GetParameter(fXRef, aHandle.aPolar.First, false, false);
1690  GetParameter(fYRef, aHandle.aPolar.Second, false, false);
1691  }
1692  else
1693  {
1694  fXRef = fWidth / 2.0;
1695  fYRef = fHeight / 2.0;
1696  }
1697  const double fDX = fPos1 - fXRef;
1698  const double fDY = fPos2 - fYRef;
1699  // ToDo: MS binary uses fixed-point number for the angle. Make sure conversion
1700  // to double is done in import and export.
1701  // ToDo: Angle unit is degree, but range ]-180;180] or [0;360[? Assume ]-180;180].
1702  if (fDX != 0.0 || fDY != 0.0)
1703  {
1704  fRadius = sqrt(fDX * fDX + fDY * fDY);
1705  fAngle = basegfx::rad2deg(atan2(fDY, fDX));
1706  }
1707  }
1708 
1709  // All formats can restrict the radius to a range
1710  if ( aHandle.nFlags & HandleFlags::RADIUS_RANGE_MINIMUM )
1711  {
1712  double fMin;
1713  GetParameter( fMin, aHandle.aRadiusRangeMinimum, false, false );
1714  if ( fRadius < fMin )
1715  fRadius = fMin;
1716  }
1717  if ( aHandle.nFlags & HandleFlags::RADIUS_RANGE_MAXIMUM )
1718  {
1719  double fMax;
1720  GetParameter( fMax, aHandle.aRadiusRangeMaximum, false, false );
1721  if ( fRadius > fMax )
1722  fRadius = fMax;
1723  }
1724 
1725  if ( nFirstAdjustmentValue >= 0 )
1726  SetAdjustValueAsDouble( fRadius, nFirstAdjustmentValue );
1727  if ( nSecondAdjustmentValue >= 0 )
1728  SetAdjustValueAsDouble( fAngle, nSecondAdjustmentValue );
1729  }
1730  else // XY-Handle
1731  {
1732  // Calculating the adjustment values follows in most cases some patterns, which only
1733  // need width and height of the shape and handle position. These patterns are calculated
1734  // in the static, local methods. More complex calculations or additional steps are
1735  // done here.
1736  // Values for corner cases like 'root(negative)' or 'div zero' are meaningless dummies.
1737  // Identifiers often refer to guide names in OOXML shape definitions.
1738  double fAdjustX = fPos1;
1739  double fAdjustY = fPos2;
1740  if (aHandle.nFlags & HandleFlags::REFX)
1741  {
1742  nFirstAdjustmentValue = aHandle.nRefX;
1743  if ((sShapeType == "ooxml-gear6") || (sShapeType == "ooxml-gear9"))
1744  {
1745  // special, needs angle calculations
1746  double fss(std::min(fWidth, fHeight));
1747  double fadj1(GetAdjustValueAsDouble(0)); // from point D6 or D9
1748  double fth(fadj1 * fss / 100000.0); // radius difference
1749  double frw(fWidth / 2.0 - fth); // inner ellipse
1750  double frh(fHeight / 2.0 - fth);
1751  double fDX(fPos1 - fWidth / 2.0);
1752  double fDY(fPos2 - fHeight / 2.0);
1753  double fbA(-1.7); // effective angle for point A6 or A9, dummy value
1754  if (fDX != 0.0 || fDY != 0.0)
1755  fbA = atan2(fDY, fDX);
1756  double faA(fbA); // corresponding circle angle, dummy value
1757  double ftmpX(frh * cos(fbA));
1758  double ftmpY(frw * sin(fbA));
1759  if (ftmpX != 0.0 || ftmpY != 0.0)
1760  faA = atan2(ftmpY, ftmpX); // range ]-pi..pi], here -pi < faA < -pi/2
1761  // screen 270 deg = mathematic coordinate system -pi/2
1762  double fha(-F_PI2 - faA); // positive circle angle difference to 270 deg
1763  if (abs(fha) == F_PI2) // should not happen, but ensure no tan(90deg)
1764  fha = 0.12; // dummy value
1765  double flFD(2 * std::min(frw, frh) * tan(fha) - fth);
1766  if (fss != 0.0)
1767  fAdjustX = flFD / fss * 100000.0;
1768  }
1769  else
1770  {
1771  fAdjustX
1772  = lcl_getXAdjustmentValue(sShapeType, nIndex, fPos1, fWidth, fHeight);
1773  if ((sShapeType == "ooxml-curvedDownArrow")
1774  || (sShapeType == "ooxml-curvedUpArrow"))
1775  {
1776  double fss(std::min(fWidth, fHeight));
1777  if (fss != 0.0)
1778  {
1779  double fadj3(GetAdjustValueAsDouble(2));
1780  double fHScaled(100000.0 * fHeight / fss);
1781  double fRadicand(fHScaled * fHScaled - fadj3 * fadj3);
1782  double fSqrt = fRadicand >= 0.0 ? sqrt(fRadicand) : 0.0;
1783  double fPart(200000.0 * fWidth / fss * (fSqrt + fHScaled));
1784  fAdjustX = fPart - 4.0 * fHScaled * fAdjustX;
1785  if (nIndex == 0)
1786  {
1787  // calculate adj1
1788  double fadj2(GetAdjustValueAsDouble(1));
1789  fAdjustX = fAdjustX - fadj2 * (fSqrt + fHScaled);
1790  double fDenominator(fSqrt - 3.0 * fHScaled);
1791  fAdjustX /= fDenominator != 0.0 ? fDenominator : 1.0;
1792  }
1793  else
1794  {
1795  // nIndex == 1, calculate adj2
1796  double fadj1(GetAdjustValueAsDouble(0));
1797  fAdjustX = fAdjustX - fadj1 * (fSqrt - fHScaled);
1798  double fDenominator(fSqrt + 3.0 * fHScaled);
1799  fAdjustX /= fDenominator != 0.0 ? fDenominator : 1.0;
1800  }
1801  }
1802  }
1803  }
1804  }
1805 
1806  if (aHandle.nFlags & HandleFlags::REFY)
1807  {
1808  nSecondAdjustmentValue = aHandle.nRefY;
1809  if ((sShapeType == "ooxml-gear6") || (sShapeType == "ooxml-gear9"))
1810  {
1811  // special, acts more like a polar handle radius
1812  double fDX = fPos1 - fWidth / 2.0;
1813  double fDY = fPos2 - fHeight / 2.0;
1814  double fRadiusDifference
1815  = lcl_getRadiusDistance(fWidth / 2.0, fHeight / 2.0, fDX, fDY);
1816  double fss(std::min(fWidth, fHeight));
1817  if (fss != 0)
1818  fAdjustY = fRadiusDifference / fss * 100000.0;
1819  }
1820  else
1821  {
1822  fAdjustY
1823  = lcl_getYAdjustmentValue(sShapeType, nIndex, fPos2, fWidth, fHeight);
1824  if (sShapeType == "ooxml-mathDivide" && nIndex == 1)
1825  fAdjustY = fAdjustY - GetAdjustValueAsDouble(0) / 2.0
1826  - GetAdjustValueAsDouble(2);
1827  else if (sShapeType == "ooxml-mathEqual" && nIndex == 0)
1828  fAdjustY -= GetAdjustValueAsDouble(1) / 2.0;
1829  else if (sShapeType == "ooxml-mathNotEqual" && nIndex == 0)
1830  fAdjustY -= GetAdjustValueAsDouble(2) / 2.0;
1831  else if (sShapeType == "ooxml-leftUpArrow" && nIndex == 0)
1832  fAdjustY -= GetAdjustValueAsDouble(1) * 2.0;
1833  else if ((sShapeType == "ooxml-curvedRightArrow")
1834  || (sShapeType == "ooxml-curvedLeftArrow"))
1835  {
1836  double fss(std::min(fWidth, fHeight));
1837  if (fss != 0.0)
1838  {
1839  double fadj3(GetAdjustValueAsDouble(2));
1840  double fWScaled(100000.0 * fWidth / fss);
1841  double fRadicand(fWScaled * fWScaled - fadj3 * fadj3);
1842  double fSqrt = fRadicand >= 0.0 ? sqrt(fRadicand) : 0.0;
1843  if (nIndex == 0)
1844  {
1845  // calculate adj1
1846  double fadj2(GetAdjustValueAsDouble(1));
1847  fAdjustY = fWScaled * (2.0 * fAdjustY - fadj2);
1848  fAdjustY += (200000.0 / fss * fHeight - fadj2) * fSqrt;
1849  double fDenominator(fSqrt + fWScaled);
1850  fAdjustY /= fDenominator != 0.0 ? fDenominator : 1.0;
1851  }
1852  else
1853  {
1854  // nIndex == 1, calculate adj2
1855  double fadj1(GetAdjustValueAsDouble(0));
1856  fAdjustY = fWScaled * (2.0 * fAdjustY + fadj1);
1857  fAdjustY += (200000.0 / fss * fHeight - fadj1) * fSqrt;
1858  double fDenominator(fSqrt + 3.0 * fWScaled);
1859  fAdjustY /= fDenominator != 0.0 ? fDenominator : 1.0;
1860  }
1861  }
1862  }
1863  else if (sShapeType == "ooxml-uturnArrow" && nIndex == 2)
1864  {
1865  double fss(std::min(fWidth, fHeight));
1866  if (fss != 0.0)
1867  {
1868  double fadj5(GetAdjustValueAsDouble(4));
1869  fAdjustY += fHeight / fss * (fadj5 - 100000.0);
1870  }
1871  }
1872  else if (sShapeType == "ooxml-leftRightRibbon")
1873  {
1874  if (nIndex == 0)
1875  fAdjustY = GetAdjustValueAsDouble(2) - fAdjustY;
1876  else // nIndex == 2
1877  fAdjustY = GetAdjustValueAsDouble(0) + fAdjustY;
1878  }
1879  }
1880  }
1881 
1882  if ( nFirstAdjustmentValue >= 0 )
1883  {
1884  if ( aHandle.nFlags & HandleFlags::RANGE_X_MINIMUM ) // check if horizontal handle needs to be within a range
1885  {
1886  double fXMin;
1887  GetParameter( fXMin, aHandle.aXRangeMinimum, false, false );
1888  if (fAdjustX < fXMin)
1889  fAdjustX = fXMin;
1890  }
1891  if ( aHandle.nFlags & HandleFlags::RANGE_X_MAXIMUM ) // check if horizontal handle needs to be within a range
1892  {
1893  double fXMax;
1894  GetParameter( fXMax, aHandle.aXRangeMaximum, false, false );
1895  if (fAdjustX > fXMax)
1896  fAdjustX = fXMax;
1897  }
1898  SetAdjustValueAsDouble(fAdjustX, nFirstAdjustmentValue);
1899  }
1900  if ( nSecondAdjustmentValue >= 0 )
1901  {
1902  if ( aHandle.nFlags & HandleFlags::RANGE_Y_MINIMUM ) // check if vertical handle needs to be within a range
1903  {
1904  double fYMin;
1905  GetParameter( fYMin, aHandle.aYRangeMinimum, false, false );
1906  if (fAdjustY < fYMin)
1907  fAdjustY = fYMin;
1908  }
1909  if ( aHandle.nFlags & HandleFlags::RANGE_Y_MAXIMUM ) // check if vertical handle needs to be within a range
1910  {
1911  double fYMax;
1912  GetParameter( fYMax, aHandle.aYRangeMaximum, false, false );
1913  if (fAdjustY > fYMax)
1914  fAdjustY = fYMax;
1915  }
1916  SetAdjustValueAsDouble(fAdjustY, nSecondAdjustmentValue);
1917  }
1918  }
1919  // and writing them back into the GeometryItem
1920  SdrCustomShapeGeometryItem aGeometryItem(mrSdrObjCustomShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ));
1921  css::beans::PropertyValue aPropVal;
1922  aPropVal.Name = "AdjustmentValues";
1923  aPropVal.Value <<= seqAdjustmentValues;
1924  aGeometryItem.SetPropertyValue( aPropVal );
1925  mrSdrObjCustomShape.SetMergedItem( aGeometryItem );
1926  bRetValue = true;
1927  }
1928  }
1929  return bRetValue;
1930 }
1931 
1932 void EnhancedCustomShape2d::SwapStartAndEndArrow( SdrObject* pObj ) //#108274
1933 {
1934  XLineStartItem aLineStart;
1935  aLineStart.SetLineStartValue(pObj->GetMergedItem( XATTR_LINEEND ).GetLineEndValue());
1936  XLineStartWidthItem aLineStartWidth(pObj->GetMergedItem( XATTR_LINEENDWIDTH ).GetValue());
1937  XLineStartCenterItem aLineStartCenter(pObj->GetMergedItem( XATTR_LINEENDCENTER ).GetValue());
1938 
1939  XLineEndItem aLineEnd;
1940  aLineEnd.SetLineEndValue(pObj->GetMergedItem( XATTR_LINESTART ).GetLineStartValue());
1941  XLineEndWidthItem aLineEndWidth(pObj->GetMergedItem( XATTR_LINESTARTWIDTH ).GetValue());
1942  XLineEndCenterItem aLineEndCenter(pObj->GetMergedItem( XATTR_LINESTARTCENTER ).GetValue());
1943 
1944  pObj->SetMergedItem( aLineStart );
1945  pObj->SetMergedItem( aLineStartWidth );
1946  pObj->SetMergedItem( aLineStartCenter );
1947  pObj->SetMergedItem( aLineEnd );
1948  pObj->SetMergedItem( aLineEndWidth );
1949  pObj->SetMergedItem( aLineEndCenter );
1950 }
1951 
1952 static basegfx::B2DPolygon CreateArc( const tools::Rectangle& rRect, const Point& rStart, const Point& rEnd, const bool bClockwise )
1953 {
1954  tools::Rectangle aRect( rRect );
1955  Point aStart( rStart );
1956  Point aEnd( rEnd );
1957 
1958  sal_Int32 bSwapStartEndAngle = 0;
1959 
1960  if ( aRect.Left() > aRect.Right() )
1961  bSwapStartEndAngle ^= 0x01;
1962  if ( aRect.Top() > aRect.Bottom() )
1963  bSwapStartEndAngle ^= 0x11;
1964  if ( bSwapStartEndAngle )
1965  {
1966  aRect.Justify();
1967  if ( bSwapStartEndAngle & 1 )
1968  {
1969  Point aTmp( aStart );
1970  aStart = aEnd;
1971  aEnd = aTmp;
1972  }
1973  }
1974 
1975  tools::Polygon aTempPoly( aRect, aStart, aEnd, PolyStyle::Arc );
1976  basegfx::B2DPolygon aRetval;
1977 
1978  if ( bClockwise )
1979  {
1980  for ( sal_uInt16 j = aTempPoly.GetSize(); j--; )
1981  {
1982  aRetval.append(basegfx::B2DPoint(aTempPoly[ j ].X(), aTempPoly[ j ].Y()));
1983  }
1984  }
1985  else
1986  {
1987  for ( sal_uInt16 j = 0; j < aTempPoly.GetSize(); j++ )
1988  {
1989  aRetval.append(basegfx::B2DPoint(aTempPoly[ j ].X(), aTempPoly[ j ].Y()));
1990  }
1991  }
1992 
1993  return aRetval;
1994 }
1995 
1996 static double lcl_getNormalizedCircleAngleRad(const double fWR, const double fHR, const double fEllipseAngleDeg)
1997 {
1998  double fRet(0.0);
1999  double fEAngleDeg(fmod(fEllipseAngleDeg, 360.0));
2000  if (fEAngleDeg < 0.0)
2001  fEAngleDeg += 360.0;
2002  if (fEAngleDeg == 0.0 || fEAngleDeg == 90.0 || fEAngleDeg == 180.0 || fEAngleDeg == 270.0)
2003  return basegfx::deg2rad(fEAngleDeg);
2004  const double fX(fHR * cos(basegfx::deg2rad(fEAngleDeg)));
2005  const double fY(fWR * sin(basegfx::deg2rad(fEAngleDeg)));
2006  if (fX != 0.0 || fY != 0.0)
2007  {
2008  fRet = atan2(fY, fX);
2009  if (fRet < 0.0)
2010  fRet += F_2PI;
2011  }
2012  return fRet;
2013 }
2014 
2015 static double lcl_getNormalizedAngleRad(const double fCircleAngleDeg)
2016 {
2017  double fRet(fmod(fCircleAngleDeg, 360.0));
2018  if (fRet < 0.0)
2019  fRet += 360.0;
2020  return basegfx::deg2rad(fRet);
2021 }
2022 
2023 void EnhancedCustomShape2d::CreateSubPath(
2024  sal_Int32& rSrcPt,
2025  sal_Int32& rSegmentInd,
2026  std::vector< std::pair< SdrPathObjUniquePtr, double> >& rObjectList,
2027  const bool bLineGeometryNeededOnly,
2028  const bool bSortFilledObjectsToBack,
2029  sal_Int32 nIndex)
2030 {
2031  bool bNoFill = false;
2032  bool bNoStroke = false;
2033  double dBrightness = 0.0; //no blending
2034 
2035  basegfx::B2DPolyPolygon aNewB2DPolyPolygon;
2036  basegfx::B2DPolygon aNewB2DPolygon;
2037 
2038  SetPathSize( nIndex );
2039 
2040  sal_Int32 nSegInfoSize = seqSegments.getLength();
2041  if ( !nSegInfoSize )
2042  {
2043  for ( const EnhancedCustomShapeParameterPair& rCoordinate : std::as_const(seqCoordinates) )
2044  {
2045  const Point aTempPoint(GetPoint( rCoordinate, true, true ));
2046  aNewB2DPolygon.append(basegfx::B2DPoint(aTempPoint.X(), aTempPoint.Y()));
2047  }
2048 
2049  aNewB2DPolygon.setClosed(true);
2050  }
2051  else
2052  {
2053  sal_Int32 nCoordSize = seqCoordinates.getLength();
2054  for ( ;rSegmentInd < nSegInfoSize; )
2055  {
2056  sal_Int16 nCommand = seqSegments[ rSegmentInd ].Command;
2057  sal_Int16 nPntCount= seqSegments[ rSegmentInd++ ].Count;
2058 
2059  switch ( nCommand )
2060  {
2061  case NOFILL :
2062  bNoFill = true;
2063  break;
2064  case NOSTROKE :
2065  bNoStroke = true;
2066  break;
2067  case DARKEN :
2068  dBrightness = -0.4; //use sign to distinguish DARKEN from LIGHTEN
2069  break;
2070  case DARKENLESS :
2071  dBrightness = -0.2;
2072  break;
2073  case LIGHTEN :
2074  dBrightness = 0.4;
2075  break;
2076  case LIGHTENLESS :
2077  dBrightness = 0.2;
2078  break;
2079  case MOVETO :
2080  {
2081  if(aNewB2DPolygon.count() > 1)
2082  {
2083  // #i76201# Add conversion to closed polygon when first and last points are equal
2084  basegfx::utils::checkClosed(aNewB2DPolygon);
2085  aNewB2DPolyPolygon.append(aNewB2DPolygon);
2086  }
2087 
2088  aNewB2DPolygon.clear();
2089 
2090  if ( rSrcPt < nCoordSize )
2091  {
2092  const Point aTempPoint(GetPoint( seqCoordinates[ rSrcPt++ ], true, true ));
2093  SAL_INFO(
2094  "svx",
2095  "moveTo: " << aTempPoint.X() << ","
2096  << aTempPoint.Y());
2097  aNewB2DPolygon.append(basegfx::B2DPoint(aTempPoint.X(), aTempPoint.Y()));
2098  }
2099  }
2100  break;
2101  case ENDSUBPATH :
2102  break;
2103  case CLOSESUBPATH :
2104  {
2105  if(aNewB2DPolygon.count())
2106  {
2107  if(aNewB2DPolygon.count() > 1)
2108  {
2109  aNewB2DPolygon.setClosed(true);
2110  aNewB2DPolyPolygon.append(aNewB2DPolygon);
2111  }
2112 
2113  aNewB2DPolygon.clear();
2114  }
2115  }
2116  break;
2117  case CURVETO :
2118  {
2119  for ( sal_uInt16 i = 0; ( i < nPntCount ) && ( ( rSrcPt + 2 ) < nCoordSize ); i++ )
2120  {
2121  const Point aControlA(GetPoint( seqCoordinates[ rSrcPt++ ], true, true ));
2122  const Point aControlB(GetPoint( seqCoordinates[ rSrcPt++ ], true, true ));
2123  const Point aEnd(GetPoint( seqCoordinates[ rSrcPt++ ], true, true ));
2124 
2125  DBG_ASSERT(aNewB2DPolygon.count(), "EnhancedCustomShape2d::CreateSubPath: Error in adding control point (!)");
2126  aNewB2DPolygon.appendBezierSegment(
2127  basegfx::B2DPoint(aControlA.X(), aControlA.Y()),
2128  basegfx::B2DPoint(aControlB.X(), aControlB.Y()),
2129  basegfx::B2DPoint(aEnd.X(), aEnd.Y()));
2130  }
2131  }
2132  break;
2133 
2134  case ANGLEELLIPSE: // command U
2135  case ANGLEELLIPSETO: // command T
2136  {
2137  // Some shapes will need special handling, decide on property 'Type'.
2138  OUString sShpType;
2139  SdrCustomShapeGeometryItem& rGeometryItem = const_cast<SdrCustomShapeGeometryItem&>(mrSdrObjCustomShape.GetMergedItem(SDRATTR_CUSTOMSHAPE_GEOMETRY));
2140  Any* pAny = rGeometryItem.GetPropertyValueByName("Type");
2141  if (pAny)
2142  *pAny >>= sShpType;
2143  // User defined shapes in MS binary format, which contain command U or T after import
2144  // in LibreOffice, starts with "mso".
2145  const bool bIsFromBinaryImport(sShpType.startsWith("mso"));
2146  // The only own or imported preset shapes with U command are those listed below.
2147  // Command T is not used in preset shapes.
2148  const std::unordered_set<OUString> aPresetShapesWithU =
2149  { "ellipse", "ring", "smiley", "sun", "forbidden", "flowchart-connector",
2150  "flowchart-summing-junction", "flowchart-or", "cloud-callout"};
2151  std::unordered_set<OUString>::const_iterator aIter = aPresetShapesWithU.find(sShpType);
2152  const bool bIsPresetShapeWithU(aIter != aPresetShapesWithU.end());
2153 
2154  for (sal_uInt16 i = 0; (i < nPntCount) && ((rSrcPt + 2) < nCoordSize); i++)
2155  {
2156  // ANGLEELLIPSE is the same as ANGLEELLIPSETO, only that it
2157  // makes an implicit MOVETO. That ends the previous subpath.
2158  if (ANGLEELLIPSE == nCommand)
2159  {
2160  if (aNewB2DPolygon.count() > 1)
2161  {
2162  // #i76201# Add conversion to closed polygon when first and last points are equal
2163  basegfx::utils::checkClosed(aNewB2DPolygon);
2164  aNewB2DPolyPolygon.append(aNewB2DPolygon);
2165  }
2166  aNewB2DPolygon.clear();
2167  }
2168 
2169  // Read all parameters, but do not finally handle them.
2170  basegfx::B2DPoint aCenter(GetPointAsB2DPoint(seqCoordinates[ rSrcPt ], true, true));
2171  double fWR; // horizontal ellipse radius
2172  double fHR; // vertical ellipse radius
2173  GetParameter(fWR, seqCoordinates[rSrcPt + 1].First, true, false);
2174  GetParameter(fHR, seqCoordinates[rSrcPt + 1].Second, false, true);
2175  double fStartAngle;
2176  GetParameter(fStartAngle, seqCoordinates[rSrcPt + 2].First, false, false);
2177  double fEndAngle;
2178  GetParameter(fEndAngle, seqCoordinates[rSrcPt + 2].Second, false, false);
2179  // Increasing here allows flat case differentiation tree by using 'continue'.
2180  rSrcPt += 3;
2181 
2182  double fScaledWR(fWR * fXScale);
2183  double fScaledHR(fHR * fYScale);
2184  if (fScaledWR == 0.0 && fScaledHR == 0.0)
2185  {
2186  // degenerated ellipse, add center point
2187  aNewB2DPolygon.append(aCenter);
2188  continue;
2189  }
2190 
2191  if (bIsFromBinaryImport)
2192  {
2193  // If a shape comes from MS binary ('escher') import, the angles are in degrees*2^16
2194  // and the second angle is not an end angle, but a swing angle.
2195  // MS Word shows this behavior: 0deg right, 90deg top, 180deg left and 270deg
2196  // bottom. Third and forth parameter are horizontal and vertical radius, not width
2197  // and height as noted in VML spec. A positive swing angle goes counter-clock
2198  // wise (in user view). The swing angle might go several times around in case
2199  // abs(swing angle) >= 360deg. Stroke accumulates, so that e.g. dash-dot might fill the
2200  // gaps of previous turn. Fill does not accumulate but uses even-odd rule, semi-transparent
2201  // fill does not become darker. The start and end points of the arc are calculated by
2202  // using the angles on a circle and then scaling the circle to the ellipse. Caution, that
2203  // is different from angle handling in ARCANGLETO and ODF.
2204  // The following implementation generates such rendering. It is only for rendering legacy
2205  // MS shapes and independent of the meaning of commands U and T in ODF specification.
2206 
2207  // The WordArt shape 'RingOutside' has already angles in degree, all other need
2208  // conversion from fixed-point number.
2209  double fSwingAngle = fEndAngle;
2210  if (sShpType != "mso-spt143")
2211  {
2212  fStartAngle /= 65536.0;
2213  fSwingAngle = fEndAngle / 65536.0;
2214  }
2215  // Convert orientation
2216  fStartAngle = -fStartAngle;
2217  fSwingAngle = -fSwingAngle;
2218 
2219  fEndAngle = fStartAngle + fSwingAngle;
2220  if (fSwingAngle < 0.0)
2221  std::swap(fStartAngle, fEndAngle);
2222  double fFrom(fStartAngle);
2223  double fTo(fFrom + 180.0);
2224  basegfx::B2DPolygon aTempB2DPolygon;
2225  double fS; // fFrom in radians in [0..2Pi[
2226  double fE; // fTo or fEndAngle in radians in [0..2PI[
2227  while (fTo < fEndAngle)
2228  {
2229  fS = lcl_getNormalizedAngleRad(fFrom);
2230  fE = lcl_getNormalizedAngleRad(fTo);
2231  aTempB2DPolygon.append(basegfx::utils::createPolygonFromEllipseSegment(aCenter, fScaledWR, fScaledHR, fS,fE));
2232  fFrom = fTo;
2233  fTo += 180.0;
2234  }
2235  fS = lcl_getNormalizedAngleRad(fFrom);
2236  fE = lcl_getNormalizedAngleRad(fEndAngle);
2237  aTempB2DPolygon.append(basegfx::utils::createPolygonFromEllipseSegment(aCenter, fScaledWR, fScaledHR,fS, fE));
2238  if (fSwingAngle < 0)
2239  aTempB2DPolygon.flip();
2240  aNewB2DPolygon.append(aTempB2DPolygon);
2241  continue;
2242  }
2243 
2244  // The not yet handled shapes are own preset shapes, or preset shapes from MS binary import, or user
2245  // defined shapes, or foreign shapes. Shapes from OOXML import do not use ANGLEELLIPSE or
2246  // ANGLEELLIPSETO, but use ARCANGLETO.
2247  if (bIsPresetShapeWithU)
2248  {
2249  // Besides "cloud-callout" all preset shapes have angle values '0 360'.
2250  // The imported "cloud-callout" has angle values '0 360' too, only our own "cloud-callout"
2251  // has values '0 23592960'. But that is fixedfloat and means 360*2^16. Thus all these shapes
2252  // have a full ellipse with start at 0deg.
2253  aNewB2DPolygon.append(basegfx::utils::createPolygonFromEllipse(aCenter, fScaledWR, fScaledHR));
2254  continue;
2255  }
2256 
2257  // In all other cases, full ODF conform handling is necessary. ODF rules:
2258  // Third and forth parameter are horizontal and vertical radius.
2259  // An angle determines the start or end point of the segment by intersection of the second angle
2260  // leg with the ellipse. The first angle leg is always the positive x-axis. For the position
2261  // of the intersection points the angle is used modulo 360deg in range [0deg..360deg[.
2262  // The position of range [0deg..360deg[ is the same as in command ARCANGLETO, with 0deg right,
2263  // 90deg bottom, 180deg left and 270deg top. Only if abs(end angle - start angle) == 360 deg,
2264  // a full ellipse is drawn. The segment is always drawn clock wise (in user view) from start
2265  // point to end point. The end point of the segment becomes the new "current" point.
2266 
2267  if (fabs(fabs(fEndAngle - fStartAngle) - 360.0) < 1.0E-15)
2268  {
2269  // draw full ellipse
2270  // Because createPolygonFromEllipseSegment cannot create full ellipse and
2271  // createPolygonFromEllipse has no varying starts, we use two half ellipses.
2272  const double fS(lcl_getNormalizedCircleAngleRad(fWR, fHR, fStartAngle));
2273  const double fH(lcl_getNormalizedCircleAngleRad(fWR, fHR, fStartAngle + 180.0));
2274  const double fE(lcl_getNormalizedCircleAngleRad(fWR, fHR, fEndAngle));
2275  aNewB2DPolygon.append(basegfx::utils::createPolygonFromEllipseSegment(aCenter, fScaledWR, fScaledHR, fS, fH));
2276  aNewB2DPolygon.append(basegfx::utils::createPolygonFromEllipseSegment(aCenter, fScaledWR, fScaledHR, fH, fE));
2277  continue;
2278  }
2279 
2280  // remaining cases with central segment angle < 360
2281  double fS(lcl_getNormalizedCircleAngleRad(fWR, fHR, fStartAngle));
2282  double fE(lcl_getNormalizedCircleAngleRad(fWR, fHR, fEndAngle));
2283  aNewB2DPolygon.append(basegfx::utils::createPolygonFromEllipseSegment(aCenter, fScaledWR, fScaledHR, fS, fE));
2284  } // end for
2285  } // end case
2286  break;
2287 
2288  case QUADRATICCURVETO :
2289  {
2290  for ( sal_Int32 i(0); ( i < nPntCount ) && ( rSrcPt + 1 < nCoordSize ); i++ )
2291  {
2292  DBG_ASSERT(aNewB2DPolygon.count(), "EnhancedCustomShape2d::CreateSubPath: Error no previous point for Q (!)");
2293  if (aNewB2DPolygon.count() > 0)
2294  {
2295  const basegfx::B2DPoint aPreviousEndPoint(aNewB2DPolygon.getB2DPoint(aNewB2DPolygon.count()-1));
2296  const basegfx::B2DPoint aControlQ(GetPointAsB2DPoint( seqCoordinates[ rSrcPt++ ], true, true ));
2297  const basegfx::B2DPoint aEnd(GetPointAsB2DPoint( seqCoordinates[ rSrcPt++ ], true, true ));
2298  const basegfx::B2DPoint aControlA((aPreviousEndPoint + (aControlQ * 2)) / 3);
2299  const basegfx::B2DPoint aControlB(((aControlQ * 2) + aEnd) / 3);
2300  aNewB2DPolygon.appendBezierSegment(aControlA, aControlB, aEnd);
2301  }
2302  else // no previous point; ill structured path, but try to draw as much as possible
2303  {
2304  rSrcPt++; // skip control point
2305  const basegfx::B2DPoint aEnd(GetPointAsB2DPoint( seqCoordinates[ rSrcPt++ ], true, true ));
2306  aNewB2DPolygon.append(aEnd);
2307  }
2308  }
2309  }
2310  break;
2311 
2312  case LINETO :
2313  {
2314  for ( sal_Int32 i(0); ( i < nPntCount ) && ( rSrcPt < nCoordSize ); i++ )
2315  {
2316  const Point aTempPoint(GetPoint( seqCoordinates[ rSrcPt++ ], true, true ));
2317  SAL_INFO(
2318  "svx",
2319  "lineTo: " << aTempPoint.X() << ","
2320  << aTempPoint.Y());
2321  aNewB2DPolygon.append(basegfx::B2DPoint(aTempPoint.X(), aTempPoint.Y()));
2322  }
2323  }
2324  break;
2325 
2326  case ARC :
2327  case CLOCKWISEARC :
2328  {
2329  if(aNewB2DPolygon.count() > 1)
2330  {
2331  // #i76201# Add conversion to closed polygon when first and last points are equal
2332  basegfx::utils::checkClosed(aNewB2DPolygon);
2333  aNewB2DPolyPolygon.append(aNewB2DPolygon);
2334  }
2335 
2336  aNewB2DPolygon.clear();
2337 
2338  [[fallthrough]];
2339  }
2340  case ARCTO :
2341  case CLOCKWISEARCTO :
2342  {
2343  bool bClockwise = ( nCommand == CLOCKWISEARC ) || ( nCommand == CLOCKWISEARCTO );
2344  sal_uInt32 nXor = bClockwise ? 3 : 2;
2345  for ( sal_uInt16 i = 0; ( i < nPntCount ) && ( ( rSrcPt + 3 ) < nCoordSize ); i++ )
2346  {
2347  tools::Rectangle aRect = tools::Rectangle::Justify( GetPoint( seqCoordinates[ rSrcPt ], true, true ), GetPoint( seqCoordinates[ rSrcPt + 1 ], true, true ) );
2348  if ( aRect.GetWidth() && aRect.GetHeight() )
2349  {
2350  Point aStart( GetPoint( seqCoordinates[ static_cast<sal_uInt16>( rSrcPt + nXor ) ], true, true ) );
2351  Point aEnd( GetPoint( seqCoordinates[ static_cast<sal_uInt16>( rSrcPt + ( nXor ^ 1 ) ) ], true, true ) );
2352  aNewB2DPolygon.append(CreateArc( aRect, aStart, aEnd, bClockwise));
2353  }
2354  rSrcPt += 4;
2355  }
2356  }
2357  break;
2358 
2359  case ARCANGLETO :
2360  {
2361  double fWR, fHR; // in Shape coordinate system
2362  double fStartAngle, fSwingAngle; // in deg
2363 
2364  for ( sal_uInt16 i = 0; ( i < nPntCount ) && ( rSrcPt + 1 < nCoordSize ); i++ )
2365  {
2366  basegfx::B2DPoint aTempPair;
2367  aTempPair = GetPointAsB2DPoint(seqCoordinates[static_cast<sal_uInt16>(rSrcPt)], false /*bScale*/, false /*bReplaceGeoSize*/);
2368  fWR = aTempPair.getX();
2369  fHR = aTempPair.getY();
2370  aTempPair = GetPointAsB2DPoint(seqCoordinates[static_cast<sal_uInt16>(rSrcPt + 1)], false /*bScale*/, false /*bReplaceGeoSize*/);
2371  fStartAngle = aTempPair.getX();
2372  fSwingAngle = aTempPair.getY();
2373 
2374  // tdf#122323 MS Office clamps the swing angle to [-360,360]. Such restriction
2375  // is neither in OOXML nor in ODF. Nevertheless, to be compatible we do it for
2376  // "ooxml-foo" shapes. Those shapes have their origin in MS Office.
2377  if (bOOXMLShape)
2378  {
2379  fSwingAngle = std::clamp(fSwingAngle, -360.0, 360.0);
2380  }
2381 
2382  SAL_INFO("svx", "ARCANGLETO scale: " << fWR << "x" << fHR << " angles: " << fStartAngle << "," << fSwingAngle);
2383 
2384  if (aNewB2DPolygon.count() > 0) // otherwise no "current point"
2385  {
2386  // use similar methods as in command U
2387  basegfx::B2DPolygon aTempB2DPolygon;
2388 
2389  if (fWR == 0.0 && fHR == 0.0)
2390  {
2391  // degenerated ellipse, add this one point
2392  aTempB2DPolygon.append(basegfx::B2DPoint(0.0, 0.0));
2393  }
2394  else
2395  {
2396  double fEndAngle = fStartAngle + fSwingAngle;
2397  // Generate arc with ellipse left|top = 0|0.
2398  basegfx::B2DPoint aCenter(fWR, fHR);
2399  if (fSwingAngle < 0.0)
2400  std::swap(fStartAngle, fEndAngle);
2401  double fS; // fFrom in radians in [0..2Pi[
2402  double fE; // fTo or fEndAngle in radians in [0..2PI[
2403  double fFrom(fStartAngle);
2404  // createPolygonFromEllipseSegment expects angles in [0..2PI[.
2405  if (fSwingAngle >= 360.0 || fSwingAngle <= -360.0)
2406  {
2407  double fTo(fFrom + 180.0);
2408  while (fTo < fEndAngle)
2409  {
2410  fS = lcl_getNormalizedCircleAngleRad(fWR, fHR, fFrom);
2411  fE = lcl_getNormalizedCircleAngleRad(fWR, fHR, fTo);
2412  aTempB2DPolygon.append(basegfx::utils::createPolygonFromEllipseSegment(aCenter, fWR, fHR, fS,fE));
2413  fFrom = fTo;
2414  fTo += 180.0;
2415  }
2416  }
2417  fS = lcl_getNormalizedCircleAngleRad(fWR, fHR, fFrom);
2418  fE = lcl_getNormalizedCircleAngleRad(fWR, fHR, fEndAngle);
2419  aTempB2DPolygon.append(basegfx::utils::createPolygonFromEllipseSegment(aCenter, fWR, fHR,fS, fE));
2420  if (fSwingAngle < 0)
2421  aTempB2DPolygon.flip();
2422  aTempB2DPolygon.removeDoublePoints();
2423  }
2424  // Scale arc to 1/100mm
2425  basegfx::B2DHomMatrix aMatrix = basegfx::utils::createScaleB2DHomMatrix(fXScale, fYScale);
2426  aTempB2DPolygon.transform(aMatrix);
2427 
2428  // Now that we have the arc, move it to the "current point".
2429  basegfx::B2DPoint aCurrentPointB2D( aNewB2DPolygon.getB2DPoint(aNewB2DPolygon.count() - 1 ) );
2430  const double fDx(aCurrentPointB2D.getX() - aTempB2DPolygon.getB2DPoint(0).getX());
2431  const double fDy(aCurrentPointB2D.getY() - aTempB2DPolygon.getB2DPoint(0).getY());
2432  aMatrix = basegfx::utils::createTranslateB2DHomMatrix(fDx, fDy);
2433  aTempB2DPolygon.transform(aMatrix);
2434  aNewB2DPolygon.append(aTempB2DPolygon);
2435  }
2436 
2437  rSrcPt += 2;
2438  }
2439  }
2440  break;
2441 
2442  case ELLIPTICALQUADRANTX :
2443  case ELLIPTICALQUADRANTY :
2444  {
2445  if (nPntCount && (rSrcPt < nCoordSize))
2446  {
2447  // The arc starts at the previous point and ends at the point given in the parameter.
2448  basegfx::B2DPoint aStart;
2449  basegfx::B2DPoint aEnd;
2450  sal_uInt16 i = 0;
2451  if (rSrcPt)
2452  {
2453  aStart = GetPointAsB2DPoint(seqCoordinates[rSrcPt - 1], true, true);
2454  }
2455  else
2456  { // no previous point, path is ill-structured. But we want to show as much as possible.
2457  // Thus make a moveTo to the point given as parameter and continue from there.
2458  aStart = GetPointAsB2DPoint(seqCoordinates[static_cast<sal_uInt16>(rSrcPt)], true, true);
2459  aNewB2DPolygon.append(aStart);
2460  rSrcPt++;
2461  i++;
2462  }
2463  // If there are several points, then the direction changes with every point.
2464  bool bIsXDirection(nCommand == ELLIPTICALQUADRANTX);
2465  basegfx::B2DPolygon aArc;
2466  for ( ; ( i < nPntCount ) && ( rSrcPt < nCoordSize ); i++ )
2467  {
2468  aEnd = GetPointAsB2DPoint(seqCoordinates[rSrcPt], true, true);
2469  basegfx::B2DPoint aCenter;
2470  double fRadiusX = fabs(aEnd.getX() - aStart.getX());
2471  double fRadiusY = fabs(aEnd.getY() - aStart.getY());
2472  if (bIsXDirection)
2473  {
2474  aCenter = basegfx::B2DPoint(aStart.getX(),aEnd.getY());
2475  if (aEnd.getX()<aStart.getX())
2476  {
2477  if (aEnd.getY()<aStart.getY()) // left, up
2478  {
2479  aArc = basegfx::utils::createPolygonFromEllipseSegment(aCenter, fRadiusX, fRadiusY, F_PI2, F_PI);
2480  }
2481  else // left, down
2482  {
2483  aArc = basegfx::utils::createPolygonFromEllipseSegment(aCenter, fRadiusX, fRadiusY, F_PI, 1.5*F_PI);
2484  aArc.flip();
2485  }
2486  }
2487  else // aEnd.getX()>=aStart.getX()
2488  {
2489  if (aEnd.getY()<aStart.getY()) // right, up
2490  {
2491  aArc = basegfx::utils::createPolygonFromEllipseSegment(aCenter, fRadiusX, fRadiusY, 0.0, F_PI2);
2492  aArc.flip();
2493  }
2494  else // right, down
2495  {
2496  aArc = basegfx::utils::createPolygonFromEllipseSegment(aCenter, fRadiusX, fRadiusY, 1.5*F_PI, F_2PI);
2497  }
2498  }
2499  }
2500  else // y-direction
2501  {
2502  aCenter = basegfx::B2DPoint(aEnd.getX(),aStart.getY());
2503  if (aEnd.getX()<aStart.getX())
2504  {
2505  if (aEnd.getY()<aStart.getY()) // up, left
2506  {
2507  aArc = basegfx::utils::createPolygonFromEllipseSegment(aCenter, fRadiusX, fRadiusY, 1.5*F_PI, F_2PI);
2508  aArc.flip();
2509  }
2510  else // down, left
2511  {
2512  aArc = basegfx::utils::createPolygonFromEllipseSegment(aCenter, fRadiusX, fRadiusY, 0.0, F_PI2);
2513  }
2514  }
2515  else // aEnd.getX()>=aStart.getX()
2516  {
2517  if (aEnd.getY()<aStart.getY()) // up, right
2518  {
2519  aArc = basegfx::utils::createPolygonFromEllipseSegment(aCenter, fRadiusX, fRadiusY, F_PI, 1.5*F_PI);
2520  }
2521  else // down, right
2522  {
2523  aArc = basegfx::utils::createPolygonFromEllipseSegment(aCenter, fRadiusX, fRadiusY, F_PI2, F_PI);
2524  aArc.flip();
2525  }
2526  }
2527  }
2528  aNewB2DPolygon.append(aArc);
2529  rSrcPt++;
2530  bIsXDirection = !bIsXDirection;
2531  aStart = aEnd;
2532  }
2533  }
2534  // else error in path syntax, do nothing
2535  }
2536  break;
2537 
2538 #ifdef DBG_CUSTOMSHAPE
2539  case UNKNOWN :
2540  default :
2541  {
2542  SAL_WARN( "svx", "CustomShapes::unknown PolyFlagValue :" << nCommand );
2543  }
2544  break;
2545 #endif
2546  }
2547  if ( nCommand == ENDSUBPATH )
2548  break;
2549  }
2550  }
2551  if ( rSegmentInd == nSegInfoSize )
2552  rSegmentInd++;
2553 
2554  if(aNewB2DPolygon.count() > 1)
2555  {
2556  // #i76201# Add conversion to closed polygon when first and last points are equal
2557  basegfx::utils::checkClosed(aNewB2DPolygon);
2558  aNewB2DPolyPolygon.append(aNewB2DPolygon);
2559  }
2560 
2561  if(!aNewB2DPolyPolygon.count())
2562  return;
2563 
2564  // #i37011#
2565  bool bForceCreateTwoObjects(false);
2566 
2567  if(!bSortFilledObjectsToBack && !aNewB2DPolyPolygon.isClosed() && !bNoStroke)
2568  {
2569  bForceCreateTwoObjects = true;
2570  }
2571 
2572  if(bLineGeometryNeededOnly)
2573  {
2574  bForceCreateTwoObjects = true;
2575  bNoFill = true;
2576  bNoStroke = false;
2577  }
2578 
2579  if(bForceCreateTwoObjects || bSortFilledObjectsToBack)
2580  {
2581  if(bFilled && !bNoFill)
2582  {
2583  basegfx::B2DPolyPolygon aClosedPolyPolygon(aNewB2DPolyPolygon);
2584  aClosedPolyPolygon.setClosed(true);
2585  SdrPathObjUniquePtr pFill(new SdrPathObj(
2586  mrSdrObjCustomShape.getSdrModelFromSdrObject(),
2587  OBJ_POLY,
2588  aClosedPolyPolygon));
2589  SfxItemSet aTempSet(*this);
2590  aTempSet.Put(makeSdrShadowItem(false));
2591  aTempSet.Put(XLineStyleItem(drawing::LineStyle_NONE));
2592  pFill->SetMergedItemSet(aTempSet);
2593  rObjectList.push_back(std::pair< SdrPathObjUniquePtr, double >(std::move(pFill), dBrightness));
2594  }
2595 
2596  if(!bNoStroke)
2597  {
2598  // there is no reason to use OBJ_PLIN here when the polygon is actually closed,
2599  // the non-fill is defined by XFILL_NONE. Since SdrPathObj::ImpForceKind() needs
2600  // to correct the polygon (here: open it) using the type, the last edge may get lost.
2601  // Thus, use a type that fits the polygon
2602  SdrPathObjUniquePtr pStroke(new SdrPathObj(
2603  mrSdrObjCustomShape.getSdrModelFromSdrObject(),
2604  aNewB2DPolyPolygon.isClosed() ? OBJ_POLY : OBJ_PLIN,
2605  aNewB2DPolyPolygon));
2606  SfxItemSet aTempSet(*this);
2607  aTempSet.Put(makeSdrShadowItem(false));
2608  aTempSet.Put(XFillStyleItem(drawing::FillStyle_NONE));
2609  pStroke->SetMergedItemSet(aTempSet);
2610  rObjectList.push_back(std::pair< SdrPathObjUniquePtr, double >(std::move(pStroke), dBrightness));
2611  }
2612  }
2613  else
2614  {
2615  SdrPathObjUniquePtr pObj;
2616  SfxItemSet aTempSet(*this);
2617  aTempSet.Put(makeSdrShadowItem(false));
2618 
2619  if(bNoFill)
2620  {
2621  // see comment above about OBJ_PLIN
2622  pObj.reset(new SdrPathObj(
2623  mrSdrObjCustomShape.getSdrModelFromSdrObject(),
2624  aNewB2DPolyPolygon.isClosed() ? OBJ_POLY : OBJ_PLIN,
2625  aNewB2DPolyPolygon));
2626  aTempSet.Put(XFillStyleItem(drawing::FillStyle_NONE));
2627  }
2628  else
2629  {
2630  aNewB2DPolyPolygon.setClosed(true);
2631  pObj.reset(new SdrPathObj(
2632  mrSdrObjCustomShape.getSdrModelFromSdrObject(),
2633  OBJ_POLY,
2634  aNewB2DPolyPolygon));
2635  }
2636 
2637  if(bNoStroke)
2638  {
2639  aTempSet.Put(XLineStyleItem(drawing::LineStyle_NONE));
2640  }
2641 
2642  pObj->SetMergedItemSet(aTempSet);
2643  rObjectList.push_back(std::pair< SdrPathObjUniquePtr, double >(std::move(pObj), dBrightness));
2644  }
2645 }
2646 
2647 static void CorrectCalloutArrows(
2648  MSO_SPT eSpType,
2649  sal_uInt32 nLineObjectCount,
2650  std::vector< std::pair< SdrPathObjUniquePtr, double> >& vObjectList )
2651 {
2652  bool bAccent = false;
2653  switch( eSpType )
2654  {
2655  case mso_sptCallout1 :
2656  case mso_sptBorderCallout1 :
2657  case mso_sptCallout90 :
2658  case mso_sptBorderCallout90 :
2659  default:
2660  break;
2661 
2662  case mso_sptAccentCallout1 :
2663  case mso_sptAccentBorderCallout1 :
2664  case mso_sptAccentCallout90 :
2665  case mso_sptAccentBorderCallout90 :
2666  {
2667  sal_uInt32 nLine = 0;
2668 
2669  for ( const std::pair< SdrPathObjUniquePtr, double >& rCandidate : vObjectList )
2670  {
2671  SdrPathObj* pObj(rCandidate.first.get());
2672 
2673  if(pObj->IsLine())
2674  {
2675  nLine++;
2676  if ( nLine == nLineObjectCount )
2677  {
2678  pObj->ClearMergedItem( XATTR_LINESTART );
2679  pObj->ClearMergedItem( XATTR_LINEEND );
2680  }
2681  }
2682  }
2683  }
2684  break;
2685 
2686  // switch start & end
2687  case mso_sptAccentCallout2 :
2688  case mso_sptAccentBorderCallout2 :
2689  bAccent = true;
2690  [[fallthrough]];
2691  case mso_sptCallout2 :
2692  case mso_sptBorderCallout2 :
2693  {
2694  sal_uInt32 nLine = 0;
2695 
2696  for ( const std::pair< SdrPathObjUniquePtr, double >& rCandidate : vObjectList )
2697  {
2698  SdrPathObj* pObj(rCandidate.first.get());
2699 
2700  if(pObj->IsLine())
2701  {
2702  nLine++;
2703  if ( nLine == 1 )
2704  pObj->ClearMergedItem( XATTR_LINEEND );
2705  else if ( ( bAccent && ( nLine == nLineObjectCount - 1 ) ) || ( !bAccent && ( nLine == nLineObjectCount ) ) )
2706  pObj->ClearMergedItem( XATTR_LINESTART );
2707  else
2708  {
2709  pObj->ClearMergedItem( XATTR_LINESTART );
2710  pObj->ClearMergedItem( XATTR_LINEEND );
2711  }
2712  }
2713  }
2714  }
2715  break;
2716 
2717  case mso_sptAccentCallout3 :
2718  case mso_sptAccentBorderCallout3 :
2719  case mso_sptCallout3 :
2720  case mso_sptBorderCallout3 :
2721  {
2722  sal_uInt32 nLine = 0;
2723 
2724  for ( const std::pair< SdrPathObjUniquePtr, double >& rCandidate : vObjectList )
2725  {
2726  SdrPathObj* pObj(rCandidate.first.get());
2727 
2728  if(pObj->IsLine())
2729  {
2730  if ( nLine )
2731  {
2732  pObj->ClearMergedItem( XATTR_LINESTART );
2733  pObj->ClearMergedItem( XATTR_LINEEND );
2734  }
2735  else
2736  EnhancedCustomShape2d::SwapStartAndEndArrow( pObj );
2737 
2738  nLine++;
2739  }
2740  }
2741  }
2742  break;
2743  }
2744 }
2745 
2746 void EnhancedCustomShape2d::AdaptObjColor(
2747  SdrPathObj& rObj,
2748  double dBrightness,
2749  const SfxItemSet& rCustomShapeSet,
2750  sal_uInt32& nColorIndex,
2751  sal_uInt32 nColorCount)
2752 {
2753  if ( rObj.IsLine() )
2754  return;
2755 
2756  const drawing::FillStyle eFillStyle = rObj.GetMergedItem(XATTR_FILLSTYLE).GetValue();
2757  switch( eFillStyle )
2758  {
2759  default:
2760  case drawing::FillStyle_SOLID:
2761  {
2762  if ( nColorCount || 0.0 != dBrightness )
2763  {
2764  Color aFillColor = GetColorData(
2765  rCustomShapeSet.Get( XATTR_FILLCOLOR ).GetColorValue(),
2766  std::min(nColorIndex, nColorCount-1),
2767  dBrightness );
2768  rObj.SetMergedItem( XFillColorItem( "", aFillColor ) );
2769  }
2770  break;
2771  }
2772  case drawing::FillStyle_GRADIENT:
2773  {
2774  XGradient aXGradient(rObj.GetMergedItem(XATTR_FILLGRADIENT).GetGradientValue());
2775 
2776  if ( nColorCount || 0.0 != dBrightness )
2777  {
2778  aXGradient.SetStartColor(
2779  GetColorData(
2780  aXGradient.GetStartColor(),
2781  std::min(nColorIndex, nColorCount-1),
2782  dBrightness ));
2783  aXGradient.SetEndColor(
2784  GetColorData(
2785  aXGradient.GetEndColor(),
2786  std::min(nColorIndex, nColorCount-1),
2787  dBrightness ));
2788  }
2789 
2790  rObj.SetMergedItem( XFillGradientItem( "", aXGradient ) );
2791  break;
2792  }
2793  case drawing::FillStyle_HATCH:
2794  {
2795  XHatch aXHatch(rObj.GetMergedItem(XATTR_FILLHATCH).GetHatchValue());
2796 
2797  if ( nColorCount || 0.0 != dBrightness )
2798  {
2799  aXHatch.SetColor(
2800  GetColorData(
2801  aXHatch.GetColor(),
2802  std::min(nColorIndex, nColorCount-1),
2803  dBrightness ));
2804  }
2805 
2806  rObj.SetMergedItem( XFillHatchItem( "", aXHatch ) );
2807  break;
2808  }
2809  case drawing::FillStyle_BITMAP:
2810  {
2811  if ( nColorCount || 0.0 != dBrightness )
2812  {
2813  BitmapEx aBitmap(rObj.GetMergedItem(XATTR_FILLBITMAP).GetGraphicObject().GetGraphic().GetBitmapEx());
2814 
2815  short nLuminancePercent = static_cast< short > ( GetLuminanceChange(
2816  std::min(nColorIndex, nColorCount-1)));
2817  aBitmap.Adjust( nLuminancePercent, 0, 0, 0, 0 );
2818 
2819  rObj.SetMergedItem(XFillBitmapItem(OUString(), Graphic(aBitmap)));
2820  }
2821 
2822  break;
2823  }
2824  }
2825 
2826  if ( nColorIndex < nColorCount )
2827  nColorIndex++;
2828 }
2829 
2830 SdrObjectUniquePtr EnhancedCustomShape2d::CreatePathObj( bool bLineGeometryNeededOnly )
2831 {
2832  if ( !seqCoordinates.hasElements() )
2833  {
2834  return nullptr;
2835  }
2836 
2837  std::vector< std::pair< SdrPathObjUniquePtr, double > > vObjectList;
2838  const bool bSortFilledObjectsToBack(SortFilledObjectsToBackByDefault(eSpType));
2839  sal_Int32 nSubPathIndex(0);
2840  sal_Int32 nSrcPt(0);
2841  sal_Int32 nSegmentInd(0);
2842  SdrObjectUniquePtr pRet;
2843 
2844  while( nSegmentInd <= seqSegments.getLength() )
2845  {
2846  CreateSubPath(
2847  nSrcPt,
2848  nSegmentInd,
2849  vObjectList,
2850  bLineGeometryNeededOnly,
2851  bSortFilledObjectsToBack,
2852  nSubPathIndex);
2853  nSubPathIndex++;
2854  }
2855 
2856  if ( !vObjectList.empty() )
2857  {
2858  const SfxItemSet& rCustomShapeSet(mrSdrObjCustomShape.GetMergedItemSet());
2859  const sal_uInt32 nColorCount(nColorData >> 28);
2860  sal_uInt32 nColorIndex(0);
2861 
2862  // #i37011# remove invisible objects
2863  std::vector< std::pair< SdrPathObjUniquePtr, double> > vNewList;
2864 
2865  for ( std::pair< SdrPathObjUniquePtr, double >& rCandidate : vObjectList )
2866  {
2867  SdrPathObj* pObj(rCandidate.first.get());
2868  const drawing::LineStyle eLineStyle(pObj->GetMergedItem(XATTR_LINESTYLE).GetValue());
2869  const drawing::FillStyle eFillStyle(pObj->GetMergedItem(XATTR_FILLSTYLE).GetValue());
2870  const auto pText = pObj->getActiveText();
2871 
2872  // #i40600# if bLineGeometryNeededOnly is set, linestyle does not matter
2873  if(pText || bLineGeometryNeededOnly || (drawing::LineStyle_NONE != eLineStyle) || (drawing::FillStyle_NONE != eFillStyle))
2874  vNewList.push_back(std::move(rCandidate));
2875  }
2876 
2877  vObjectList = std::move(vNewList);
2878 
2879  if(1 == vObjectList.size())
2880  {
2881  // a single object, correct some values
2882  AdaptObjColor(
2883  *vObjectList.begin()->first,
2884  vObjectList.begin()->second,
2885  rCustomShapeSet,
2886  nColorIndex,
2887  nColorCount);
2888  }
2889  else
2890  {
2891  sal_Int32 nLineObjectCount(0);
2892 
2893  // correct some values and collect content data
2894  for ( const std::pair< SdrPathObjUniquePtr, double >& rCandidate : vObjectList )
2895  {
2896  SdrPathObj* pObj(rCandidate.first.get());
2897 
2898  if(pObj->IsLine())
2899  {
2900  nLineObjectCount++;
2901  }
2902  else
2903  {
2904  AdaptObjColor(
2905  *pObj,
2906  rCandidate.second,
2907  rCustomShapeSet,
2908  nColorIndex,
2909  nColorCount);
2910 
2911  // OperationSmiley: when we have access to the SdrObjCustomShape and the
2912  // CustomShape is built with more than a single filled Geometry, use it
2913  // to define that all helper geometries defined here (SdrObjects currently)
2914  // will use the same FillGeometryDefinition (from the referenced SdrObjCustomShape).
2915  // This will all same-filled objects look like filled smoothly with the same style.
2916  pObj->setFillGeometryDefiningShape(&mrSdrObjCustomShape);
2917  }
2918  }
2919 
2920  // #i88870# correct line arrows for callouts
2921  if ( nLineObjectCount )
2922  {
2923  CorrectCalloutArrows(
2924  eSpType,
2925  nLineObjectCount,
2926  vObjectList);
2927  }
2928 
2929  // sort objects so that filled ones are in front. Necessary
2930  // for some strange objects
2931  if(bSortFilledObjectsToBack)
2932  {
2933  std::vector< std::pair< SdrPathObjUniquePtr, double> > vTempList;
2934  vTempList.reserve(vObjectList.size());
2935 
2936  for ( std::pair< SdrPathObjUniquePtr, double >& rCandidate : vObjectList )
2937  {
2938  SdrPathObj* pObj(rCandidate.first.get());
2939  if ( !pObj->IsLine() )
2940  vTempList.push_back(std::move(rCandidate));
2941  }
2942 
2943  for ( std::pair< SdrPathObjUniquePtr, double >& rCandidate : vObjectList )
2944  {
2945  if ( rCandidate.first )
2946  vTempList.push_back(std::move(rCandidate));
2947  }
2948 
2949  vObjectList = std::move(vTempList);
2950  }
2951  }
2952  }
2953 
2954  // #i37011#
2955  if(!vObjectList.empty())
2956  {
2957  // copy remaining objects to pRet
2958  if(vObjectList.size() > 1)
2959  {
2960  pRet.reset(new SdrObjGroup(mrSdrObjCustomShape.getSdrModelFromSdrObject()));
2961 
2962  for ( std::pair< SdrPathObjUniquePtr, double >& rCandidate : vObjectList )
2963  {
2964  pRet->GetSubList()->NbcInsertObject(rCandidate.first.release());
2965  }
2966  }
2967  else if(1 == vObjectList.size())
2968  {
2969  pRet.reset(vObjectList.begin()->first.release());
2970  }
2971 
2972  if(pRet)
2973  {
2974  // move to target position
2975  tools::Rectangle aCurRect(pRet->GetSnapRect());
2976  aCurRect.Move(aLogicRect.Left(), aLogicRect.Top());
2977  pRet->NbcSetSnapRect(aCurRect);
2978  }
2979  }
2980 
2981  return pRet;
2982 }
2983 
2984 SdrObjectUniquePtr EnhancedCustomShape2d::CreateObject( bool bLineGeometryNeededOnly )
2985 {
2986  SdrObjectUniquePtr pRet;
2987 
2988  if ( eSpType == mso_sptRectangle )
2989  {
2990  pRet.reset(new SdrRectObj(mrSdrObjCustomShape.getSdrModelFromSdrObject(), aLogicRect));
2991  pRet->SetMergedItemSet( *this );
2992  }
2993  if ( !pRet )
2994  pRet = CreatePathObj( bLineGeometryNeededOnly );
2995 
2996  return pRet;
2997 }
2998 
2999 void EnhancedCustomShape2d::ApplyGluePoints( SdrObject* pObj )
3000 {
3001  if ( !pObj )
3002  return;
3003 
3004  for ( const auto& rGluePoint : std::as_const(seqGluePoints) )
3005  {
3006  SdrGluePoint aGluePoint;
3007 
3008  aGluePoint.SetPos( GetPoint( rGluePoint, true, true ) );
3009  aGluePoint.SetPercent( false );
3010  aGluePoint.SetAlign( SdrAlign::VERT_TOP | SdrAlign::HORZ_LEFT );
3011  aGluePoint.SetEscDir( SdrEscapeDirection::SMART );
3012  SdrGluePointList* pList = pObj->ForceGluePointList();
3013  if( pList )
3014  /* sal_uInt16 nId = */ pList->Insert( aGluePoint );
3015  }
3016 }
3017 
3018 SdrObjectUniquePtr EnhancedCustomShape2d::CreateLineGeometry()
3019 {
3020  return CreateObject( true );
3021 }
3022 
3023 
3024 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
ExpressionFunct
ExpressionFunct
EnhancedCustomShape2d::GetParameter
void GetParameter(double &rParameterReturnValue, const css::drawing::EnhancedCustomShapeParameter &, const bool bReplaceGeoWidth, const bool bReplaceGeoHeight) const
Definition: EnhancedCustomShape2d.cxx:949
EnhancedCustomShape2d::Handle::aYRangeMinimum
css::drawing::EnhancedCustomShapeParameter aYRangeMinimum
Definition: EnhancedCustomShape2d.hxx:173
Tuple2D< double >::getY
double getY() const
EnhancedCustomShape2d::mrSdrObjCustomShape
SdrObjCustomShape & mrSdrObjCustomShape
Definition: EnhancedCustomShape2d.hxx:81
DFF_Prop_geoTop
#define DFF_Prop_geoTop
Definition: msdffdef.hxx:146
nIndex
sal_Int32 nIndex
basegfx::B2DPolygon::append
void append(const basegfx::B2DPoint &rPoint, sal_uInt32 nCount)
EnhancedCustomShape2d::SwapStartAndEndArrow
static SAL_DLLPRIVATE void SwapStartAndEndArrow(SdrObject *pObj)
Definition: EnhancedCustomShape2d.cxx:1932
XATTR_LINEEND
constexpr TypedWhichId< XLineEndItem > XATTR_LINEEND(XATTR_LINE_FIRST+5)
XATTR_LINEENDCENTER
constexpr TypedWhichId< XLineEndCenterItem > XATTR_LINEENDCENTER(XATTR_LINE_FIRST+9)
lcl_getRadiusDistance
static double lcl_getRadiusDistance(double fWR, double fHR, double fX, double fY)
Definition: EnhancedCustomShape2d.cxx:1430
Color::GetRed
sal_uInt8 GetRed() const
EnhancedCustomShape2d::AdaptObjColor
SAL_DLLPRIVATE void AdaptObjColor(SdrPathObj &rObj, double dBrightness, const SfxItemSet &rCustomShapeSet, sal_uInt32 &nColorIndex, sal_uInt32 nColorCount)
Definition: EnhancedCustomShape2d.cxx:2746
XATTR_LINESTART
constexpr TypedWhichId< XLineStartItem > XATTR_LINESTART(XATTR_LINE_FIRST+4)
ShearPoint
void ShearPoint(Point &rPnt, const Point &rRef, double tn, bool bVShear=false)
Definition: svdtrans.hxx:122
EnhancedCustomShape2d::CreateObject
SdrObjectUniquePtr CreateObject(bool bLineGeometryNeededOnly)
Definition: EnhancedCustomShape2d.cxx:2984
BitmapEx::Adjust
bool Adjust(short nLuminancePercent, short nContrastPercent, short nChannelRPercent, short nChannelGPercent, short nChannelBPercent, double fGamma=1.0, bool bInvert=false, bool msoBrightness=false)
GetValue
std::string GetValue
basegfx::fTools::equalZero
bool equalZero(const T &rfVal)
DFF_Prop_geoBottom
#define DFF_Prop_geoBottom
Definition: msdffdef.hxx:148
basegfx::B2DPolyPolygon::setClosed
void setClosed(bool bNew)
tools::Rectangle::Left
constexpr tools::Long Left() const
EnhancedCustomShape2d::GetTextRect
tools::Rectangle GetTextRect() const
Definition: EnhancedCustomShape2d.cxx:1094
EnhancedCustomShape2d::vEquationResults
std::vector< EquationResult > vEquationResults
Definition: EnhancedCustomShape2d.hxx:112
XATTR_FILLSTYLE
constexpr TypedWhichId< XFillStyleItem > XATTR_FILLSTYLE(XATTR_FILL_FIRST)
F_PI2
#define F_PI2
OBJ_POLY
circle cut
Definition: svdobjkind.hxx:34
EnhancedCustomShape2d::GetHandlePosition
bool GetHandlePosition(const sal_uInt32 nIndex, Point &rReturnPosition) const
Definition: EnhancedCustomShape2d.cxx:1125
basegfx::B2DPolygon::appendBezierSegment
void appendBezierSegment(const basegfx::B2DPoint &rNextControlPoint, const basegfx::B2DPoint &rPrevControlPoint, const basegfx::B2DPoint &rPoint)
XATTR_LINESTYLE
constexpr TypedWhichId< XLineStyleItem > XATTR_LINESTYLE(XATTR_LINE_FIRST)
toRadians
double toRadians(Degree10 x)
EnhancedCustomShape2d::GetPoint
SAL_DLLPRIVATE Point GetPoint(const css::drawing::EnhancedCustomShapeParameterPair &, const bool bScale=true, const bool bReplaceGeoSize=false) const
Definition: EnhancedCustomShape2d.cxx:942
XATTR_FILLHATCH
constexpr TypedWhichId< XFillHatchItem > XATTR_FILLHATCH(XATTR_FILL_FIRST+3)
abs
SwNodeOffset abs(const SwNodeOffset &a)
SdrAttrObj::GetSnapRect
virtual const tools::Rectangle & GetSnapRect() const override
Definition: svdoattr.cxx:49
CreateArc
static basegfx::B2DPolygon CreateArc(const tools::Rectangle &rRect, const Point &rStart, const Point &rEnd, const bool bClockwise)
Definition: EnhancedCustomShape2d.cxx:1952
basegfx::rad2deg
constexpr double rad2deg(double v)
SdrPathObjUniquePtr
std::unique_ptr< SdrPathObj, SdrObjectFreeOp > SdrPathObjUniquePtr
Definition: svdotext.hxx:123
basegfx::BColor::setGreen
void setGreen(double fNew)
EnhancedCustomShape2d::GetAdjustValueAsDouble
SAL_DLLPRIVATE double GetAdjustValueAsDouble(const sal_Int32 nIndex) const
Definition: EnhancedCustomShape2d.cxx:851
o3tl::starts_with
constexpr bool starts_with(std::basic_string_view< charT, traits > sv, std::basic_string_view< charT, traits > x) noexcept
DFF_Prop_geoLeft
#define DFF_Prop_geoLeft
Definition: msdffdef.hxx:145
SdrRectObj
Rectangle objects (rectangle, circle, ...)
Definition: svdorect.hxx:38
Value
Value
XHatch::SetColor
void SetColor(const Color &rColor)
Definition: xhatch.hxx:47
DFF_Prop_adjust10Value
#define DFF_Prop_adjust10Value
Definition: msdffdef.hxx:160
SdrObject::ClearMergedItem
void ClearMergedItem(const sal_uInt16 nWhich=0)
Definition: svdobj.cxx:1993
EnhancedCustomShape2d::Handle::aRadiusRangeMaximum
css::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum
Definition: EnhancedCustomShape2d.hxx:170
MSO_SPT
MSO_SPT
Definition: msdffdef.hxx:274
basegfx::utils::createScaleB2DHomMatrix
B2DHomMatrix createScaleB2DHomMatrix(double fScaleX, double fScaleY)
GeoStat
The transformation of a rectangle into a polygon, by using angle parameters from GeoStat.
Definition: svdtrans.hxx:214
nCount
int nCount
EnhancedCustomShape2d::GetColorData
SAL_DLLPRIVATE Color GetColorData(const Color &rFillColor, sal_uInt32 nIndex, double dBrightness) const
Definition: EnhancedCustomShape2d.cxx:1037
tools::Rectangle::GetWidth
constexpr tools::Long GetWidth() const
DFF_Prop_adjustValue
#define DFF_Prop_adjustValue
Definition: msdffdef.hxx:151
o3tl::strong_int< sal_Int32, struct Degree100Tag >
basegfx::BColor::getBlue
double getBlue() const
SdrTextObj::GetGeoStat
const GeoStat & GetGeoStat() const
Definition: svdotext.hxx:392
DFF_Prop_adjust3Value
#define DFF_Prop_adjust3Value
Definition: msdffdef.hxx:153
SDRATTR_SHADOW
constexpr TypedWhichId< SdrOnOffItem > SDRATTR_SHADOW(SDRATTR_SHADOW_FIRST+0)
Color::GetBlue
sal_uInt8 GetBlue() const
EnhancedCustomShape2d::Handle::aXRangeMaximum
css::drawing::EnhancedCustomShapeParameter aXRangeMaximum
Definition: EnhancedCustomShape2d.hxx:172
UNKNOWN
UNKNOWN
GeoStat::mfTanShearAngle
double mfTanShearAngle
Definition: svdtrans.hxx:218
XLineStartItem::SetLineStartValue
void SetLineStartValue(const basegfx::B2DPolyPolygon &rPolyPolygon)
Definition: xlnstit.hxx:54
EnhancedCustomShape2d::SetHandleControllerPosition
bool SetHandleControllerPosition(const sal_uInt32 nIndex, const css::awt::Point &rPosition)
Definition: EnhancedCustomShape2d.cxx:1465
EnhancedCustomShape2d::seqTextFrames
css::uno::Sequence< css::drawing::EnhancedCustomShapeTextFrame > seqTextFrames
Definition: EnhancedCustomShape2d.hxx:116
tools::Rectangle::SetLeft
constexpr void SetLeft(tools::Long v)
DFF_Prop_adjust8Value
#define DFF_Prop_adjust8Value
Definition: msdffdef.hxx:158
EnhancedCustomShape2d::seqSubViewSize
css::uno::Sequence< css::awt::Size > seqSubViewSize
Definition: EnhancedCustomShape2d.hxx:120
basegfx::BColor::getRed
double getRed() const
SDRATTR_TEXTDIRECTION
constexpr TypedWhichId< SvxWritingModeItem > SDRATTR_TEXTDIRECTION(SDRATTR_NOTPERSIST_FIRST+34)
lcl_getXAdjustmentValue
static double lcl_getXAdjustmentValue(std::u16string_view rShapeType, const sal_uInt32 nHandleIndex, const double fX, const double fW, const double fH)
Definition: EnhancedCustomShape2d.cxx:1193
EnhancedCustomShape2d::Handle::aPolar
css::drawing::EnhancedCustomShapeParameterPair aPolar
Definition: EnhancedCustomShape2d.hxx:162
EnhancedCustomShape2d::CreateSubPath
SAL_DLLPRIVATE void CreateSubPath(sal_Int32 &rSrcPt, sal_Int32 &rSegmentInd, std::vector< std::pair< SdrPathObjUniquePtr, double > > &rObjectList, bool bLineGeometryNeededOnly, bool bSortFilledObjectsToBack, sal_Int32 nIndex)
Definition: EnhancedCustomShape2d.cxx:2023
SfxItemSet::ClearItem
sal_uInt16 ClearItem(sal_uInt16 nWhich=0)
EnhancedCustomShape2d::seqEquations
css::uno::Sequence< OUString > seqEquations
Definition: EnhancedCustomShape2d.hxx:110
EnhancedCustomShape2d::Handle::aPosition
css::drawing::EnhancedCustomShapeParameterPair aPosition
Definition: EnhancedCustomShape2d.hxx:161
EnhancedCustomShape2d::GetPointAsB2DPoint
SAL_DLLPRIVATE basegfx::B2DPoint GetPointAsB2DPoint(const css::drawing::EnhancedCustomShapeParameterPair &, const bool bScale=true, const bool bReplaceGeoSize=false) const
Definition: EnhancedCustomShape2d.cxx:921
EnhancedCustomShape2d::Handle::aRadiusRangeMinimum
css::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum
Definition: EnhancedCustomShape2d.hxx:169
F_PI
#define F_PI
SAL_MAX_INT32
#define SAL_MAX_INT32
XGradient::SetStartColor
void SetStartColor(const Color &rColor)
Definition: xgrad.hxx:58
EnhancedCustomShape2d::GetEquation
static OUString GetEquation(const sal_uInt16 nFlags, sal_Int32 nPara1, sal_Int32 nPara2, sal_Int32 nPara3)
Definition: EnhancedCustomShape2d.cxx:86
XATTR_LINESTARTWIDTH
constexpr TypedWhichId< XLineStartWidthItem > XATTR_LINESTARTWIDTH(XATTR_LINE_FIRST+6)
basegfx::utils::checkClosed
void checkClosed(B2DPolygon &rCandidate)
basegfx::B2DPolyPolygon::isClosed
bool isClosed() const
XATTR_FILLGRADIENT
constexpr TypedWhichId< XFillGradientItem > XATTR_FILLGRADIENT(XATTR_FILL_FIRST+2)
DBG_ASSERT
#define DBG_ASSERT(sCon, aError)
EnhancedCustomShape2d::SetPathSize
SAL_DLLPRIVATE void SetPathSize(sal_Int32 nIndex=0)
Definition: EnhancedCustomShape2d.cxx:628
SDRATTR_CUSTOMSHAPE_GEOMETRY
constexpr TypedWhichId< SdrCustomShapeGeometryItem > SDRATTR_CUSTOMSHAPE_GEOMETRY(SDRATTR_CUSTOMSHAPE_FIRST+2)
i
int i
SortFilledObjectsToBackByDefault
bool SortFilledObjectsToBackByDefault(MSO_SPT eSpType)
Definition: EnhancedCustomShapeGeometry.cxx:6256
a
uno_Any a
XATTR_FILLBITMAP
constexpr TypedWhichId< XFillBitmapItem > XATTR_FILLBITMAP(XATTR_FILL_FIRST+4)
DFF_Prop_adjust9Value
#define DFF_Prop_adjust9Value
Definition: msdffdef.hxx:159
FRound
tools::Long FRound(double fVal)
DFF_Prop_adjust6Value
#define DFF_Prop_adjust6Value
Definition: msdffdef.hxx:156
DFF_Prop_adjust4Value
#define DFF_Prop_adjust4Value
Definition: msdffdef.hxx:154
DFF_Prop_adjust7Value
#define DFF_Prop_adjust7Value
Definition: msdffdef.hxx:157
EnhancedCustomShape2d::GetLuminanceChange
SAL_DLLPRIVATE sal_Int32 GetLuminanceChange(sal_uInt32 nIndex) const
Definition: EnhancedCustomShape2d.cxx:1024
XATTR_LINEENDWIDTH
constexpr TypedWhichId< XLineEndWidthItem > XATTR_LINEENDWIDTH(XATTR_LINE_FIRST+7)
basegfx::utils::hsv2rgb
BColor hsv2rgb(const BColor &rHSVColor)
EnhancedCustomShape2d::vNodesSharedPtr
std::vector< std::shared_ptr< EnhancedCustomShape::ExpressionNode > > vNodesSharedPtr
Definition: EnhancedCustomShape2d.hxx:111
EnhancedCustomShape2d::seqHandles
css::uno::Sequence< css::beans::PropertyValues > seqHandles
Definition: EnhancedCustomShape2d.hxx:119
F_2PI
#define F_2PI
tools::Rectangle::Right
constexpr tools::Long Right() const
u
float u
SdrObject::getSdrModelFromSdrObject
SdrModel & getSdrModelFromSdrObject() const
Definition: svdobj.cxx:279
EnhancedCustomShape2d::ApplyGluePoints
void ApplyGluePoints(SdrObject *pObj)
Definition: EnhancedCustomShape2d.cxx:2999
OBJ_PLIN
polygon, PolyPolygon
Definition: svdobjkind.hxx:35
SdrGluePoint::SetPercent
void SetPercent(bool bOn)
Definition: svdglue.hxx:126
tools::Rectangle::Top
constexpr tools::Long Top() const
EnhancedCustomShape2d::SetEnhancedCustomShapeParameter
static void SetEnhancedCustomShapeParameter(css::drawing::EnhancedCustomShapeParameter &rParameter, const sal_Int32 nValue)
Definition: EnhancedCustomShape2d.cxx:70
tools::Polygon::GetSize
sal_uInt16 GetSize() const
basegfx::deg2rad
constexpr double deg2rad(double v)
lcl_getYAdjustmentValue
static double lcl_getYAdjustmentValue(std::u16string_view rShapeType, const sal_uInt32 nHandleIndex, const double fY, const double fW, const double fH)
Definition: EnhancedCustomShape2d.cxx:1301
SdrObject::SetMergedItem
void SetMergedItem(const SfxPoolItem &rItem)
Definition: svdobj.cxx:1988
tools::Rectangle::SetRight
constexpr void SetRight(tools::Long v)
EnhancedCustomShape2d::Handle::aXRangeMinimum
css::drawing::EnhancedCustomShapeParameter aXRangeMinimum
Definition: EnhancedCustomShape2d.hxx:171
tools::Rectangle::SetBottom
constexpr void SetBottom(tools::Long v)
SdrObject::GetMergedItem
const SfxPoolItem & GetMergedItem(const sal_uInt16 nWhich) const
Definition: svdobj.cxx:2013
XATTR_LINESTARTCENTER
constexpr TypedWhichId< XLineStartCenterItem > XATTR_LINESTARTCENTER(XATTR_LINE_FIRST+8)
EnhancedCustomShape2d::GetEquationValueAsDouble
SAL_DLLPRIVATE double GetEquationValueAsDouble(const sal_Int32 nIndex) const
Definition: EnhancedCustomShape2d.cxx:867
SdrObject
Abstract DrawObject.
Definition: svdobj.hxx:259
EnhancedCustomShape2d::seqAdjustmentValues
css::uno::Sequence< css::drawing::EnhancedCustomShapeAdjustmentValue > seqAdjustmentValues
Definition: EnhancedCustomShape2d.hxx:118
tools::Rectangle::SetTop
constexpr void SetTop(tools::Long v)
Y
#define Y
DFF_Prop_adjust2Value
#define DFF_Prop_adjust2Value
Definition: msdffdef.hxx:152
tools::Rectangle::Center
constexpr Point Center() const
basegfx::B2DPolygon::transform
void transform(const basegfx::B2DHomMatrix &rMatrix)
SdrGluePointList::Insert
sal_uInt16 Insert(const SdrGluePoint &rGP)
Definition: svdglue.cxx:295
tools::Rectangle::Bottom
constexpr tools::Long Bottom() const
Color::GetGreen
sal_uInt8 GetGreen() const
basegfx::B2DPolyPolygon::append
void append(const B2DPolygon &rPolygon, sal_uInt32 nCount=1)
SdrPathObj::IsLine
bool IsLine() const
Definition: svdopath.hxx:147
XATTR_FILLCOLOR
constexpr TypedWhichId< XFillColorItem > XATTR_FILLCOLOR(XATTR_FILL_FIRST+1)
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
basegfx::B2DPolygon::setClosed
void setClosed(bool bNew)
RotatePoint
void RotatePoint(Point &rPnt, const Point &rRef, double sn, double cs)
Definition: svdtrans.hxx:114
tools::Rectangle::GetSize
constexpr Size GetSize() const
basegfx::B2DPolyPolygon::count
sal_uInt32 count() const
lcl_getAngleInOOXMLUnit
static double lcl_getAngleInOOXMLUnit(double fDY, double fDX)
Definition: EnhancedCustomShape2d.cxx:1414
lcl_getNormalizedCircleAngleRad
static double lcl_getNormalizedCircleAngleRad(const double fWR, const double fHR, const double fEllipseAngleDeg)
Definition: EnhancedCustomShape2d.cxx:1996
lcl_getNormalizedAngleRad
static double lcl_getNormalizedAngleRad(const double fCircleAngleDeg)
Definition: EnhancedCustomShape2d.cxx:2015
SdrObject::ForceGluePointList
virtual SdrGluePointList * ForceGluePointList()
Definition: svdobj.cxx:2295
SfxItemSet::Get
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
sal_uInt8
unsigned char sal_uInt8
basegfx::BColor::getGreen
double getGreen() const
SdrObjCustomShape::GetObjectRotation
double GetObjectRotation() const
Definition: svdoashp.hxx:142
EnhancedCustomShape2d::GetEnumFunc
SAL_DLLPRIVATE double GetEnumFunc(const EnhancedCustomShape::ExpressionFunct eVal) const
Definition: EnhancedCustomShape2d.cxx:829
eFillStyle
eFillStyle
Definition: fillctrl.cxx:54
EnhancedCustomShape2d::~EnhancedCustomShape2d
virtual ~EnhancedCustomShape2d() override
Definition: EnhancedCustomShape2d.cxx:624
SAL_INFO
#define SAL_INFO(area, stream)
SdrObject::GetMergedItemSet
const SfxItemSet & GetMergedItemSet() const
Definition: svdobj.cxx:1978
basegfx::utils::createPolygonFromEllipseSegment
B2DPolygon createPolygonFromEllipseSegment(const B2DPoint &rCenter, double fRadiusX, double fRadiusY, double fStart, double fEnd)
XLineEndItem::SetLineEndValue
void SetLineEndValue(const basegfx::B2DPolyPolygon &rPolyPolygon)
Definition: xlnedit.hxx:54
EnhancedCustomShape2d::seqGluePoints
css::uno::Sequence< css::drawing::EnhancedCustomShapeParameterPair > seqGluePoints
Definition: EnhancedCustomShape2d.hxx:117
EnhancedCustomShape2d::CreateLineGeometry
SdrObjectUniquePtr CreateLineGeometry()
Definition: EnhancedCustomShape2d.cxx:3018
EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter
static void SetEnhancedCustomShapeHandleParameter(css::drawing::EnhancedCustomShapeParameter &rParameter, const sal_Int32 nPara, const bool bIsSpecialValue, bool bHorz)
Definition: EnhancedCustomShape2d.cxx:389
DFF_Prop_adjust5Value
#define DFF_Prop_adjust5Value
Definition: msdffdef.hxx:155
EnhancedCustomShape2d::CreatePathObj
SAL_DLLPRIVATE SdrObjectUniquePtr CreatePathObj(bool bLineGeometryNeededOnly)
Definition: EnhancedCustomShape2d.cxx:2830
EnhancedCustomShape2d::GetHdlCount
sal_uInt32 GetHdlCount() const
Definition: EnhancedCustomShape2d.cxx:1120
SdrObjectUniquePtr
std::unique_ptr< SdrObject, SdrObjectFreeOp > SdrObjectUniquePtr
Definition: svdobj.hxx:97
DFF_Prop_geoRight
#define DFF_Prop_geoRight
Definition: msdffdef.hxx:147
makeSdrShadowItem
SdrOnOffItem makeSdrShadowItem(bool bShadow)
Definition: sdshitm.hxx:25
basegfx::utils::rgb2hsv
BColor rgb2hsv(const BColor &rRGBColor)
EnhancedCustomShape2d::EnhancedCustomShape2d
EnhancedCustomShape2d(SdrObjCustomShape &rSdrObjCustomShape)
Definition: EnhancedCustomShape2d.cxx:698
SdrCustomShapeGeometryItem::GetPropertyValueByName
css::uno::Any * GetPropertyValueByName(const OUString &rPropName)
Definition: customshapeitem.cxx:64
EnhancedCustomShape2d::ConvertSequenceToEnhancedCustomShape2dHandle
static SAL_DLLPRIVATE bool ConvertSequenceToEnhancedCustomShape2dHandle(const css::beans::PropertyValues &rHandleProperties, EnhancedCustomShape2d::Handle &rDestinationHandle)
Definition: EnhancedCustomShape2d.cxx:439
tools::Rectangle::Move
void Move(tools::Long nHorzMoveDelta, tools::Long nVertMoveDelta)
SdrGluePoint::SetAlign
void SetAlign(SdrAlign nAlg)
Definition: svdglue.hxx:147
SAL_WARN
#define SAL_WARN(area, stream)
Tuple2D< double >::getX
double getX() const
EnhancedCustomShapeTypeNames::Get
SVXCORE_DLLPUBLIC MSO_SPT Get(const OUString &)
Definition: EnhancedCustomShapeTypeNames.cxx:287
EnhancedCustomShape2d::ApplyShapeAttributes
SAL_DLLPRIVATE void ApplyShapeAttributes(const SdrCustomShapeGeometryItem &rItem)
Definition: EnhancedCustomShape2d.cxx:541
EnhancedCustomShape2d::seqCoordinates
css::uno::Sequence< css::drawing::EnhancedCustomShapeParameterPair > seqCoordinates
Definition: EnhancedCustomShape2d.hxx:115
nLength
sal_Int32 nLength
EnhancedCustomShape2d::SetAdjustValueAsDouble
SAL_DLLPRIVATE bool SetAdjustValueAsDouble(const double &rValue, const sal_Int32 nIndex)
Definition: EnhancedCustomShape2d.cxx:908
basegfx::utils::createTranslateB2DHomMatrix
B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY)
CorrectCalloutArrows
static void CorrectCalloutArrows(MSO_SPT eSpType, sal_uInt32 nLineObjectCount, std::vector< std::pair< SdrPathObjUniquePtr, double > > &vObjectList)
Definition: EnhancedCustomShape2d.cxx:2647
EnhancedCustomShape2d::AppendEnhancedCustomShapeEquationParameter
static SAL_DLLPRIVATE void AppendEnhancedCustomShapeEquationParameter(OUString &rParameter, const sal_Int32 nPara, const bool bIsSpecialValue)
Definition: EnhancedCustomShape2d.cxx:330
basegfx::utils::createPolygonFromEllipse
B2DPolygon createPolygonFromEllipse(const B2DPoint &rCenter, double fRadiusX, double fRadiusY, sal_uInt32 nStartQuadrant=0)
EnhancedCustomShape2d::seqSegments
css::uno::Sequence< css::drawing::EnhancedCustomShapeSegment > seqSegments
Definition: EnhancedCustomShape2d.hxx:114
SdrGluePoint::SetEscDir
void SetEscDir(SdrEscapeDirection nNewEsc)
Definition: svdglue.hxx:110
basegfx::BColor::setBlue
void setBlue(double fNew)
SdrGluePoint::SetPos
void SetPos(const Point &rNewPos)
Definition: svdglue.hxx:102
nValue
sal_Int16 nValue
Definition: fmsrccfg.cxx:81
basegfx::B2DPolygon::count
sal_uInt32 count() const
tools::Rectangle::GetHeight
constexpr tools::Long GetHeight() const
SdrTextObj::GetLogicRect
virtual const tools::Rectangle & GetLogicRect() const override
Definition: svdotxtr.cxx:69
basegfx::B2DPolygon::getB2DPoint
basegfx::B2DPoint const & getB2DPoint(sal_uInt32 nIndex) const
string_view.hxx
EnhancedCustomShape2d::Handle::aYRangeMaximum
css::drawing::EnhancedCustomShapeParameter aYRangeMaximum
Definition: EnhancedCustomShape2d.hxx:174
EnhancedCustomShape::ParseError
This exception is thrown, when the arithmetic expression parser failed to parse a string...
Definition: EnhancedCustomShapeFunctionParser.hxx:174
Generated on Sat Oct 23 2021 21:01:42 for LibreOffice Module svx (master) by   doxygen 1.8.10