?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update credits
[LibreOffice.git] / svx / source / svdraw / svdoashp.cxx
blobbabab98398e083bbeaa9a1ee8deea03f7042453d
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 <svx/svdoashp.hxx>
21 #include "svx/unoapi.hxx"
22 #include <svx/unoshape.hxx>
23 #include <ucbhelper/content.hxx>
24 #include <unotools/datetime.hxx>
25 #include <sfx2/lnkbase.hxx>
26 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
27 #include <com/sun/star/drawing/XShape.hpp>
28 #include <com/sun/star/drawing/XCustomShapeEngine.hpp>
29 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
30 #include <com/sun/star/beans/PropertyValue.hpp>
31 #include <com/sun/star/awt/Rectangle.hpp>
32 #include <comphelper/processfactory.hxx>
33 #include <svl/urihelper.hxx>
34 #include <com/sun/star/uno/Sequence.h>
35 #include <svx/svdogrp.hxx>
36 #include <tools/helpers.hxx>
37 #include <svx/svddrag.hxx>
38 #include <svx/xpool.hxx>
39 #include <svx/xpoly.hxx>
40 #include <svx/svdmodel.hxx>
41 #include <svx/svdpage.hxx>
42 #include "svx/svditer.hxx"
43 #include <svx/svdobj.hxx>
44 #include <svx/svdtrans.hxx>
45 #include <svx/svdetc.hxx>
46 #include <svx/svdattrx.hxx> // NotPersistItems
47 #include <svx/svdoedge.hxx> // for broadcasting connectors to Move
48 #include "svx/svdglob.hxx" // StringCache
49 #include "svx/svdstr.hrc" // the object's name
50 #include <editeng/eeitem.hxx>
51 #include "editeng/editstat.hxx"
52 #include <svx/svdoutl.hxx>
53 #include <editeng/outlobj.hxx>
54 #include <svx/sdtfchim.hxx>
55 #include "svx/EnhancedCustomShapeGeometry.hxx"
56 #include "svx/EnhancedCustomShapeTypeNames.hxx"
57 #include "svx/EnhancedCustomShape2d.hxx"
58 #include <com/sun/star/beans/PropertyValues.hpp>
59 #include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
60 #include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
61 #include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
62 #include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
63 #include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
64 #include <editeng/writingmodeitem.hxx>
65 #include <svx/xlnclit.hxx>
66 #include <svx/svxids.hrc>
67 #include <svl/whiter.hxx>
68 #include <svx/sdr/properties/customshapeproperties.hxx>
69 #include <svx/sdr/contact/viewcontactofsdrobjcustomshape.hxx>
70 #include <svx/xlntrit.hxx>
71 #include <svx/xfltrit.hxx>
72 #include <svx/xflclit.hxx>
73 #include <svx/xflgrit.hxx>
74 #include <svx/xflhtit.hxx>
75 #include <svx/xbtmpit.hxx>
76 #include <vcl/bmpacc.hxx>
77 #include <svx/svdview.hxx>
78 #include <basegfx/polygon/b2dpolypolygontools.hxx>
79 #include <basegfx/matrix/b2dhommatrix.hxx>
80 #include <basegfx/matrix/b2dhommatrixtools.hxx>
81 #include <basegfx/tools/unotools.hxx>
82 #include "svdconv.hxx"
83
84 using namespace ::com::sun::star;
85 using namespace ::com::sun::star::uno;
86 using namespace ::com::sun::star::lang;
87 using namespace ::com::sun::star::beans;
88 using namespace ::com::sun::star::drawing;
89
90 static void lcl_ShapeSegmentFromBinary( EnhancedCustomShapeSegment& rSegInfo, sal_uInt16 nSDat )
91 {
92 switch( nSDat >> 8 )
93 {
94 case 0x00 :
95 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::LINETO;
96 rSegInfo.Count = nSDat & 0xff;
97 if ( !rSegInfo.Count )
98 rSegInfo.Count = 1;
99 break;
100 case 0x20 :
101 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CURVETO;
102 rSegInfo.Count = nSDat & 0xff;
103 if ( !rSegInfo.Count )
104 rSegInfo.Count = 1;
105 break;
106 case 0x40 :
107 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::MOVETO;
108 rSegInfo.Count = nSDat & 0xff;
109 if ( !rSegInfo.Count )
110 rSegInfo.Count = 1;
111 break;
112 case 0x60 :
113 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
114 rSegInfo.Count = 0;
115 break;
116 case 0x80 :
117 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
118 rSegInfo.Count = 0;
119 break;
120 case 0xa1 :
121 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO;
122 rSegInfo.Count = ( nSDat & 0xff ) / 3;
123 break;
124 case 0xa2 :
125 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE;
126 rSegInfo.Count = ( nSDat & 0xff ) / 3;
127 break;
128 case 0xa3 :
129 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ARCTO;
130 rSegInfo.Count = ( nSDat & 0xff ) >> 2;
131 break;
132 case 0xa4 :
133 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ARC;
134 rSegInfo.Count = ( nSDat & 0xff ) >> 2;
135 break;
136 case 0xa5 :
137 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO;
138 rSegInfo.Count = ( nSDat & 0xff ) >> 2;
139 break;
140 case 0xa6 :
141 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CLOCKWISEARC;
142 rSegInfo.Count = ( nSDat & 0xff ) >> 2;
143 break;
144 case 0xa7 :
145 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX;
146 rSegInfo.Count = nSDat & 0xff;
147 break;
148 case 0xa8 :
149 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY;
150 rSegInfo.Count = nSDat & 0xff;
151 break;
152 case 0xaa :
153 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::NOFILL;
154 rSegInfo.Count = 0;
155 break;
156 case 0xab :
157 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::NOSTROKE;
158 rSegInfo.Count = 0;
159 break;
160 default:
161 case 0xf8 :
162 rSegInfo.Command = EnhancedCustomShapeSegmentCommand::UNKNOWN;
163 rSegInfo.Count = nSDat;
164 break;
165 }
166 return;
167 }
168
169 static MSO_SPT ImpGetCustomShapeType( const SdrObjCustomShape& rCustoShape )
170 {
171 MSO_SPT eRetValue = mso_sptNil;
172
173 OUString aEngine( ( (SdrCustomShapeEngineItem&)rCustoShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_ENGINE ) ).GetValue() );
174 if ( aEngine.isEmpty() || aEngine == "com.sun.star.drawing.EnhancedCustomShapeEngine" )
175 {
176 OUString sShapeType;
177 const OUString sType( "Type" );
178 SdrCustomShapeGeometryItem& rGeometryItem( (SdrCustomShapeGeometryItem&)rCustoShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
179 Any* pAny = rGeometryItem.GetPropertyValueByName( sType );
180 if ( pAny && ( *pAny >>= sShapeType ) )
181 eRetValue = EnhancedCustomShapeTypeNames::Get( sShapeType );
182 }
183 return eRetValue;
184 };
185
186 static bool ImpVerticalSwitch( const SdrObjCustomShape& rCustoShape )
187 {
188 bool bRet = false;
189 MSO_SPT eShapeType( ImpGetCustomShapeType( rCustoShape ) );
190 switch( eShapeType )
191 {
192 case mso_sptAccentBorderCallout90 : // 2 ortho
193 case mso_sptBorderCallout1 : // 2 diag
194 case mso_sptBorderCallout2 : // 3
195 {
196 bRet = true;
197 }
198 break;
199 default: break;
200 }
201 return bRet;
202 }
203
204 // #i37011# create a clone with all attributes changed to shadow attributes
205 // and translation executed, too.
206 SdrObject* ImpCreateShadowObjectClone(const SdrObject& rOriginal, const SfxItemSet& rOriginalSet)
207 {
208 SdrObject* pRetval = 0L;
209 const sal_Bool bShadow(((SdrShadowItem&)rOriginalSet.Get(SDRATTR_SHADOW)).GetValue());
210
211 if(bShadow)
212 {
213 // create a shadow representing object
214 const sal_Int32 nXDist(((SdrShadowXDistItem&)(rOriginalSet.Get(SDRATTR_SHADOWXDIST))).GetValue());
215 const sal_Int32 nYDist(((SdrShadowYDistItem&)(rOriginalSet.Get(SDRATTR_SHADOWYDIST))).GetValue());
216 const ::Color aShadowColor(((SdrShadowColorItem&)(rOriginalSet.Get(SDRATTR_SHADOWCOLOR))).GetColorValue());
217 const sal_uInt16 nShadowTransparence(((SdrShadowTransparenceItem&)(rOriginalSet.Get(SDRATTR_SHADOWTRANSPARENCE))).GetValue());
218 pRetval = rOriginal.Clone();
219 DBG_ASSERT(pRetval, "ImpCreateShadowObjectClone: Could not clone object (!)");
220
221 // look for used stuff
222 SdrObjListIter aIterator(rOriginal);
223 bool bLineUsed(false);
224 bool bAllFillUsed(false);
225 bool bSolidFillUsed(false);
226 bool bGradientFillUsed(false);
227 bool bHatchFillUsed(false);
228 bool bBitmapFillUsed(false);
229
230 while(aIterator.IsMore())
231 {
232 SdrObject* pObj = aIterator.Next();
233 XFillStyle eFillStyle = ((XFillStyleItem&)(pObj->GetMergedItem(XATTR_FILLSTYLE))).GetValue();
234
235 if(!bLineUsed)
236 {
237 XLineStyle eLineStyle = ((XLineStyleItem&)(pObj->GetMergedItem(XATTR_LINESTYLE))).GetValue();
238
239 if(XLINE_NONE != eLineStyle)
240 {
241 bLineUsed = true;
242 }
243 }
244
245 if(!bAllFillUsed)
246 {
247 if(!bSolidFillUsed && XFILL_SOLID == eFillStyle)
248 {
249 bSolidFillUsed = true;
250 bAllFillUsed = (bSolidFillUsed && bGradientFillUsed && bHatchFillUsed && bBitmapFillUsed);
251 }
252 if(!bGradientFillUsed && XFILL_GRADIENT == eFillStyle)
253 {
254 bGradientFillUsed = true;
255 bAllFillUsed = (bSolidFillUsed && bGradientFillUsed && bHatchFillUsed && bBitmapFillUsed);
256 }
257 if(!bHatchFillUsed && XFILL_HATCH == eFillStyle)
258 {
259 bHatchFillUsed = true;
260 bAllFillUsed = (bSolidFillUsed && bGradientFillUsed && bHatchFillUsed && bBitmapFillUsed);
261 }
262 if(!bBitmapFillUsed && XFILL_BITMAP == eFillStyle)
263 {
264 bBitmapFillUsed = true;
265 bAllFillUsed = (bSolidFillUsed && bGradientFillUsed && bHatchFillUsed && bBitmapFillUsed);
266 }
267 }
268 }
269
270 // translate to shadow coordinates
271 pRetval->NbcMove(Size(nXDist, nYDist));
272
273 // set items as needed
274 SfxItemSet aTempSet(rOriginalSet);
275
276 // if a SvxWritingModeItem (Top->Bottom) is set the text object
277 // is creating a paraobject, but paraobjects can not be created without model. So
278 // we are preventing the crash by setting the writing mode always left to right,
279 // this is not bad since our shadow geometry does not contain text.
280 aTempSet.Put( SvxWritingModeItem( com::sun::star::text::WritingMode_LR_TB, SDRATTR_TEXTDIRECTION ) );
281
282 // no shadow
283 aTempSet.Put(SdrShadowItem(sal_False));
284 aTempSet.Put(SdrShadowXDistItem(0L));
285 aTempSet.Put(SdrShadowYDistItem(0L));
286
287 // line color and transparency like shadow
288 if(bLineUsed)
289 {
290 aTempSet.Put(XLineColorItem(String(), aShadowColor));
291 aTempSet.Put(XLineTransparenceItem(nShadowTransparence));
292 }
293
294 // fill color and transparency like shadow
295 if(bSolidFillUsed)
296 {
297 aTempSet.Put(XFillColorItem(String(), aShadowColor));
298 aTempSet.Put(XFillTransparenceItem(nShadowTransparence));
299 }
300
301 // gradient and transparency like shadow
302 if(bGradientFillUsed)
303 {
304 XGradient aGradient(((XFillGradientItem&)(rOriginalSet.Get(XATTR_FILLGRADIENT))).GetGradientValue());
305 sal_uInt8 nStartLuminance(aGradient.GetStartColor().GetLuminance());
306 sal_uInt8 nEndLuminance(aGradient.GetEndColor().GetLuminance());
307
308 if(aGradient.GetStartIntens() != 100)
309 {
310 nStartLuminance = (sal_uInt8)(nStartLuminance * ((double)aGradient.GetStartIntens() / 100.0));
311 }
312
313 if(aGradient.GetEndIntens() != 100)
314 {
315 nEndLuminance = (sal_uInt8)(nEndLuminance * ((double)aGradient.GetEndIntens() / 100.0));
316 }
317
318 ::Color aStartColor(
319 (sal_uInt8)((nStartLuminance * aShadowColor.GetRed()) / 256),
320 (sal_uInt8)((nStartLuminance * aShadowColor.GetGreen()) / 256),
321 (sal_uInt8)((nStartLuminance * aShadowColor.GetBlue()) / 256));
322
323 ::Color aEndColor(
324 (sal_uInt8)((nEndLuminance * aShadowColor.GetRed()) / 256),
325 (sal_uInt8)((nEndLuminance * aShadowColor.GetGreen()) / 256),
326 (sal_uInt8)((nEndLuminance * aShadowColor.GetBlue()) / 256));
327
328 aGradient.SetStartColor(aStartColor);
329 aGradient.SetEndColor(aEndColor);
330 aTempSet.Put(XFillGradientItem(aGradient));
331 aTempSet.Put(XFillTransparenceItem(nShadowTransparence));
332 }
333
334 // hatch and transparency like shadow
335 if(bHatchFillUsed)
336 {
337 XHatch aHatch(((XFillHatchItem&)(rOriginalSet.Get(XATTR_FILLHATCH))).GetHatchValue());
338 aHatch.SetColor(aShadowColor);
339 aTempSet.Put(XFillHatchItem(aTempSet.GetPool(), aHatch));
340 aTempSet.Put(XFillTransparenceItem(nShadowTransparence));
341 }
342
343 // bitmap and transparency like shadow
344 if(bBitmapFillUsed)
345 {
346 GraphicObject aGraphicObject(((XFillBitmapItem&)(rOriginalSet.Get(XATTR_FILLBITMAP))).GetGraphicObject());
347 const BitmapEx aBitmapEx(aGraphicObject.GetGraphic().GetBitmapEx());
348 Bitmap aBitmap(aBitmapEx.GetBitmap());
349
350 if(!aBitmap.IsEmpty())
351 {
352 BitmapReadAccess* pReadAccess = aBitmap.AcquireReadAccess();
353
354 if(pReadAccess)
355 {
356 Bitmap aDestBitmap(aBitmap.GetSizePixel(), 24L);
357 BitmapWriteAccess* pWriteAccess = aDestBitmap.AcquireWriteAccess();
358
359 if(pWriteAccess)
360 {
361 for(sal_Int32 y(0L); y < pReadAccess->Height(); y++)
362 {
363 for(sal_Int32 x(0L); x < pReadAccess->Width(); x++)
364 {
365 sal_uInt16 nLuminance((sal_uInt16)pReadAccess->GetLuminance(y, x) + 1);
366 const BitmapColor aDestColor(
367 (sal_uInt8)((nLuminance * (sal_uInt16)aShadowColor.GetRed()) >> 8L),
368 (sal_uInt8)((nLuminance * (sal_uInt16)aShadowColor.GetGreen()) >> 8L),
369 (sal_uInt8)((nLuminance * (sal_uInt16)aShadowColor.GetBlue()) >> 8L));
370 pWriteAccess->SetPixel(y, x, aDestColor);
371 }
372 }
373
374 aDestBitmap.ReleaseAccess(pWriteAccess);
375 }
376
377 aBitmap.ReleaseAccess(pReadAccess);
378
379 if(aBitmapEx.IsTransparent())
380 {
381 if(aBitmapEx.IsAlpha())
382 {
383 aGraphicObject.SetGraphic(Graphic(BitmapEx(aDestBitmap, aBitmapEx.GetAlpha())));
384 }
385 else
386 {
387 aGraphicObject.SetGraphic(Graphic(BitmapEx(aDestBitmap, aBitmapEx.GetMask())));
388 }
389 }
390 else
391 {
392 aGraphicObject.SetGraphic(Graphic(aDestBitmap));
393 }
394 }
395 }
396
397 aTempSet.Put(XFillBitmapItem(aTempSet.GetPool(), aGraphicObject));
398 aTempSet.Put(XFillTransparenceItem(nShadowTransparence));
399 }
400
401 // set attributes and paint shadow object
402 pRetval->SetMergedItemSet( aTempSet );
403 }
404 return pRetval;
405 }
406
407 ////////////////////////////////////////////////////////////////////////////////////////////////////
408
409 Reference< XCustomShapeEngine > SdrObjCustomShape::GetCustomShapeEngine() const
410 {
411 if (mxCustomShapeEngine.is())
412 return mxCustomShapeEngine;
413
414 String aEngine(((SdrCustomShapeEngineItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_ENGINE )).GetValue());
415 if ( !aEngine.Len() )
416 aEngine = String( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.drawing.EnhancedCustomShapeEngine" ) );
417
418 Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
419
420 Reference< XShape > aXShape = GetXShapeForSdrObject(const_cast<SdrObjCustomShape*>(this));
421 if ( aXShape.is() )
422 {
423 if ( aEngine.Len() )
424 {
425 Sequence< Any > aArgument( 1 );
426 Sequence< PropertyValue > aPropValues( 1 );
427 aPropValues[ 0 ].Name = OUString("CustomShape");
428 aPropValues[ 0 ].Value <<= aXShape;
429 aArgument[ 0 ] <<= aPropValues;
430 Reference< XInterface > xInterface( xContext->getServiceManager()->createInstanceWithArgumentsAndContext( aEngine, aArgument, xContext ) );
431 if ( xInterface.is() )
432 mxCustomShapeEngine = Reference< XCustomShapeEngine >( xInterface, UNO_QUERY );
433 }
434 }
435
436 return mxCustomShapeEngine;
437 }
438
439 const SdrObject* SdrObjCustomShape::GetSdrObjectFromCustomShape() const
440 {
441 if ( !mXRenderedCustomShape.is() )
442 {
443 Reference< XCustomShapeEngine > xCustomShapeEngine( GetCustomShapeEngine() );
444 if ( xCustomShapeEngine.is() )
445 ((SdrObjCustomShape*)this)->mXRenderedCustomShape = xCustomShapeEngine->render();
446 }
447 SdrObject* pRenderedCustomShape = mXRenderedCustomShape.is()
448 ? GetSdrObjectFromXShape( mXRenderedCustomShape )
449 : NULL;
450 return pRenderedCustomShape;
451 }
452
453 // #i37011# Shadow geometry creation
454 const SdrObject* SdrObjCustomShape::GetSdrObjectShadowFromCustomShape() const
455 {
456 if(!mpLastShadowGeometry)
457 {
458 const SdrObject* pSdrObject = GetSdrObjectFromCustomShape();
459 if(pSdrObject)
460 {
461 const SfxItemSet& rOriginalSet = GetObjectItemSet();
462 const sal_Bool bShadow(((SdrShadowItem&)rOriginalSet.Get( SDRATTR_SHADOW )).GetValue());
463
464 if(bShadow)
465 {
466 // create a clone with all attributes changed to shadow attributes
467 // and translation executed, too.
468 ((SdrObjCustomShape*)this)->mpLastShadowGeometry = ImpCreateShadowObjectClone(*pSdrObject, rOriginalSet);
469 }
470 }
471 }
472
473 return mpLastShadowGeometry;
474 }
475
476 sal_Bool SdrObjCustomShape::IsTextPath() const
477 {
478 const OUString sTextPath( "TextPath" );
479 sal_Bool bTextPathOn = sal_False;
480 SdrCustomShapeGeometryItem& rGeometryItem = (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
481 Any* pAny = rGeometryItem.GetPropertyValueByName( sTextPath, sTextPath );
482 if ( pAny )
483 *pAny >>= bTextPathOn;
484 return bTextPathOn;
485 }
486
487 sal_Bool SdrObjCustomShape::UseNoFillStyle() const
488 {
489 sal_Bool bRet = sal_False;
490 OUString sShapeType;
491 const OUString sType( "Type" );
492 SdrCustomShapeGeometryItem& rGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
493 Any* pAny = rGeometryItem.GetPropertyValueByName( sType );
494 if ( pAny )
495 *pAny >>= sShapeType;
496 bRet = IsCustomShapeFilledByDefault( EnhancedCustomShapeTypeNames::Get( sType ) ) == 0;
497
498 return bRet;
499 }
500
501 sal_Bool SdrObjCustomShape::IsMirroredX() const
502 {
503 sal_Bool bMirroredX = sal_False;
504 SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
505 const OUString sMirroredX( "MirroredX" );
506 com::sun::star::uno::Any* pAny = aGeometryItem.GetPropertyValueByName( sMirroredX );
507 if ( pAny )
508 *pAny >>= bMirroredX;
509 return bMirroredX;
510 }
511 sal_Bool SdrObjCustomShape::IsMirroredY() const
512 {
513 sal_Bool bMirroredY = sal_False;
514 SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
515 const OUString sMirroredY( "MirroredY" );
516 com::sun::star::uno::Any* pAny = aGeometryItem.GetPropertyValueByName( sMirroredY );
517 if ( pAny )
518 *pAny >>= bMirroredY;
519 return bMirroredY;
520 }
521 void SdrObjCustomShape::SetMirroredX( const sal_Bool bMirrorX )
522 {
523 SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
524 const OUString sMirroredX( "MirroredX" );
525 PropertyValue aPropVal;
526 aPropVal.Name = sMirroredX;
527 aPropVal.Value <<= bMirrorX;
528 aGeometryItem.SetPropertyValue( aPropVal );
529 SetMergedItem( aGeometryItem );
530 }
531 void SdrObjCustomShape::SetMirroredY( const sal_Bool bMirrorY )
532 {
533 SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
534 const OUString sMirroredY( "MirroredY" );
535 PropertyValue aPropVal;
536 aPropVal.Name = sMirroredY;
537 aPropVal.Value <<= bMirrorY;
538 aGeometryItem.SetPropertyValue( aPropVal );
539 SetMergedItem( aGeometryItem );
540 }
541
542 double SdrObjCustomShape::GetObjectRotation() const
543 {
544 return fObjectRotation;
545 }
546
547 bool SdrObjCustomShape::IsPostRotate() const
548 {
549 const com::sun::star::uno::Any* pAny;
550 bool bPostRotate = false;
551 SdrCustomShapeGeometryItem& rGeometryItem = (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
552 pAny = rGeometryItem.GetPropertyValueByName( "IsPostRotateAngle" );
553 if ( pAny )
554 *pAny >>= bPostRotate;
555 return bPostRotate;
556 }
557
558 double SdrObjCustomShape::GetExtraTextRotation( const bool bPreRotation ) const
559 {
560 const com::sun::star::uno::Any* pAny;
561 SdrCustomShapeGeometryItem& rGeometryItem = (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
562 const OUString sTextRotateAngle( "TextRotateAngle" );
563 const OUString sTextPreRotateAngle( "TextPreRotateAngle" );
564 pAny = rGeometryItem.GetPropertyValueByName( bPreRotation ? sTextPreRotateAngle : sTextRotateAngle );
565 double fExtraTextRotateAngle = 0.0;
566 if ( pAny )
567 *pAny >>= fExtraTextRotateAngle;
568 return fExtraTextRotateAngle;
569 }
570
571 sal_Bool SdrObjCustomShape::GetTextBounds( Rectangle& rTextBound ) const
572 {
573 sal_Bool bRet = sal_False;
574
575 Reference< XCustomShapeEngine > xCustomShapeEngine( GetCustomShapeEngine() );
576 if ( xCustomShapeEngine.is() )
577 {
578 awt::Rectangle aR( xCustomShapeEngine->getTextBounds() );
579 if ( aR.Width > 1 && aR.Height > 1 )
580 {
581 rTextBound = Rectangle( Point( aR.X, aR.Y ), Size( aR.Width, aR.Height ) );
582 bRet = sal_True;
583 }
584 }
585 return bRet;
586 }
587 basegfx::B2DPolyPolygon SdrObjCustomShape::GetLineGeometry( const SdrObjCustomShape* pCustomShape, const sal_Bool bBezierAllowed )
588 {
589 basegfx::B2DPolyPolygon aRetval;
590 Reference< XCustomShapeEngine > xCustomShapeEngine( pCustomShape->GetCustomShapeEngine() );
591 if ( xCustomShapeEngine.is() )
592 {
593 com::sun::star::drawing::PolyPolygonBezierCoords aBezierCoords = xCustomShapeEngine->getLineGeometry();
594 try
595 {
596 aRetval = basegfx::unotools::polyPolygonBezierToB2DPolyPolygon( aBezierCoords );
597 if ( !bBezierAllowed && aRetval.areControlPointsUsed())
598 {
599 aRetval = basegfx::tools::adaptiveSubdivideByAngle(aRetval);
600 }
601 }
602 catch ( const com::sun::star::lang::IllegalArgumentException & )
603 {
604 }
605 }
606 return aRetval;
607 }
608
609 std::vector< SdrCustomShapeInteraction > SdrObjCustomShape::GetInteractionHandles( const SdrObjCustomShape* pCustomShape ) const
610 {
611 std::vector< SdrCustomShapeInteraction > xRet;
612 try
613 {
614 Reference< XCustomShapeEngine > xCustomShapeEngine( pCustomShape->GetCustomShapeEngine() );
615 if ( xCustomShapeEngine.is() )
616 {
617 int i;
618 Sequence< Reference< XCustomShapeHandle > > xInteractionHandles( xCustomShapeEngine->getInteraction() );
619 for ( i = 0; i < xInteractionHandles.getLength(); i++ )
620 {
621 if ( xInteractionHandles[ i ].is() )
622 {
623 SdrCustomShapeInteraction aSdrCustomShapeInteraction;
624 aSdrCustomShapeInteraction.xInteraction = xInteractionHandles[ i ];
625 aSdrCustomShapeInteraction.aPosition = xInteractionHandles[ i ]->getPosition();
626
627 sal_Int32 nMode = 0;
628 switch( ImpGetCustomShapeType( *this ) )
629 {
630 case mso_sptAccentBorderCallout90 : // 2 ortho
631 {
632 if ( !i )
633 nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED | CUSTOMSHAPE_HANDLE_CREATE_FIXED;
634 else if ( i == 1)
635 nMode |= CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X | CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y | CUSTOMSHAPE_HANDLE_MOVE_SHAPE | CUSTOMSHAPE_HANDLE_ORTHO4;
636 }
637 break;
638
639 case mso_sptWedgeRectCallout :
640 case mso_sptWedgeRRectCallout :
641 case mso_sptCloudCallout :
642 case mso_sptWedgeEllipseCallout :
643 {
644 if ( !i )
645 nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED;
646 }
647 break;
648
649 case mso_sptBorderCallout1 : // 2 diag
650 {
651 if ( !i )
652 nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED | CUSTOMSHAPE_HANDLE_CREATE_FIXED;
653 else if ( i == 1 )
654 nMode |= CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X | CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y | CUSTOMSHAPE_HANDLE_MOVE_SHAPE;
655 }
656 break;
657 case mso_sptBorderCallout2 : // 3
658 {
659 if ( !i )
660 nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED | CUSTOMSHAPE_HANDLE_CREATE_FIXED;
661 else if ( i == 2 )
662 nMode |= CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X | CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y | CUSTOMSHAPE_HANDLE_MOVE_SHAPE;
663 }
664 break;
665 case mso_sptCallout90 :
666 case mso_sptAccentCallout90 :
667 case mso_sptBorderCallout90 :
668 case mso_sptCallout1 :
669 case mso_sptCallout2 :
670 case mso_sptCallout3 :
671 case mso_sptAccentCallout1 :
672 case mso_sptAccentCallout2 :
673 case mso_sptAccentCallout3 :
674 case mso_sptBorderCallout3 :
675 case mso_sptAccentBorderCallout1 :
676 case mso_sptAccentBorderCallout2 :
677 case mso_sptAccentBorderCallout3 :
678 {
679 if ( !i )
680 nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED | CUSTOMSHAPE_HANDLE_CREATE_FIXED;
681 }
682 break;
683 default: break;
684 }
685 aSdrCustomShapeInteraction.nMode = nMode;
686 xRet.push_back( aSdrCustomShapeInteraction );
687 }
688 }
689 }
690 }
691 catch( const uno::RuntimeException& )
692 {
693 }
694 return xRet;
695 }
696
697 //////////////////////////////////////////////////////////////////////////////
698 // BaseProperties section
699 #define DEFAULT_MINIMUM_SIGNED_COMPARE ((sal_Int32)0x80000000)
700 #define DEFAULT_MAXIMUM_SIGNED_COMPARE ((sal_Int32)0x7fffffff)
701
702 static sal_Int32 GetNumberOfProperties ( const SvxMSDffHandle* pData )
703 {
704 sal_Int32 nPropertiesNeeded=1; // position is always needed
705 sal_Int32 nFlags = pData->nFlags;
706
707 if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_X )
708 nPropertiesNeeded++;
709 if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_Y )
710 nPropertiesNeeded++;
711 if ( nFlags & MSDFF_HANDLE_FLAGS_SWITCHED )
712 nPropertiesNeeded++;
713 if ( nFlags & MSDFF_HANDLE_FLAGS_POLAR )
714 {
715 nPropertiesNeeded++;
716 if ( nFlags & MSDFF_HANDLE_FLAGS_RADIUS_RANGE )
717 {
718 if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
719 nPropertiesNeeded++;
720 if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
721 nPropertiesNeeded++;
722 }
723 }
724 else if ( nFlags & MSDFF_HANDLE_FLAGS_RANGE )
725 {
726 if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
727 nPropertiesNeeded++;
728 if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
729 nPropertiesNeeded++;
730 if ( pData->nRangeYMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
731 nPropertiesNeeded++;
732 if ( pData->nRangeYMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
733 nPropertiesNeeded++;
734 }
735
736 return nPropertiesNeeded;
737 }
738
739 static void lcl_ShapePropertiesFromDFF( const SvxMSDffHandle* pData, com::sun::star::beans::PropertyValues& rPropValues )
740 {
741 sal_Int32 nFlags = pData->nFlags, n=0;
742
743 // POSITION
744 {
745 const OUString sPosition( "Position" );
746 ::com::sun::star::drawing::EnhancedCustomShapeParameterPair aPosition;
747 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aPosition.First, pData->nPositionX, true, true );
748 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aPosition.Second, pData->nPositionY, true, false );
749 rPropValues[ n ].Name = sPosition;
750 rPropValues[ n++ ].Value <<= aPosition;
751 }
752 if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_X )
753 {
754 const OUString sMirroredX( "MirroredX" );
755 sal_Bool bMirroredX = sal_True;
756 rPropValues[ n ].Name = sMirroredX;
757 rPropValues[ n++ ].Value <<= bMirroredX;
758 }
759 if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_Y )
760 {
761 const OUString sMirroredY( "MirroredY" );
762 sal_Bool bMirroredY = sal_True;
763 rPropValues[ n ].Name = sMirroredY;
764 rPropValues[ n++ ].Value <<= bMirroredY;
765 }
766 if ( nFlags & MSDFF_HANDLE_FLAGS_SWITCHED )
767 {
768 const OUString sSwitched( "Switched" );
769 sal_Bool bSwitched = sal_True;
770 rPropValues[ n ].Name = sSwitched;
771 rPropValues[ n++ ].Value <<= bSwitched;
772 }
773 if ( nFlags & MSDFF_HANDLE_FLAGS_POLAR )
774 {
775 const OUString sPolar( "Polar" );
776 ::com::sun::star::drawing::EnhancedCustomShapeParameterPair aCenter;
777 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aCenter.First, pData->nCenterX,
778 ( nFlags & MSDFF_HANDLE_FLAGS_CENTER_X_IS_SPECIAL ) != 0, true );
779 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aCenter.Second, pData->nCenterY,
780 ( nFlags & MSDFF_HANDLE_FLAGS_CENTER_Y_IS_SPECIAL ) != 0, false );
781 rPropValues[ n ].Name = sPolar;
782 rPropValues[ n++ ].Value <<= aCenter;
783 if ( nFlags & MSDFF_HANDLE_FLAGS_RADIUS_RANGE )
784 {
785 if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
786 {
787 const OUString sRadiusRangeMinimum( "RadiusRangeMinimum" );
788 ::com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
789 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRadiusRangeMinimum, pData->nRangeXMin,
790 ( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MIN_IS_SPECIAL ) != 0, true );
791 rPropValues[ n ].Name = sRadiusRangeMinimum;
792 rPropValues[ n++ ].Value <<= aRadiusRangeMinimum;
793 }
794 if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
795 {
796 const OUString sRadiusRangeMaximum( "RadiusRangeMaximum" );
797 ::com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
798 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRadiusRangeMaximum, pData->nRangeXMax,
799 ( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MAX_IS_SPECIAL ) != 0, false );
800 rPropValues[ n ].Name = sRadiusRangeMaximum;
801 rPropValues[ n++ ].Value <<= aRadiusRangeMaximum;
802 }
803 }
804 }
805 else if ( nFlags & MSDFF_HANDLE_FLAGS_RANGE )
806 {
807 if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
808 {
809 const OUString sRangeXMinimum( "RangeXMinimum" );
810 ::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeXMinimum;
811 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeXMinimum, pData->nRangeXMin,
812 ( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MIN_IS_SPECIAL ) != 0, true );
813 rPropValues[ n ].Name = sRangeXMinimum;
814 rPropValues[ n++ ].Value <<= aRangeXMinimum;
815 }
816 if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
817 {
818 const OUString sRangeXMaximum( "RangeXMaximum" );
819 ::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeXMaximum;
820 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeXMaximum, pData->nRangeXMax,
821 ( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MAX_IS_SPECIAL ) != 0, false );
822 rPropValues[ n ].Name = sRangeXMaximum;
823 rPropValues[ n++ ].Value <<= aRangeXMaximum;
824 }
825 if ( pData->nRangeYMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
826 {
827 const OUString sRangeYMinimum( "RangeYMinimum" );
828 ::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeYMinimum;
829 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeYMinimum, pData->nRangeYMin,
830 ( nFlags & MSDFF_HANDLE_FLAGS_RANGE_Y_MIN_IS_SPECIAL ) != 0, true );
831 rPropValues[ n ].Name = sRangeYMinimum;
832 rPropValues[ n++ ].Value <<= aRangeYMinimum;
833 }
834 if ( pData->nRangeYMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
835 {
836 const OUString sRangeYMaximum( "RangeYMaximum" );
837 ::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeYMaximum;
838 EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeYMaximum, pData->nRangeYMax,
839 ( nFlags & MSDFF_HANDLE_FLAGS_RANGE_Y_MAX_IS_SPECIAL ) != 0, false );
840 rPropValues[ n ].Name = sRangeYMaximum;
841 rPropValues[ n++ ].Value <<= aRangeYMaximum;
842 }
843 }
844 return;
845 }
846
847 sdr::properties::BaseProperties* SdrObjCustomShape::CreateObjectSpecificProperties()
848 {
849 return new sdr::properties::CustomShapeProperties(*this);
850 }
851
852 TYPEINIT1(SdrObjCustomShape,SdrTextObj);
853 SdrObjCustomShape::SdrObjCustomShape() :
854 SdrTextObj(),
855 fObjectRotation( 0.0 ),
856 mpLastShadowGeometry(0L)
857 {
858 bTextFrame = sal_True;
859 }
860
861 SdrObjCustomShape::~SdrObjCustomShape()
862 {
863 // delete buffered display geometry
864 InvalidateRenderGeometry();
865 }
866
867 void SdrObjCustomShape::MergeDefaultAttributes( const OUString* pType )
868 {
869 PropertyValue aPropVal;
870 OUString sShapeType;
871 const OUString sType( "Type" );
872 SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
873 if ( pType && !pType->isEmpty() )
874 {
875 sal_Int32 nType = pType->toInt32();
876 if ( nType )
877 sShapeType = EnhancedCustomShapeTypeNames::Get( static_cast< MSO_SPT >( nType ) );
878 else
879 sShapeType = *pType;
880
881 aPropVal.Name = sType;
882 aPropVal.Value <<= sShapeType;
883 aGeometryItem.SetPropertyValue( aPropVal );
884 }
885 else
886 {
887 Any *pAny = aGeometryItem.GetPropertyValueByName( sType );
888 if ( pAny )
889 *pAny >>= sShapeType;
890 }
891 MSO_SPT eSpType = EnhancedCustomShapeTypeNames::Get( sShapeType );
892
893 const sal_Int32* pDefData = NULL;
894 const mso_CustomShape* pDefCustomShape = GetCustomShapeContent( eSpType );
895 if ( pDefCustomShape )
896 pDefData = pDefCustomShape->pDefData;
897
898 com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > seqAdjustmentValues;
899
900 //////////////////////
901 // AdjustmentValues //
902 //////////////////////
903 const OUString sAdjustmentValues( "AdjustmentValues" );
904 const Any* pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sAdjustmentValues );
905 if ( pAny )
906 *pAny >>= seqAdjustmentValues;
907 if ( pDefCustomShape && pDefData ) // now check if we have to default some adjustment values
908 {
909 // first check if there are adjustment values are to be appended
910 sal_Int32 i, nAdjustmentValues = seqAdjustmentValues.getLength();
911 sal_Int32 nAdjustmentDefaults = *pDefData++;
912 if ( nAdjustmentDefaults > nAdjustmentValues )
913 {
914 seqAdjustmentValues.realloc( nAdjustmentDefaults );
915 for ( i = nAdjustmentValues; i < nAdjustmentDefaults; i++ )
916 {
917 seqAdjustmentValues[ i ].Value <<= pDefData[ i ];
918 seqAdjustmentValues[ i ].State = com::sun::star::beans::PropertyState_DIRECT_VALUE;
919 }
920 }
921 // check if there are defaulted adjustment values that should be filled the hard coded defaults (pDefValue)
922 sal_Int32 nCount = nAdjustmentValues > nAdjustmentDefaults ? nAdjustmentDefaults : nAdjustmentValues;
923 for ( i = 0; i < nCount; i++ )
924 {
925 if ( seqAdjustmentValues[ i ].State != com::sun::star::beans::PropertyState_DIRECT_VALUE )
926 {
927 seqAdjustmentValues[ i ].Value <<= pDefData[ i ];
928 seqAdjustmentValues[ i ].State = com::sun::star::beans::PropertyState_DIRECT_VALUE;
929 }
930 }
931 }
932 aPropVal.Name = sAdjustmentValues;
933 aPropVal.Value <<= seqAdjustmentValues;
934 aGeometryItem.SetPropertyValue( aPropVal );
935
936 ///////////////
937 // Coordsize //
938 ///////////////
939 const OUString sViewBox( "ViewBox" );
940 const Any* pViewBox = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sViewBox );
941 com::sun::star::awt::Rectangle aViewBox;
942 if ( !pViewBox || !(*pViewBox >>= aViewBox ) )
943 {
944 if ( pDefCustomShape )
945 {
946 aViewBox.X = 0;
947 aViewBox.Y = 0;
948 aViewBox.Width = pDefCustomShape->nCoordWidth;
949 aViewBox.Height= pDefCustomShape->nCoordHeight;
950 aPropVal.Name = sViewBox;
951 aPropVal.Value <<= aViewBox;
952 aGeometryItem.SetPropertyValue( aPropVal );
953 }
954 }
955
956 const OUString sPath( "Path" );
957
958 //////////////////////
959 // Path/Coordinates //
960 //////////////////////
961 const OUString sCoordinates( "Coordinates" );
962 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sCoordinates );
963 if ( !pAny && pDefCustomShape && pDefCustomShape->nVertices && pDefCustomShape->pVertices )
964 {
965 com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> seqCoordinates;
966
967 sal_Int32 i, nCount = pDefCustomShape->nVertices;
968 seqCoordinates.realloc( nCount );
969 for ( i = 0; i < nCount; i++ )
970 {
971 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqCoordinates[ i ].First, pDefCustomShape->pVertices[ i ].nValA );
972 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqCoordinates[ i ].Second, pDefCustomShape->pVertices[ i ].nValB );
973 }
974 aPropVal.Name = sCoordinates;
975 aPropVal.Value <<= seqCoordinates;
976 aGeometryItem.SetPropertyValue( sPath, aPropVal );
977 }
978
979 // Path/GluePoints //
980 const OUString sGluePoints( "GluePoints" );
981 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sGluePoints );
982 if ( !pAny && pDefCustomShape && pDefCustomShape->nGluePoints && pDefCustomShape->pGluePoints )
983 {
984 com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> seqGluePoints;
985 sal_Int32 i, nCount = pDefCustomShape->nGluePoints;
986 seqGluePoints.realloc( nCount );
987 for ( i = 0; i < nCount; i++ )
988 {
989 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqGluePoints[ i ].First, pDefCustomShape->pGluePoints[ i ].nValA );
990 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqGluePoints[ i ].Second, pDefCustomShape->pGluePoints[ i ].nValB );
991 }
992 aPropVal.Name = sGluePoints;
993 aPropVal.Value <<= seqGluePoints;
994 aGeometryItem.SetPropertyValue( sPath, aPropVal );
995 }
996
997 // Path/Segments //
998 const OUString sSegments( "Segments" );
999 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sSegments );
1000 if ( !pAny && pDefCustomShape && pDefCustomShape->nElements && pDefCustomShape->pElements )
1001 {
1002 com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > seqSegments;
1003
1004 sal_Int32 i, nCount = pDefCustomShape->nElements;
1005 seqSegments.realloc( nCount );
1006 for ( i = 0; i < nCount; i++ )
1007 {
1008 EnhancedCustomShapeSegment& rSegInfo = seqSegments[ i ];
1009 sal_uInt16 nSDat = pDefCustomShape->pElements[ i ];
1010 lcl_ShapeSegmentFromBinary( rSegInfo, nSDat );
1011 }
1012 aPropVal.Name = sSegments;
1013 aPropVal.Value <<= seqSegments;
1014 aGeometryItem.SetPropertyValue( sPath, aPropVal );
1015 }
1016
1017 // Path/StretchX //
1018 const OUString sStretchX( "StretchX" );
1019 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sStretchX );
1020 if ( !pAny && pDefCustomShape )
1021 {
1022 sal_Int32 nXRef = pDefCustomShape->nXRef;
1023 if ( ( nXRef != DEFAULT_MINIMUM_SIGNED_COMPARE ) )
1024 {
1025 aPropVal.Name = sStretchX;
1026 aPropVal.Value <<= nXRef;
1027 aGeometryItem.SetPropertyValue( sPath, aPropVal );
1028 }
1029 }
1030
1031 // Path/StretchY //
1032 const OUString sStretchY( "StretchY" );
1033 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sStretchY );
1034 if ( !pAny && pDefCustomShape )
1035 {
1036 sal_Int32 nYRef = pDefCustomShape->nYRef;
1037 if ( ( nYRef != DEFAULT_MINIMUM_SIGNED_COMPARE ) )
1038 {
1039 aPropVal.Name = sStretchY;
1040 aPropVal.Value <<= nYRef;
1041 aGeometryItem.SetPropertyValue( sPath, aPropVal );
1042 }
1043 }
1044
1045 // Path/TextFrames //
1046 const OUString sTextFrames( "TextFrames" );
1047 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sTextFrames );
1048 if ( !pAny && pDefCustomShape && pDefCustomShape->nTextRect && pDefCustomShape->pTextRect )
1049 {
1050 com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > seqTextFrames;
1051
1052 sal_Int32 i, nCount = pDefCustomShape->nTextRect;
1053 seqTextFrames.realloc( nCount );
1054 const SvxMSDffTextRectangles* pRectangles = pDefCustomShape->pTextRect;
1055 for ( i = 0; i < nCount; i++, pRectangles++ )
1056 {
1057 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames[ i ].TopLeft.First, pRectangles->nPairA.nValA );
1058 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames[ i ].TopLeft.Second, pRectangles->nPairA.nValB );
1059 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames[ i ].BottomRight.First, pRectangles->nPairB.nValA );
1060 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames[ i ].BottomRight.Second, pRectangles->nPairB.nValB );
1061 }
1062 aPropVal.Name = sTextFrames;
1063 aPropVal.Value <<= seqTextFrames;
1064 aGeometryItem.SetPropertyValue( sPath, aPropVal );
1065 }
1066
1067 // Equations //
1068 const OUString sEquations( "Equations" );
1069 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sEquations );
1070 if ( !pAny && pDefCustomShape && pDefCustomShape->nCalculation && pDefCustomShape->pCalculation )
1071 {
1072 com::sun::star::uno::Sequence< OUString > seqEquations;
1073
1074 sal_Int32 i, nCount = pDefCustomShape->nCalculation;
1075 seqEquations.realloc( nCount );
1076 const SvxMSDffCalculationData* pData = pDefCustomShape->pCalculation;
1077 for ( i = 0; i < nCount; i++, pData++ )
1078 seqEquations[ i ] = EnhancedCustomShape2d::GetEquation( pData->nFlags, pData->nVal[ 0 ], pData->nVal[ 1 ], pData->nVal[ 2 ] );
1079 aPropVal.Name = sEquations;
1080 aPropVal.Value <<= seqEquations;
1081 aGeometryItem.SetPropertyValue( aPropVal );
1082 }
1083
1084 // Handles //
1085 const OUString sHandles( "Handles" );
1086 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sHandles );
1087 if ( !pAny && pDefCustomShape && pDefCustomShape->nHandles && pDefCustomShape->pHandles )
1088 {
1089 com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValues > seqHandles;
1090
1091 sal_Int32 i, nCount = pDefCustomShape->nHandles;
1092 const SvxMSDffHandle* pData = pDefCustomShape->pHandles;
1093 seqHandles.realloc( nCount );
1094 for ( i = 0; i < nCount; i++, pData++ )
1095 {
1096 sal_Int32 nPropertiesNeeded;
1097 com::sun::star::beans::PropertyValues& rPropValues = seqHandles[ i ];
1098 nPropertiesNeeded = GetNumberOfProperties( pData );
1099 rPropValues.realloc( nPropertiesNeeded );
1100 lcl_ShapePropertiesFromDFF( pData, rPropValues );
1101 }
1102 aPropVal.Name = sHandles;
1103 aPropVal.Value <<= seqHandles;
1104 aGeometryItem.SetPropertyValue( aPropVal );
1105 }
1106 SetMergedItem( aGeometryItem );
1107 }
1108
1109 sal_Bool SdrObjCustomShape::IsDefaultGeometry( const DefaultType eDefaultType ) const
1110 {
1111 sal_Bool bIsDefaultGeometry = sal_False;
1112
1113 PropertyValue aPropVal;
1114 OUString sShapeType;
1115 const OUString sType( "Type" );
1116 SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
1117
1118 Any *pAny = aGeometryItem.GetPropertyValueByName( sType );
1119 if ( pAny )
1120 *pAny >>= sShapeType;
1121
1122 MSO_SPT eSpType = EnhancedCustomShapeTypeNames::Get( sShapeType );
1123
1124 const mso_CustomShape* pDefCustomShape = GetCustomShapeContent( eSpType );
1125 const OUString sPath( "Path" );
1126 switch( eDefaultType )
1127 {
1128 case DEFAULT_VIEWBOX :
1129 {
1130 const OUString sViewBox( "ViewBox" );
1131 const Any* pViewBox = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sViewBox );
1132 com::sun::star::awt::Rectangle aViewBox;
1133 if ( pViewBox && ( *pViewBox >>= aViewBox ) )
1134 {
1135 if ( ( aViewBox.Width == pDefCustomShape->nCoordWidth )
1136 && ( aViewBox.Height == pDefCustomShape->nCoordHeight ) )
1137 bIsDefaultGeometry = sal_True;
1138 }
1139 }
1140 break;
1141
1142 case DEFAULT_PATH :
1143 {
1144 const OUString sCoordinates( "Coordinates" );
1145 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sCoordinates );
1146 if ( pAny && pDefCustomShape && pDefCustomShape->nVertices && pDefCustomShape->pVertices )
1147 {
1148 com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> seqCoordinates1, seqCoordinates2;
1149 if ( *pAny >>= seqCoordinates1 )
1150 {
1151 sal_Int32 i, nCount = pDefCustomShape->nVertices;
1152 seqCoordinates2.realloc( nCount );
1153 for ( i = 0; i < nCount; i++ )
1154 {
1155 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqCoordinates2[ i ].First, pDefCustomShape->pVertices[ i ].nValA );
1156 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqCoordinates2[ i ].Second, pDefCustomShape->pVertices[ i ].nValB );
1157 }
1158 if ( seqCoordinates1 == seqCoordinates2 )
1159 bIsDefaultGeometry = sal_True;
1160 }
1161 }
1162 else if ( pDefCustomShape && ( ( pDefCustomShape->nVertices == 0 ) || ( pDefCustomShape->pVertices == 0 ) ) )
1163 bIsDefaultGeometry = sal_True;
1164 }
1165 break;
1166
1167 case DEFAULT_GLUEPOINTS :
1168 {
1169 const OUString sGluePoints( "GluePoints" );
1170 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sGluePoints );
1171 if ( pAny && pDefCustomShape && pDefCustomShape->nGluePoints && pDefCustomShape->pGluePoints )
1172 {
1173 com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> seqGluePoints1, seqGluePoints2;
1174 if ( *pAny >>= seqGluePoints1 )
1175 {
1176 sal_Int32 i, nCount = pDefCustomShape->nGluePoints;
1177 seqGluePoints2.realloc( nCount );
1178 for ( i = 0; i < nCount; i++ )
1179 {
1180 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqGluePoints2[ i ].First, pDefCustomShape->pGluePoints[ i ].nValA );
1181 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqGluePoints2[ i ].Second, pDefCustomShape->pGluePoints[ i ].nValB );
1182 }
1183 if ( seqGluePoints1 == seqGluePoints2 )
1184 bIsDefaultGeometry = sal_True;
1185 }
1186 }
1187 else if ( pDefCustomShape && ( pDefCustomShape->nGluePoints == 0 ) )
1188 bIsDefaultGeometry = sal_True;
1189 }
1190 break;
1191
1192 case DEFAULT_SEGMENTS :
1193 {
1194 // Path/Segments //
1195 const OUString sSegments( "Segments" );
1196 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sSegments );
1197 if ( pAny )
1198 {
1199 com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > seqSegments1, seqSegments2;
1200 if ( *pAny >>= seqSegments1 )
1201 {
1202 if ( pDefCustomShape && pDefCustomShape->nElements && pDefCustomShape->pElements )
1203 {
1204 sal_Int32 i, nCount = pDefCustomShape->nElements;
1205 if ( nCount )
1206 {
1207 seqSegments2.realloc( nCount );
1208 for ( i = 0; i < nCount; i++ )
1209 {
1210 EnhancedCustomShapeSegment& rSegInfo = seqSegments2[ i ];
1211 sal_uInt16 nSDat = pDefCustomShape->pElements[ i ];
1212 lcl_ShapeSegmentFromBinary( rSegInfo, nSDat );
1213 }
1214 if ( seqSegments1 == seqSegments2 )
1215 bIsDefaultGeometry = sal_True;
1216 }
1217 }
1218 else
1219 {
1220 // check if its the default segment description ( M L Z N )
1221 if ( seqSegments1.getLength() == 4 )
1222 {
1223 if ( ( seqSegments1[ 0 ].Command == EnhancedCustomShapeSegmentCommand::MOVETO )
1224 && ( seqSegments1[ 1 ].Command == EnhancedCustomShapeSegmentCommand::LINETO )
1225 && ( seqSegments1[ 2 ].Command == EnhancedCustomShapeSegmentCommand::CLOSESUBPATH )
1226 && ( seqSegments1[ 3 ].Command == EnhancedCustomShapeSegmentCommand::ENDSUBPATH ) )
1227 bIsDefaultGeometry = sal_True;
1228 }
1229 }
1230 }
1231 }
1232 else if ( pDefCustomShape && ( ( pDefCustomShape->nElements == 0 ) || ( pDefCustomShape->pElements == 0 ) ) )
1233 bIsDefaultGeometry = sal_True;
1234 }
1235 break;
1236
1237 case DEFAULT_STRETCHX :
1238 {
1239 const OUString sStretchX( "StretchX" );
1240 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sStretchX );
1241 if ( pAny && pDefCustomShape )
1242 {
1243 sal_Int32 nStretchX = 0;
1244 if ( *pAny >>= nStretchX )
1245 {
1246 if ( pDefCustomShape->nXRef == nStretchX )
1247 bIsDefaultGeometry = sal_True;
1248 }
1249 }
1250 else if ( pDefCustomShape && ( pDefCustomShape->nXRef == DEFAULT_MINIMUM_SIGNED_COMPARE ) )
1251 bIsDefaultGeometry = sal_True;
1252 }
1253 break;
1254
1255 case DEFAULT_STRETCHY :
1256 {
1257 const OUString sStretchY( "StretchY" );
1258 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sStretchY );
1259 if ( pAny && pDefCustomShape )
1260 {
1261 sal_Int32 nStretchY = 0;
1262 if ( *pAny >>= nStretchY )
1263 {
1264 if ( pDefCustomShape->nYRef == nStretchY )
1265 bIsDefaultGeometry = sal_True;
1266 }
1267 }
1268 else if ( pDefCustomShape && ( pDefCustomShape->nYRef == DEFAULT_MINIMUM_SIGNED_COMPARE ) )
1269 bIsDefaultGeometry = sal_True;
1270 }
1271 break;
1272
1273 case DEFAULT_EQUATIONS :
1274 {
1275 const OUString sEquations( "Equations" );
1276 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sEquations );
1277 if ( pAny && pDefCustomShape && pDefCustomShape->nCalculation && pDefCustomShape->pCalculation )
1278 {
1279 com::sun::star::uno::Sequence< OUString > seqEquations1, seqEquations2;
1280 if ( *pAny >>= seqEquations1 )
1281 {
1282 sal_Int32 i, nCount = pDefCustomShape->nCalculation;
1283 seqEquations2.realloc( nCount );
1284
1285 const SvxMSDffCalculationData* pData = pDefCustomShape->pCalculation;
1286 for ( i = 0; i < nCount; i++, pData++ )
1287 seqEquations2[ i ] = EnhancedCustomShape2d::GetEquation( pData->nFlags, pData->nVal[ 0 ], pData->nVal[ 1 ], pData->nVal[ 2 ] );
1288
1289 if ( seqEquations1 == seqEquations2 )
1290 bIsDefaultGeometry = sal_True;
1291 }
1292 }
1293 else if ( pDefCustomShape && ( ( pDefCustomShape->nCalculation == 0 ) || ( pDefCustomShape->pCalculation == 0 ) ) )
1294 bIsDefaultGeometry = sal_True;
1295 }
1296 break;
1297
1298 case DEFAULT_TEXTFRAMES :
1299 {
1300 const OUString sTextFrames( "TextFrames" );
1301 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sTextFrames );
1302 if ( pAny && pDefCustomShape && pDefCustomShape->nTextRect && pDefCustomShape->pTextRect )
1303 {
1304 com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > seqTextFrames1, seqTextFrames2;
1305 if ( *pAny >>= seqTextFrames1 )
1306 {
1307 sal_Int32 i, nCount = pDefCustomShape->nTextRect;
1308 seqTextFrames2.realloc( nCount );
1309 const SvxMSDffTextRectangles* pRectangles = pDefCustomShape->pTextRect;
1310 for ( i = 0; i < nCount; i++, pRectangles++ )
1311 {
1312 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames2[ i ].TopLeft.First, pRectangles->nPairA.nValA );
1313 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames2[ i ].TopLeft.Second, pRectangles->nPairA.nValB );
1314 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames2[ i ].BottomRight.First, pRectangles->nPairB.nValA );
1315 EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames2[ i ].BottomRight.Second, pRectangles->nPairB.nValB );
1316 }
1317 if ( seqTextFrames1 == seqTextFrames2 )
1318 bIsDefaultGeometry = sal_True;
1319 }
1320 }
1321 else if ( pDefCustomShape && ( ( pDefCustomShape->nTextRect == 0 ) || ( pDefCustomShape->pTextRect == 0 ) ) )
1322 bIsDefaultGeometry = sal_True;
1323 }
1324 break;
1325
1326 case DEFAULT_HANDLES :
1327 {
1328 const OUString sHandles( "Handles" );
1329 pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sHandles );
1330 if ( pAny && pDefCustomShape && pDefCustomShape->nHandles && pDefCustomShape->pHandles )
1331 {
1332 com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValues > seqHandles1, seqHandles2;
1333 if ( *pAny >>= seqHandles1 )
1334 {
1335 sal_Int32 i, nCount = pDefCustomShape->nHandles;
1336 const SvxMSDffHandle* pData = pDefCustomShape->pHandles;
1337 seqHandles2.realloc( nCount );
1338 for ( i = 0; i < nCount; i++, pData++ )
1339 {
1340 sal_Int32 nPropertiesNeeded;
1341 com::sun::star::beans::PropertyValues& rPropValues = seqHandles2[ i ];
1342 nPropertiesNeeded = GetNumberOfProperties( pData );
1343 rPropValues.realloc( nPropertiesNeeded );
1344 lcl_ShapePropertiesFromDFF( pData, rPropValues );
1345 }
1346 if ( seqHandles1 == seqHandles2 )
1347 bIsDefaultGeometry = sal_True;
1348 }
1349 }
1350 else if ( pDefCustomShape && ( ( pDefCustomShape->nHandles == 0 ) || ( pDefCustomShape->pHandles == 0 ) ) )
1351 bIsDefaultGeometry = sal_True;
1352 }
1353 break;
1354 }
1355 return bIsDefaultGeometry;
1356 }
1357
1358 void SdrObjCustomShape::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
1359 {
1360 rInfo.bResizeFreeAllowed=fObjectRotation == 0.0;
1361 rInfo.bResizePropAllowed=sal_True;
1362 rInfo.bRotateFreeAllowed=sal_True;
1363 rInfo.bRotate90Allowed =sal_True;
1364 rInfo.bMirrorFreeAllowed=sal_True;
1365 rInfo.bMirror45Allowed =sal_True;
1366 rInfo.bMirror90Allowed =sal_True;
1367 rInfo.bTransparenceAllowed = sal_False;
1368 rInfo.bGradientAllowed = sal_False;
1369 rInfo.bShearAllowed =sal_True;
1370 rInfo.bEdgeRadiusAllowed=sal_False;
1371 rInfo.bNoContortion =sal_True;
1372
1373 // #i37011#
1374 if ( mXRenderedCustomShape.is() )
1375 {
1376 const SdrObject* pRenderedCustomShape = GetSdrObjectFromXShape( mXRenderedCustomShape );
1377 if ( pRenderedCustomShape )
1378 {
1379 // #i37262#
1380 // Iterate self over the contained objects, since there are combinations of
1381 // polygon and curve objects. In that case, aInfo.bCanConvToPath and
1382 // aInfo.bCanConvToPoly would be false. What is needed here is an or, not an and.
1383 SdrObjListIter aIterator(*pRenderedCustomShape);
1384 while(aIterator.IsMore())
1385 {
1386 SdrObject* pCandidate = aIterator.Next();
1387 SdrObjTransformInfoRec aInfo;
1388 pCandidate->TakeObjInfo(aInfo);
1389
1390 // set path and poly conversion if one is possible since
1391 // this object will first be broken
1392 const bool bCanConvToPathOrPoly(aInfo.bCanConvToPath || aInfo.bCanConvToPoly);
1393 if(rInfo.bCanConvToPath != bCanConvToPathOrPoly)
1394 {
1395 rInfo.bCanConvToPath = bCanConvToPathOrPoly;
1396 }
1397
1398 if(rInfo.bCanConvToPoly != bCanConvToPathOrPoly)
1399 {
1400 rInfo.bCanConvToPoly = bCanConvToPathOrPoly;
1401 }
1402
1403 if(rInfo.bCanConvToContour != aInfo.bCanConvToContour)
1404 {
1405 rInfo.bCanConvToContour = aInfo.bCanConvToContour;
1406 }
1407
1408 if(rInfo.bShearAllowed != aInfo.bShearAllowed)
1409 {
1410 rInfo.bShearAllowed = aInfo.bShearAllowed;
1411 }
1412 }
1413 }
1414 }
1415 }
1416
1417 void SdrObjCustomShape::SetModel(SdrModel* pNewModel)
1418 {
1419 SdrTextObj::SetModel(pNewModel);
1420 mXRenderedCustomShape.clear();
1421 }
1422
1423 sal_uInt16 SdrObjCustomShape::GetObjIdentifier() const
1424 {
1425 return sal_uInt16(OBJ_CUSTOMSHAPE);
1426 }
1427
1428 ////////////////////////////////////////////////////////////////////////////////////////////////////
1429
1430 void SdrObjCustomShape::RecalcSnapRect()
1431 {
1432 SdrTextObj::RecalcSnapRect();
1433 }
1434 const Rectangle& SdrObjCustomShape::GetSnapRect() const
1435 {
1436 return SdrTextObj::GetSnapRect();
1437 }
1438 const Rectangle& SdrObjCustomShape::GetCurrentBoundRect() const
1439 {
1440 return SdrTextObj::GetCurrentBoundRect();
1441 }
1442 const Rectangle& SdrObjCustomShape::GetLogicRect() const
1443 {
1444 return SdrTextObj::GetLogicRect();
1445 }
1446 void SdrObjCustomShape::NbcSetSnapRect( const Rectangle& rRect )
1447 {
1448 aRect=rRect;
1449 ImpJustifyRect(aRect);
1450 InvalidateRenderGeometry();
1451 Rectangle aTextBound( aRect );
1452 if ( GetTextBounds( aTextBound ) )
1453 {
1454 if ( pModel==NULL || !pModel->IsPasteResize() )
1455 {
1456 long nHDist=GetTextLeftDistance()+GetTextRightDistance();
1457 long nVDist=GetTextUpperDistance()+GetTextLowerDistance();
1458 long nTWdt=aTextBound.GetWidth ()-1-nHDist; if (nTWdt<0) nTWdt=0;
1459 long nTHgt=aTextBound.GetHeight()-1-nVDist; if (nTHgt<0) nTHgt=0;
1460 if ( IsAutoGrowWidth() )
1461 NbcSetMinTextFrameWidth( nTWdt );
1462 if ( IsAutoGrowHeight() )
1463 NbcSetMinTextFrameHeight( nTHgt );
1464 NbcAdjustTextFrameWidthAndHeight();
1465 }
1466 }
1467 ImpCheckShear();
1468 SetRectsDirty();
1469 SetChanged();
1470 }
1471 void SdrObjCustomShape::SetSnapRect( const Rectangle& rRect )
1472 {
1473 Rectangle aBoundRect0;
1474 if ( pUserCall )
1475 aBoundRect0 = GetLastBoundRect();
1476 NbcSetSnapRect( rRect );
1477 BroadcastObjectChange();
1478 SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1479 }
1480 void SdrObjCustomShape::NbcSetLogicRect( const Rectangle& rRect )
1481 {
1482 aRect = rRect;
1483 ImpJustifyRect( aRect );
1484 InvalidateRenderGeometry();
1485 Rectangle aTextBound( aRect );
1486 if ( GetTextBounds( aTextBound ) )
1487 {
1488 long nHDist=GetTextLeftDistance()+GetTextRightDistance();
1489 long nVDist=GetTextUpperDistance()+GetTextLowerDistance();
1490
1491 long nTWdt=aTextBound.GetWidth()-1-nHDist; if (nTWdt<0) nTWdt=0;
1492 long nTHgt=aTextBound.GetHeight()-1-nVDist; if (nTHgt<0) nTHgt=0;
1493 if ( IsAutoGrowWidth() )
1494 NbcSetMinTextFrameWidth( nTWdt );
1495 if ( IsAutoGrowHeight() )
1496 NbcSetMinTextFrameHeight( nTHgt );
1497 NbcAdjustTextFrameWidthAndHeight();
1498 }
1499 SetRectsDirty();
1500 SetChanged();
1501 }
1502 void SdrObjCustomShape::SetLogicRect( const Rectangle& rRect )
1503 {
1504 Rectangle aBoundRect0;
1505 if ( pUserCall )
1506 aBoundRect0 = GetLastBoundRect();
1507 NbcSetLogicRect(rRect);
1508 BroadcastObjectChange();
1509 SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1510 }
1511 void SdrObjCustomShape::Move( const Size& rSiz )
1512 {
1513 if ( rSiz.Width() || rSiz.Height() )
1514 {
1515 Rectangle aBoundRect0;
1516 if ( pUserCall )
1517 aBoundRect0 = GetLastBoundRect();
1518 NbcMove(rSiz);
1519 SetChanged();
1520 BroadcastObjectChange();
1521 SendUserCall(SDRUSERCALL_MOVEONLY,aBoundRect0);
1522 }
1523 }
1524 void SdrObjCustomShape::NbcMove( const Size& rSiz )
1525 {
1526 SdrTextObj::NbcMove( rSiz );
1527 if ( mXRenderedCustomShape.is() )
1528 {
1529 SdrObject* pRenderedCustomShape = GetSdrObjectFromXShape( mXRenderedCustomShape );
1530 if ( pRenderedCustomShape )
1531 {
1532 // #i97149# the visualisation shape needs to be informed
1533 // about change, too
1534 pRenderedCustomShape->ActionChanged();
1535 pRenderedCustomShape->NbcMove( rSiz );
1536 }
1537 }
1538
1539 // #i37011# adapt geometry shadow
1540 if(mpLastShadowGeometry)
1541 {
1542 mpLastShadowGeometry->NbcMove( rSiz );
1543 }
1544 }
1545 void SdrObjCustomShape::Resize( const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bUnsetRelative )
1546 {
1547 SdrTextObj::Resize( rRef, xFact, yFact, bUnsetRelative );
1548 }
1549
1550 void SdrObjCustomShape::NbcResize( const Point& rRef, const Fraction& rxFact, const Fraction& ryFact )
1551 {
1552 Fraction xFact( rxFact );
1553 Fraction yFact( ryFact );
1554
1555 // taking care of handles that should not been changed
1556 Rectangle aOld( aRect );
1557 std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );
1558
1559 SdrTextObj::NbcResize( rRef, xFact, yFact );
1560
1561 if ( ( xFact.GetNumerator() != xFact.GetDenominator() )
1562 || ( yFact.GetNumerator()!= yFact.GetDenominator() ) )
1563 {
1564 if ( ( ( xFact.GetNumerator() < 0 ) && ( xFact.GetDenominator() > 0 ) ) ||
1565 ( ( xFact.GetNumerator() > 0 ) && ( xFact.GetDenominator() < 0 ) ) )
1566 {
1567 SetMirroredX( IsMirroredX() == sal_False );
1568 }
1569 if ( ( ( yFact.GetNumerator() < 0 ) && ( yFact.GetDenominator() > 0 ) ) ||
1570 ( ( yFact.GetNumerator() > 0 ) && ( yFact.GetDenominator() < 0 ) ) )
1571 {
1572 SetMirroredY( IsMirroredY() == sal_False );
1573 }
1574 }
1575
1576 for (std::vector< SdrCustomShapeInteraction >::const_iterator aIter( aInteractionHandles.begin() ), aEnd( aInteractionHandles.end() );
1577 aIter != aEnd; ++aIter )
1578 {
1579 try
1580 {
1581 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
1582 aIter->xInteraction->setControllerPosition( aIter->aPosition );
1583 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X )
1584 {
1585 sal_Int32 nX = ( aIter->aPosition.X - aOld.Left() ) + aRect.Left();
1586 aIter->xInteraction->setControllerPosition( com::sun::star::awt::Point( nX, aIter->xInteraction->getPosition().Y ) );
1587 }
1588 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y )
1589 {
1590 sal_Int32 nY = ( aIter->aPosition.Y - aOld.Top() ) + aRect.Top();
1591 aIter->xInteraction->setControllerPosition( com::sun::star::awt::Point( aIter->xInteraction->getPosition().X, nY ) );
1592 }
1593 }
1594 catch ( const uno::RuntimeException& )
1595 {
1596 }
1597 }
1598 InvalidateRenderGeometry();
1599 }
1600 void SdrObjCustomShape::NbcRotate( const Point& rRef, long nWink, double sn, double cs )
1601 {
1602 sal_Bool bMirroredX = IsMirroredX();
1603 sal_Bool bMirroredY = IsMirroredY();
1604
1605 fObjectRotation = fmod( fObjectRotation, 360.0 );
1606 if ( fObjectRotation < 0 )
1607 fObjectRotation = 360 + fObjectRotation;
1608
1609 // the rotation angle for ashapes is stored in fObjectRotation, this rotation
1610 // has to be applied to the text object (which is internally using aGeo.nWink).
1611 SdrTextObj::NbcRotate( aRect.TopLeft(), -aGeo.nDrehWink, // retrieving the unrotated text object
1612 sin( (-aGeo.nDrehWink) * F_PI18000 ),
1613 cos( (-aGeo.nDrehWink) * F_PI18000 ) );
1614 aGeo.nDrehWink = 0; // resetting aGeo data
1615 aGeo.RecalcSinCos();
1616
1617 long nW = (long)( fObjectRotation * 100 ); // applying our object rotation
1618 if ( bMirroredX )
1619 nW = 36000 - nW;
1620 if ( bMirroredY )
1621 nW = 18000 - nW;
1622 nW = nW % 36000;
1623 if ( nW < 0 )
1624 nW = 36000 + nW;
1625 SdrTextObj::NbcRotate( aRect.TopLeft(), nW, // applying text rotation
1626 sin( nW * F_PI18000 ),
1627 cos( nW * F_PI18000 ) );
1628
1629 int nSwap = 0;
1630 if ( bMirroredX )
1631 nSwap ^= 1;
1632 if ( bMirroredY )
1633 nSwap ^= 1;
1634
1635 double fWink = nWink; // updating to our new object rotation
1636 fWink /= 100.0;
1637 fObjectRotation = fmod( nSwap ? fObjectRotation - fWink : fObjectRotation + fWink, 360.0 );
1638 if ( fObjectRotation < 0 )
1639 fObjectRotation = 360 + fObjectRotation;
1640
1641 SdrTextObj::NbcRotate( rRef, nWink, sn, cs ); // applying text rotation
1642 InvalidateRenderGeometry();
1643 }
1644
1645 void SdrObjCustomShape::NbcMirror( const Point& rRef1, const Point& rRef2 )
1646 {
1647 // storing horizontal and vertical flipping without modifying the rotate angle
1648 sal_Bool bHorz = sal_False;
1649 sal_Bool bVert = sal_False;
1650 if ( rRef1.X() == rRef2.X() )
1651 bHorz = sal_True;
1652 if ( rRef1.Y() == rRef2.Y() )
1653 bVert = sal_True;
1654 if ( !bHorz && !bVert )
1655 bHorz = bVert = sal_True;
1656
1657 if ( bHorz || bVert )
1658 {
1659 SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
1660
1661 // "MirroredX" //
1662 if ( bHorz )
1663 {
1664 const OUString sMirroredX( "MirroredX" );
1665 com::sun::star::uno::Any* pAny = aGeometryItem.GetPropertyValueByName( sMirroredX );
1666 if ( pAny )
1667 {
1668 sal_Bool bFlip = sal_Bool();
1669 if ( *pAny >>= bFlip )
1670 {
1671 if ( bFlip )
1672 bHorz = sal_False;
1673 }
1674 }
1675 PropertyValue aPropVal;
1676 aPropVal.Name = sMirroredX;
1677 aPropVal.Value <<= bHorz;
1678 aGeometryItem.SetPropertyValue( aPropVal );
1679 }
1680
1681 // "MirroredY" //
1682 if ( bVert )
1683 {
1684 const OUString sMirroredY( "MirroredY" );
1685 com::sun::star::uno::Any* pAny = aGeometryItem.GetPropertyValueByName( sMirroredY );
1686 if ( pAny )
1687 {
1688 sal_Bool bFlip = sal_Bool();
1689 if ( *pAny >>= bFlip )
1690 {
1691 if ( bFlip )
1692 bVert = sal_False;
1693 }
1694 }
1695 PropertyValue aPropVal;
1696 aPropVal.Name = sMirroredY;
1697 aPropVal.Value <<= bVert;
1698 aGeometryItem.SetPropertyValue( aPropVal );
1699 }
1700 SetMergedItem( aGeometryItem );
1701 }
1702 SdrTextObj::NbcMirror( rRef1, rRef2 );
1703 InvalidateRenderGeometry();
1704 }
1705
1706 void SdrObjCustomShape::Shear( const Point& rRef, long nWink, double tn, bool bVShear )
1707 {
1708 SdrTextObj::Shear( rRef, nWink, tn, bVShear );
1709 InvalidateRenderGeometry();
1710 }
1711 void SdrObjCustomShape::NbcShear( const Point& rRef, long nWink, double tn, bool bVShear )
1712 {
1713 long nDrehWink = aGeo.nDrehWink;
1714 if ( nDrehWink )
1715 {
1716 aGeo.nDrehWink = -nDrehWink;
1717 aGeo.RecalcSinCos();
1718 NbcRotate( rRef, aGeo.nDrehWink, aGeo.nSin, aGeo.nCos );
1719 }
1720 SdrTextObj::NbcShear(rRef,nWink,tn,bVShear);
1721 if ( nDrehWink )
1722 {
1723 aGeo.nDrehWink = nDrehWink;
1724 aGeo.RecalcSinCos();
1725 Rotate( rRef, aGeo.nDrehWink, aGeo.nSin, aGeo.nCos );
1726 }
1727 InvalidateRenderGeometry();
1728 }
1729
1730 ////////////////////////////////////////////////////////////////////////////////////////////////////
1731
1732 SdrGluePoint SdrObjCustomShape::GetVertexGluePoint(sal_uInt16 nPosNum) const
1733 {
1734 sal_Int32 nWdt = ImpGetLineWdt(); // #i25616#
1735
1736 // #i25616#
1737 if(!LineIsOutsideGeometry())
1738 {
1739 nWdt++;
1740 nWdt /= 2;
1741 }
1742
1743 Point aPt;
1744 switch (nPosNum) {
1745 case 0: aPt=aRect.TopCenter(); aPt.Y()-=nWdt; break;
1746 case 1: aPt=aRect.RightCenter(); aPt.X()+=nWdt; break;
1747 case 2: aPt=aRect.BottomCenter(); aPt.Y()+=nWdt; break;
1748 case 3: aPt=aRect.LeftCenter(); aPt.X()-=nWdt; break;
1749 }
1750 if (aGeo.nShearWink!=0) ShearPoint(aPt,aRect.TopLeft(),aGeo.nTan);
1751 if (aGeo.nDrehWink!=0) RotatePoint(aPt,aRect.TopLeft(),aGeo.nSin,aGeo.nCos);
1752 aPt-=GetSnapRect().Center();
1753 SdrGluePoint aGP(aPt);
1754 aGP.SetPercent(sal_False);
1755 return aGP;
1756 }
1757
1758 ////////////////////////////////////////////////////////////////////////////////////////////////////
1759
1760 // #i38892#
1761 void SdrObjCustomShape::ImpCheckCustomGluePointsAreAdded()
1762 {
1763 const SdrObject* pSdrObject = GetSdrObjectFromCustomShape();
1764
1765 if(pSdrObject)
1766 {
1767 const SdrGluePointList* pSource = pSdrObject->GetGluePointList();
1768
1769 if(pSource && pSource->GetCount())
1770 {
1771 if(!SdrTextObj::GetGluePointList())
1772 {
1773 SdrTextObj::ForceGluePointList();
1774 }
1775
1776 const SdrGluePointList* pList = SdrTextObj::GetGluePointList();
1777
1778 if(pList)
1779 {
1780 SdrGluePointList aNewList;
1781 sal_uInt16 a;
1782
1783 for(a = 0; a < pSource->GetCount(); a++)
1784 {
1785 SdrGluePoint aCopy((*pSource)[a]);
1786 aCopy.SetUserDefined(sal_False);
1787 aNewList.Insert(aCopy);
1788 }
1789
1790 sal_Bool bMirroredX = IsMirroredX();
1791 sal_Bool bMirroredY = IsMirroredY();
1792
1793 long nShearWink = aGeo.nShearWink;
1794 double fTan = aGeo.nTan;
1795
1796 if ( aGeo.nDrehWink || nShearWink || bMirroredX || bMirroredY )
1797 {
1798 Polygon aPoly( aRect );
1799 if( nShearWink )
1800 {
1801 sal_uInt16 nPointCount=aPoly.GetSize();
1802 for (sal_uInt16 i=0; i<nPointCount; i++)
1803 ShearPoint(aPoly[i],aRect.Center(), fTan, sal_False );
1804 }
1805 if ( aGeo.nDrehWink )
1806 aPoly.Rotate( aRect.Center(), aGeo.nDrehWink / 10 );
1807
1808 Rectangle aBoundRect( aPoly.GetBoundRect() );
1809 sal_Int32 nXDiff = aBoundRect.Left() - aRect.Left();
1810 sal_Int32 nYDiff = aBoundRect.Top() - aRect.Top();
1811
1812 if (nShearWink&&((bMirroredX&&!bMirroredY)||(bMirroredY&&!bMirroredX)))
1813 {
1814 nShearWink = -nShearWink;
1815 fTan = -fTan;
1816 }
1817
1818 Point aRef( aRect.GetWidth() / 2, aRect.GetHeight() / 2 );
1819 for ( a = 0; a < aNewList.GetCount(); a++ )
1820 {
1821 SdrGluePoint& rPoint = aNewList[ a ];
1822 Point aGlue( rPoint.GetPos() );
1823 if ( nShearWink )
1824 ShearPoint( aGlue, aRef, fTan );
1825
1826 RotatePoint( aGlue, aRef, sin( fObjectRotation * F_PI180 ), cos( fObjectRotation * F_PI180 ) );
1827 if ( bMirroredX )
1828 aGlue.X() = aRect.GetWidth() - aGlue.X();
1829 if ( bMirroredY )
1830 aGlue.Y() = aRect.GetHeight() - aGlue.Y();
1831 aGlue.X() -= nXDiff;
1832 aGlue.Y() -= nYDiff;
1833 rPoint.SetPos( aGlue );
1834 }
1835 }
1836
1837 for(a = 0; a < pList->GetCount(); a++)
1838 {
1839 const SdrGluePoint& rCandidate = (*pList)[a];
1840
1841 if(rCandidate.IsUserDefined())
1842 {
1843 aNewList.Insert(rCandidate);
1844 }
1845 }
1846
1847 // copy new list to local. This is NOT very convenient behavior, the local
1848 // GluePointList should not be set, but we delivered by using GetGluePointList(),
1849 // maybe on demand. Since the local object is changed here, this is assumed to
1850 // be a result of GetGluePointList and thus the list is copied
1851 if(pPlusData)
1852 {
1853 pPlusData->SetGluePoints(aNewList);
1854 }
1855 }
1856 }
1857 }
1858 }
1859
1860 // #i38892#
1861 const SdrGluePointList* SdrObjCustomShape::GetGluePointList() const
1862 {
1863 ((SdrObjCustomShape*)this)->ImpCheckCustomGluePointsAreAdded();
1864 return SdrTextObj::GetGluePointList();
1865 }
1866
1867 // #i38892#
1868 SdrGluePointList* SdrObjCustomShape::ForceGluePointList()
1869 {
1870 if(SdrTextObj::ForceGluePointList())
1871 {
1872 ImpCheckCustomGluePointsAreAdded();
1873 return SdrTextObj::ForceGluePointList();
1874 }
1875 else
1876 {
1877 return 0L;
1878 }
1879 }
1880
1881 ////////////////////////////////////////////////////////////////////////////////////////////////////
1882
1883 sal_uInt32 SdrObjCustomShape::GetHdlCount() const
1884 {
1885 const sal_uInt32 nBasicHdlCount(SdrTextObj::GetHdlCount());
1886 std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );
1887 return ( aInteractionHandles.size() + nBasicHdlCount );
1888 }
1889
1890 SdrHdl* SdrObjCustomShape::GetHdl( sal_uInt32 nHdlNum ) const
1891 {
1892 SdrHdl* pH = NULL;
1893 const sal_uInt32 nBasicHdlCount(SdrTextObj::GetHdlCount());
1894
1895 if ( nHdlNum < nBasicHdlCount )
1896 pH = SdrTextObj::GetHdl( nHdlNum );
1897 else
1898 {
1899 std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );
1900 const sal_uInt32 nCustomShapeHdlNum(nHdlNum - nBasicHdlCount);
1901
1902 if ( nCustomShapeHdlNum < aInteractionHandles.size() )
1903 {
1904 if ( aInteractionHandles[ nCustomShapeHdlNum ].xInteraction.is() )
1905 {
1906 try
1907 {
1908 com::sun::star::awt::Point aPosition( aInteractionHandles[ nCustomShapeHdlNum ].xInteraction->getPosition() );
1909 pH = new SdrHdl( Point( aPosition.X, aPosition.Y ), HDL_CUSTOMSHAPE1 );
1910 pH->SetPointNum( nCustomShapeHdlNum );
1911 pH->SetObj( (SdrObject*)this );
1912 }
1913 catch ( const uno::RuntimeException& )
1914 {
1915 }
1916 }
1917 }
1918 }
1919 return pH;
1920 }
1921
1922 ////////////////////////////////////////////////////////////////////////////////////////////////////
1923
1924 bool SdrObjCustomShape::hasSpecialDrag() const
1925 {
1926 return true;
1927 }
1928
1929 bool SdrObjCustomShape::beginSpecialDrag(SdrDragStat& rDrag) const
1930 {
1931 const SdrHdl* pHdl = rDrag.GetHdl();
1932
1933 if(pHdl && HDL_CUSTOMSHAPE1 == pHdl->GetKind())
1934 {
1935 rDrag.SetEndDragChangesAttributes(true);
1936 rDrag.SetNoSnap(true);
1937 }
1938 else
1939 {
1940 const SdrHdl* pHdl2 = rDrag.GetHdl();
1941 const SdrHdlKind eHdl((pHdl2 == NULL) ? HDL_MOVE : pHdl2->GetKind());
1942
1943 switch( eHdl )
1944 {
1945 case HDL_UPLFT :
1946 case HDL_UPPER :
1947 case HDL_UPRGT :
1948 case HDL_LEFT :
1949 case HDL_RIGHT :
1950 case HDL_LWLFT :
1951 case HDL_LOWER :
1952 case HDL_LWRGT :
1953 case HDL_MOVE :
1954 {
1955 break;
1956 }
1957 default:
1958 {
1959 return false;
1960 }
1961 }
1962 }
1963
1964 return true;
1965 }
1966
1967 void SdrObjCustomShape::DragResizeCustomShape( const Rectangle& rNewRect, SdrObjCustomShape* pObj ) const
1968 {
1969 Rectangle aOld( pObj->aRect );
1970 sal_Bool bOldMirroredX( pObj->IsMirroredX() );
1971 sal_Bool bOldMirroredY( pObj->IsMirroredY() );
1972
1973 Rectangle aNewRect( rNewRect );
1974 aNewRect.Justify();
1975
1976 std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( pObj ) );
1977
1978 GeoStat aGeoStat( pObj->GetGeoStat() );
1979 if ( aNewRect.TopLeft()!= pObj->aRect.TopLeft() &&
1980 ( pObj->aGeo.nDrehWink || pObj->aGeo.nShearWink ) )
1981 {
1982 Point aNewPos( aNewRect.TopLeft() );
1983 if ( pObj->aGeo.nShearWink ) ShearPoint( aNewPos, aOld.TopLeft(), aGeoStat.nTan );
1984 if ( pObj->aGeo.nDrehWink ) RotatePoint(aNewPos, aOld.TopLeft(), aGeoStat.nSin, aGeoStat.nCos );
1985 aNewRect.SetPos( aNewPos );
1986 }
1987 if ( aNewRect != pObj->aRect )
1988 {
1989 pObj->SetLogicRect( aNewRect );
1990 pObj->InvalidateRenderGeometry();
1991
1992 if ( rNewRect.Left() > rNewRect.Right() )
1993 {
1994 Point aTop( ( pObj->GetSnapRect().Left() + pObj->GetSnapRect().Right() ) >> 1, pObj->GetSnapRect().Top() );
1995 Point aBottom( aTop.X(), aTop.Y() + 1000 );
1996 pObj->NbcMirror( aTop, aBottom );
1997 }
1998 if ( rNewRect.Top() > rNewRect.Bottom() )
1999 {
2000 Point aLeft( pObj->GetSnapRect().Left(), ( pObj->GetSnapRect().Top() + pObj->GetSnapRect().Bottom() ) >> 1 );
2001 Point aRight( aLeft.X() + 1000, aLeft.Y() );
2002 pObj->NbcMirror( aLeft, aRight );
2003 }
2004
2005 for (std::vector< SdrCustomShapeInteraction >::const_iterator aIter( aInteractionHandles.begin() ), aEnd( aInteractionHandles.end() );
2006 aIter != aEnd ; ++aIter )
2007 {
2008 try
2009 {
2010 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
2011 aIter->xInteraction->setControllerPosition( aIter->aPosition );
2012 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X )
2013 {
2014 sal_Int32 nX;
2015 if ( bOldMirroredX )
2016 {
2017 nX = ( aIter->aPosition.X - aOld.Right() );
2018 if ( rNewRect.Left() > rNewRect.Right() )
2019 nX = pObj->aRect.Left() - nX;
2020 else
2021 nX += pObj->aRect.Right();
2022 }
2023 else
2024 {
2025 nX = ( aIter->aPosition.X - aOld.Left() );
2026 if ( rNewRect.Left() > rNewRect.Right() )
2027 nX = pObj->aRect.Right() - nX;
2028 else
2029 nX += pObj->aRect.Left();
2030 }
2031 aIter->xInteraction->setControllerPosition( com::sun::star::awt::Point( nX, aIter->xInteraction->getPosition().Y ) );
2032 }
2033 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y )
2034 {
2035 sal_Int32 nY;
2036 if ( bOldMirroredY )
2037 {
2038 nY = ( aIter->aPosition.Y - aOld.Bottom() );
2039 if ( rNewRect.Top() > rNewRect.Bottom() )
2040 nY = pObj->aRect.Top() - nY;
2041 else
2042 nY += pObj->aRect.Bottom();
2043 }
2044 else
2045 {
2046 nY = ( aIter->aPosition.Y - aOld.Top() );
2047 if ( rNewRect.Top() > rNewRect.Bottom() )
2048 nY = pObj->aRect.Bottom() - nY;
2049 else
2050 nY += pObj->aRect.Top();
2051 }
2052 aIter->xInteraction->setControllerPosition( com::sun::star::awt::Point( aIter->xInteraction->getPosition().X, nY ) );
2053 }
2054 }
2055 catch ( const uno::RuntimeException& )
2056 {
2057 }
2058 }
2059 }
2060 }
2061
2062 void SdrObjCustomShape::DragMoveCustomShapeHdl( const Point aDestination, const sal_uInt16 nCustomShapeHdlNum, SdrObjCustomShape* pObj ) const
2063 {
2064 std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( pObj ) );
2065 if ( nCustomShapeHdlNum < aInteractionHandles.size() )
2066 {
2067 SdrCustomShapeInteraction aInteractionHandle( aInteractionHandles[ nCustomShapeHdlNum ] );
2068 if ( aInteractionHandle.xInteraction.is() )
2069 {
2070 try
2071 {
2072 com::sun::star::awt::Point aPt( aDestination.X(), aDestination.Y() );
2073 if ( aInteractionHandle.nMode & CUSTOMSHAPE_HANDLE_MOVE_SHAPE )
2074 {
2075 sal_Int32 nXDiff = aPt.X - aInteractionHandle.aPosition.X;
2076 sal_Int32 nYDiff = aPt.Y - aInteractionHandle.aPosition.Y;
2077
2078 pObj->aRect.Move( nXDiff, nYDiff );
2079 pObj->aOutRect.Move( nXDiff, nYDiff );
2080 pObj->maSnapRect.Move( nXDiff, nYDiff );
2081 pObj->SetRectsDirty(sal_True);
2082 pObj->InvalidateRenderGeometry();
2083
2084 for (std::vector< SdrCustomShapeInteraction >::const_iterator aIter( aInteractionHandles.begin() ), aEnd( aInteractionHandles.end() ) ;
2085 aIter != aEnd; ++aIter)
2086 {
2087 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
2088 {
2089 if ( aIter->xInteraction.is() )
2090 aIter->xInteraction->setControllerPosition( aIter->aPosition );
2091 }
2092 }
2093 }
2094 aInteractionHandle.xInteraction->setControllerPosition( aPt );
2095 }
2096 catch ( const uno::RuntimeException& )
2097 {
2098 }
2099 }
2100 }
2101 }
2102
2103 bool SdrObjCustomShape::applySpecialDrag(SdrDragStat& rDrag)
2104 {
2105 const SdrHdl* pHdl = rDrag.GetHdl();
2106 const SdrHdlKind eHdl((pHdl == NULL) ? HDL_MOVE : pHdl->GetKind());
2107
2108 switch(eHdl)
2109 {
2110 case HDL_CUSTOMSHAPE1 :
2111 {
2112 rDrag.SetEndDragChangesGeoAndAttributes(true);
2113 DragMoveCustomShapeHdl( rDrag.GetNow(), (sal_uInt16)pHdl->GetPointNum(), this );
2114 SetRectsDirty();
2115 InvalidateRenderGeometry();
2116 SetChanged();
2117 break;
2118 }
2119
2120 case HDL_UPLFT :
2121 case HDL_UPPER :
2122 case HDL_UPRGT :
2123 case HDL_LEFT :
2124 case HDL_RIGHT :
2125 case HDL_LWLFT :
2126 case HDL_LOWER :
2127 case HDL_LWRGT :
2128 {
2129 DragResizeCustomShape(ImpDragCalcRect(rDrag), this);
2130 break;
2131 }
2132 case HDL_MOVE :
2133 {
2134 Move(Size(rDrag.GetDX(), rDrag.GetDY()));
2135 break;
2136 }
2137 default: break;
2138 }
2139
2140 return true;
2141 }
2142
2143 ////////////////////////////////////////////////////////////////////////////////////////////////////
2144
2145 void SdrObjCustomShape::DragCreateObject( SdrDragStat& rStat )
2146 {
2147 Rectangle aRect1;
2148 rStat.TakeCreateRect( aRect1 );
2149
2150 std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );
2151
2152 sal_uInt32 nDefaultObjectSizeWidth = 3000; // default width from SDOptions ?
2153 sal_uInt32 nDefaultObjectSizeHeight= 3000;
2154
2155 if ( ImpVerticalSwitch( *this ) )
2156 {
2157 SetMirroredX( aRect1.Left() > aRect1.Right() );
2158
2159 aRect1 = Rectangle( rStat.GetNow(), Size( nDefaultObjectSizeWidth, nDefaultObjectSizeHeight ) );
2160 // subtracting the horizontal difference of the latest handle from shape position
2161 if ( !aInteractionHandles.empty() )
2162 {
2163 sal_Int32 nHandlePos = aInteractionHandles[ aInteractionHandles.size() - 1 ].xInteraction->getPosition().X;
2164 aRect1.Move( aRect.Left() - nHandlePos, 0 );
2165 }
2166 }
2167 ImpJustifyRect( aRect1 );
2168 rStat.SetActionRect( aRect1 );
2169 aRect = aRect1;
2170 SetRectsDirty();
2171
2172 for (std::vector< SdrCustomShapeInteraction >::const_iterator aIter( aInteractionHandles.begin() ), aEnd( aInteractionHandles.end() );
2173 aIter != aEnd ; ++aIter)
2174 {
2175 try
2176 {
2177 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_CREATE_FIXED )
2178 aIter->xInteraction->setControllerPosition( awt::Point( rStat.GetStart().X(), rStat.GetStart().Y() ) );
2179 }
2180 catch ( const uno::RuntimeException& )
2181 {
2182 }
2183 }
2184
2185 SetBoundRectDirty();
2186 bSnapRectDirty=sal_True;
2187 }
2188
2189 bool SdrObjCustomShape::BegCreate( SdrDragStat& rDrag )
2190 {
2191 return SdrTextObj::BegCreate( rDrag );
2192 }
2193
2194 bool SdrObjCustomShape::MovCreate(SdrDragStat& rStat)
2195 {
2196 SdrView* pView = rStat.GetView(); // #i37448#
2197 if( pView && pView->IsSolidDragging() )
2198 {
2199 InvalidateRenderGeometry();
2200 }
2201 DragCreateObject( rStat );
2202 SetRectsDirty();
2203 return sal_True;
2204 }
2205
2206 bool SdrObjCustomShape::EndCreate( SdrDragStat& rStat, SdrCreateCmd eCmd )
2207 {
2208 DragCreateObject( rStat );
2209
2210 if ( bTextFrame )
2211 {
2212 if ( IsAutoGrowHeight() )
2213 {
2214 // MinTextHeight
2215 long nHgt=aRect.GetHeight()-1;
2216 if (nHgt==1) nHgt=0;
2217 NbcSetMinTextFrameHeight( nHgt );
2218 }
2219 if ( IsAutoGrowWidth() )
2220 {
2221 // MinTextWidth
2222 long nWdt=aRect.GetWidth()-1;
2223 if (nWdt==1) nWdt=0;
2224 NbcSetMinTextFrameWidth( nWdt );
2225 }
2226 // re-calculate text frame
2227 NbcAdjustTextFrameWidthAndHeight();
2228 }
2229 SetRectsDirty();
2230 return ( eCmd == SDRCREATE_FORCEEND || rStat.GetPointAnz() >= 2 );
2231 }
2232
2233 basegfx::B2DPolyPolygon SdrObjCustomShape::TakeCreatePoly(const SdrDragStat& /*rDrag*/) const
2234 {
2235 return GetLineGeometry( this, sal_False );
2236 }
2237
2238 ////////////////////////////////////////////////////////////////////////////////////////////////////
2239
2240 // in context with the SdrObjCustomShape the SdrTextAutoGrowHeightItem == true -> Resize Shape to fit text,
2241 // the SdrTextAutoGrowWidthItem == true -> Word wrap text in Shape
2242 bool SdrObjCustomShape::IsAutoGrowHeight() const
2243 {
2244 const SfxItemSet& rSet = GetMergedItemSet();
2245 bool bIsAutoGrowHeight = ((SdrTextAutoGrowHeightItem&)(rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT))).GetValue();
2246 if ( bIsAutoGrowHeight && IsVerticalWriting() )
2247 bIsAutoGrowHeight = ((SdrTextWordWrapItem&)(rSet.Get(SDRATTR_TEXT_WORDWRAP))).GetValue() == sal_False;
2248 return bIsAutoGrowHeight;
2249 }
2250 bool SdrObjCustomShape::IsAutoGrowWidth() const
2251 {
2252 const SfxItemSet& rSet = GetMergedItemSet();
2253 bool bIsAutoGrowWidth = ((SdrTextAutoGrowHeightItem&)(rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT))).GetValue();
2254 if ( bIsAutoGrowWidth && !IsVerticalWriting() )
2255 bIsAutoGrowWidth = ((SdrTextWordWrapItem&)(rSet.Get(SDRATTR_TEXT_WORDWRAP))).GetValue() == sal_False;
2256 return bIsAutoGrowWidth;
2257 }
2258
2259 /* The following method is identical to the SdrTextObj::SetVerticalWriting method, the only difference
2260 is that the SdrAutoGrowWidthItem and SdrAutoGrowHeightItem are not exchanged if the vertical writing
2261 mode has been changed */
2262
2263 void SdrObjCustomShape::SetVerticalWriting( sal_Bool bVertical )
2264 {
2265 ForceOutlinerParaObject();
2266
2267 OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
2268
2269 DBG_ASSERT( pOutlinerParaObject, "SdrTextObj::SetVerticalWriting() without OutlinerParaObject!" );
2270
2271 if( pOutlinerParaObject )
2272 {
2273 if(pOutlinerParaObject->IsVertical() != (bool)bVertical)
2274 {
2275 // get item settings
2276 const SfxItemSet& rSet = GetObjectItemSet();
2277
2278 // Also exchange horizontal and vertical adjust items
2279 SdrTextHorzAdjust eHorz = ((SdrTextHorzAdjustItem&)(rSet.Get(SDRATTR_TEXT_HORZADJUST))).GetValue();
2280 SdrTextVertAdjust eVert = ((SdrTextVertAdjustItem&)(rSet.Get(SDRATTR_TEXT_VERTADJUST))).GetValue();
2281
2282 // rescue object size
2283 Rectangle aObjectRect = GetSnapRect();
2284
2285 // prepare ItemSet to set exchanged width and height items
2286 SfxItemSet aNewSet(*rSet.GetPool(),
2287 SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWHEIGHT,
2288 // Expanded item ranges to also support horizontal and vertical adjust.
2289 SDRATTR_TEXT_VERTADJUST, SDRATTR_TEXT_VERTADJUST,
2290 SDRATTR_TEXT_AUTOGROWWIDTH, SDRATTR_TEXT_HORZADJUST,
2291 0, 0);
2292
2293 aNewSet.Put(rSet);
2294
2295 // Exchange horizontal and vertical adjusts
2296 switch(eVert)
2297 {
2298 case SDRTEXTVERTADJUST_TOP: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); break;
2299 case SDRTEXTVERTADJUST_CENTER: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_CENTER)); break;
2300 case SDRTEXTVERTADJUST_BOTTOM: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); break;
2301 case SDRTEXTVERTADJUST_BLOCK: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_BLOCK)); break;
2302 }
2303 switch(eHorz)
2304 {
2305 case SDRTEXTHORZADJUST_LEFT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM)); break;
2306 case SDRTEXTHORZADJUST_CENTER: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_CENTER)); break;
2307 case SDRTEXTHORZADJUST_RIGHT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP)); break;
2308 case SDRTEXTHORZADJUST_BLOCK: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK)); break;
2309 }
2310
2311 SetObjectItemSet( aNewSet );
2312 pOutlinerParaObject = GetOutlinerParaObject();
2313 if ( pOutlinerParaObject )
2314 pOutlinerParaObject->SetVertical(bVertical);
2315
2316 // restore object size
2317 SetSnapRect(aObjectRect);
2318 }
2319 }
2320 }
2321 bool SdrObjCustomShape::AdjustTextFrameWidthAndHeight(Rectangle& rR, bool bHgt, bool bWdt) const
2322 {
2323 if ( pModel && HasText() && !rR.IsEmpty() )
2324 {
2325 bool bWdtGrow=bWdt && IsAutoGrowWidth();
2326 bool bHgtGrow=bHgt && IsAutoGrowHeight();
2327 if ( bWdtGrow || bHgtGrow )
2328 {
2329 Rectangle aR0(rR);
2330 long nHgt=0,nMinHgt=0,nMaxHgt=0;
2331 long nWdt=0,nMinWdt=0,nMaxWdt=0;
2332 Size aSiz(rR.GetSize()); aSiz.Width()--; aSiz.Height()--;
2333 Size aMaxSiz(100000,100000);
2334 Size aTmpSiz(pModel->GetMaxObjSize());
2335 if (aTmpSiz.Width()!=0) aMaxSiz.Width()=aTmpSiz.Width();
2336 if (aTmpSiz.Height()!=0) aMaxSiz.Height()=aTmpSiz.Height();
2337 if (bWdtGrow)
2338 {
2339 nMinWdt=GetMinTextFrameWidth();
2340 nMaxWdt=GetMaxTextFrameWidth();
2341 if (nMaxWdt==0 || nMaxWdt>aMaxSiz.Width()) nMaxWdt=aMaxSiz.Width();
2342 if (nMinWdt<=0) nMinWdt=1;
2343 aSiz.Width()=nMaxWdt;
2344 }
2345 if (bHgtGrow)
2346 {
2347 nMinHgt=GetMinTextFrameHeight();
2348 nMaxHgt=GetMaxTextFrameHeight();
2349 if (nMaxHgt==0 || nMaxHgt>aMaxSiz.Height()) nMaxHgt=aMaxSiz.Height();
2350 if (nMinHgt<=0) nMinHgt=1;
2351 aSiz.Height()=nMaxHgt;
2352 }
2353 long nHDist=GetTextLeftDistance()+GetTextRightDistance();
2354 long nVDist=GetTextUpperDistance()+GetTextLowerDistance();
2355 aSiz.Width()-=nHDist;
2356 aSiz.Height()-=nVDist;
2357 if ( aSiz.Width() < 2 )
2358 aSiz.Width() = 2; // minimum size=2
2359 if ( aSiz.Height() < 2 )
2360 aSiz.Height() = 2; // minimum size=2
2361
2362 if(pEdtOutl)
2363 {
2364 pEdtOutl->SetMaxAutoPaperSize( aSiz );
2365 if (bWdtGrow)
2366 {
2367 Size aSiz2(pEdtOutl->CalcTextSize());
2368 nWdt=aSiz2.Width()+1; // a little more tolerance
2369 if (bHgtGrow) nHgt=aSiz2.Height()+1; // a little more tolerance
2370 } else
2371 {
2372 nHgt=pEdtOutl->GetTextHeight()+1; // a little more tolerance
2373 }
2374 }
2375 else
2376 {
2377 Outliner& rOutliner=ImpGetDrawOutliner();
2378 rOutliner.SetPaperSize(aSiz);
2379 rOutliner.SetUpdateMode(sal_True);
2380 // TODO: add the optimization with bPortionInfoChecked again.
2381 OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
2382 if( pOutlinerParaObject != NULL )
2383 {
2384 rOutliner.SetText(*pOutlinerParaObject);
2385 rOutliner.SetFixedCellHeight(((const SdrTextFixedCellHeightItem&)GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT)).GetValue());
2386 }
2387 if ( bWdtGrow )
2388 {
2389 Size aSiz2(rOutliner.CalcTextSize());
2390 nWdt=aSiz2.Width()+1; // a little more tolerance
2391 if ( bHgtGrow )
2392 nHgt=aSiz2.Height()+1; // a little more tolerance
2393 }
2394 else
2395 nHgt = rOutliner.GetTextHeight()+1; // a little more tolerance
2396 rOutliner.Clear();
2397 }
2398 if ( nWdt < nMinWdt )
2399 nWdt = nMinWdt;
2400 if ( nWdt > nMaxWdt )
2401 nWdt = nMaxWdt;
2402 nWdt += nHDist;
2403 if ( nWdt < 1 )
2404 nWdt = 1; // nHDist may also be negative
2405 if ( nHgt < nMinHgt )
2406 nHgt = nMinHgt;
2407 if ( nHgt > nMaxHgt )
2408 nHgt = nMaxHgt;
2409 nHgt+=nVDist;
2410 if ( nHgt < 1 )
2411 nHgt = 1; // nVDist may also be negative
2412 long nWdtGrow = nWdt-(rR.Right()-rR.Left());
2413 long nHgtGrow = nHgt-(rR.Bottom()-rR.Top());
2414 if ( nWdtGrow == 0 )
2415 bWdtGrow = sal_False;
2416 if ( nHgtGrow == 0 )
2417 bHgtGrow=sal_False;
2418 if ( bWdtGrow || bHgtGrow )
2419 {
2420 if ( bWdtGrow )
2421 {
2422 SdrTextHorzAdjust eHAdj=GetTextHorizontalAdjust();
2423 if ( eHAdj == SDRTEXTHORZADJUST_LEFT )
2424 rR.Right()+=nWdtGrow;
2425 else if ( eHAdj == SDRTEXTHORZADJUST_RIGHT )
2426 rR.Left()-=nWdtGrow;
2427 else
2428 {
2429 long nWdtGrow2=nWdtGrow/2;
2430 rR.Left()-=nWdtGrow2;
2431 rR.Right()=rR.Left()+nWdt;
2432 }
2433 }
2434 if ( bHgtGrow )
2435 {
2436 SdrTextVertAdjust eVAdj=GetTextVerticalAdjust();
2437 if ( eVAdj == SDRTEXTVERTADJUST_TOP )
2438 rR.Bottom()+=nHgtGrow;
2439 else if ( eVAdj == SDRTEXTVERTADJUST_BOTTOM )
2440 rR.Top()-=nHgtGrow;
2441 else
2442 {
2443 long nHgtGrow2=nHgtGrow/2;
2444 rR.Top()-=nHgtGrow2;
2445 rR.Bottom()=rR.Top()+nHgt;
2446 }
2447 }
2448 if ( aGeo.nDrehWink )
2449 {
2450 Point aD1(rR.TopLeft());
2451 aD1-=aR0.TopLeft();
2452 Point aD2(aD1);
2453 RotatePoint(aD2,Point(),aGeo.nSin,aGeo.nCos);
2454 aD2-=aD1;
2455 rR.Move(aD2.X(),aD2.Y());
2456 }
2457 return sal_True;
2458 }
2459 }
2460 }
2461 return sal_False;
2462 }
2463
2464 Rectangle SdrObjCustomShape::ImpCalculateTextFrame( const bool bHgt, const bool bWdt )
2465 {
2466 Rectangle aReturnValue;
2467
2468 Rectangle aOldTextRect( aRect ); // <- initial text rectangle
2469
2470 Rectangle aNewTextRect( aRect ); // <- new text rectangle returned from the custom shape renderer,
2471 GetTextBounds( aNewTextRect ); // it depends to the current logical shape size
2472
2473 Rectangle aAdjustedTextRect( aNewTextRect ); // <- new text rectangle is being tested by AdjustTextFrameWidthAndHeight to ensure
2474 if ( AdjustTextFrameWidthAndHeight( aAdjustedTextRect, bHgt, bWdt ) ) // that the new text rectangle is matching the current text size from the outliner
2475 {
2476 if ( ( aAdjustedTextRect != aNewTextRect ) && ( aOldTextRect != aAdjustedTextRect ) )
2477 {
2478 aReturnValue = aRect;
2479 double fXScale = (double)aOldTextRect.GetWidth() / (double)aNewTextRect.GetWidth();
2480 double fYScale = (double)aOldTextRect.GetHeight() / (double)aNewTextRect.GetHeight();
2481 double fRightDiff = (double)( aAdjustedTextRect.Right() - aNewTextRect.Right() ) * fXScale;
2482 double fLeftDiff = (double)( aAdjustedTextRect.Left() - aNewTextRect.Left() ) * fXScale;
2483 double fTopDiff = (double)( aAdjustedTextRect.Top() - aNewTextRect.Top() ) * fYScale;
2484 double fBottomDiff= (double)( aAdjustedTextRect.Bottom()- aNewTextRect.Bottom()) * fYScale;
2485 aReturnValue.Left() += (sal_Int32)fLeftDiff;
2486 aReturnValue.Right() += (sal_Int32)fRightDiff;
2487 aReturnValue.Top() += (sal_Int32)fTopDiff;
2488 aReturnValue.Bottom() += (sal_Int32)fBottomDiff;
2489 }
2490 }
2491 return aReturnValue;
2492 }
2493
2494 bool SdrObjCustomShape::NbcAdjustTextFrameWidthAndHeight(bool bHgt, bool bWdt)
2495 {
2496 Rectangle aNewTextRect = ImpCalculateTextFrame( bHgt, bWdt );
2497 bool bRet = !aNewTextRect.IsEmpty() && ( aNewTextRect != aRect );
2498 if ( bRet )
2499 {
2500 // taking care of handles that should not been changed
2501 std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );
2502
2503 aRect = aNewTextRect;
2504 SetRectsDirty();
2505 SetChanged();
2506
2507 for (std::vector< SdrCustomShapeInteraction >::const_iterator aIter( aInteractionHandles.begin() ), aEnd ( aInteractionHandles.end() );
2508 aIter != aEnd ; ++aIter)
2509 {
2510 try
2511 {
2512 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
2513 aIter->xInteraction->setControllerPosition( aIter->aPosition );
2514 }
2515 catch ( const uno::RuntimeException& )
2516 {
2517 }
2518 }
2519 InvalidateRenderGeometry();
2520 }
2521 return bRet;
2522 }
2523 bool SdrObjCustomShape::AdjustTextFrameWidthAndHeight(bool bHgt, bool bWdt)
2524 {
2525 Rectangle aNewTextRect = ImpCalculateTextFrame( bHgt, bWdt );
2526 bool bRet = !aNewTextRect.IsEmpty() && ( aNewTextRect != aRect );
2527 if ( bRet )
2528 {
2529 Rectangle aBoundRect0;
2530 if ( pUserCall )
2531 aBoundRect0 = GetCurrentBoundRect();
2532
2533 // taking care of handles that should not been changed
2534 std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );
2535
2536 aRect = aNewTextRect;
2537 SetRectsDirty();
2538
2539 for (std::vector< SdrCustomShapeInteraction >::const_iterator aIter( aInteractionHandles.begin() ), aEnd( aInteractionHandles.end() ) ;
2540 aIter != aEnd ; ++aIter)
2541 {
2542 try
2543 {
2544 if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
2545 aIter->xInteraction->setControllerPosition( aIter->aPosition );
2546 }
2547 catch ( const uno::RuntimeException& )
2548 {
2549 }
2550 }
2551
2552 InvalidateRenderGeometry();
2553 SetChanged();
2554 BroadcastObjectChange();
2555 SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
2556 }
2557 return bRet;
2558 }
2559 sal_Bool SdrObjCustomShape::BegTextEdit( SdrOutliner& rOutl )
2560 {
2561 return SdrTextObj::BegTextEdit( rOutl );
2562 }
2563 void SdrObjCustomShape::TakeTextEditArea(Size* pPaperMin, Size* pPaperMax, Rectangle* pViewInit, Rectangle* pViewMin) const
2564 {
2565 Size aPaperMin,aPaperMax;
2566 Rectangle aViewInit;
2567 TakeTextAnchorRect( aViewInit );
2568 if ( aGeo.nDrehWink )
2569 {
2570 Point aCenter(aViewInit.Center());
2571 aCenter-=aViewInit.TopLeft();
2572 Point aCenter0(aCenter);
2573 RotatePoint(aCenter,Point(),aGeo.nSin,aGeo.nCos);
2574 aCenter-=aCenter0;
2575 aViewInit.Move(aCenter.X(),aCenter.Y());
2576 }
2577 Size aAnkSiz(aViewInit.GetSize());
2578 aAnkSiz.Width()--; aAnkSiz.Height()--; // because GetSize() adds 1
2579 Size aMaxSiz(1000000,1000000);
2580 if (pModel!=NULL) {
2581 Size aTmpSiz(pModel->GetMaxObjSize());
2582 if (aTmpSiz.Width()!=0) aMaxSiz.Width()=aTmpSiz.Width();
2583 if (aTmpSiz.Height()!=0) aMaxSiz.Height()=aTmpSiz.Height();
2584 }
2585 SdrTextHorzAdjust eHAdj(GetTextHorizontalAdjust());
2586 SdrTextVertAdjust eVAdj(GetTextVerticalAdjust());
2587
2588 long nMinWdt = GetMinTextFrameWidth();
2589 long nMinHgt = GetMinTextFrameHeight();
2590 long nMaxWdt = GetMaxTextFrameWidth();
2591 long nMaxHgt = GetMaxTextFrameHeight();
2592 if (nMinWdt<1) nMinWdt=1;
2593 if (nMinHgt<1) nMinHgt=1;
2594 if ( nMaxWdt == 0 || nMaxWdt > aMaxSiz.Width() )
2595 nMaxWdt = aMaxSiz.Width();
2596 if ( nMaxHgt == 0 || nMaxHgt > aMaxSiz.Height() )
2597 nMaxHgt=aMaxSiz.Height();
2598
2599 if (((SdrTextWordWrapItem&)(GetMergedItem(SDRATTR_TEXT_WORDWRAP))).GetValue())
2600 {
2601 if ( IsVerticalWriting() )
2602 {
2603 nMaxHgt = aAnkSiz.Height();
2604 nMinHgt = nMaxHgt;
2605 }
2606 else
2607 {
2608 nMaxWdt = aAnkSiz.Width();
2609 nMinWdt = nMaxWdt;
2610 }
2611 }
2612 aPaperMax.Width()=nMaxWdt;
2613 aPaperMax.Height()=nMaxHgt;
2614
2615 aPaperMin.Width()=nMinWdt;
2616 aPaperMin.Height()=nMinHgt;
2617
2618 if ( pViewMin )
2619 {
2620 *pViewMin = aViewInit;
2621
2622 long nXFree = aAnkSiz.Width() - aPaperMin.Width();
2623 if ( eHAdj == SDRTEXTHORZADJUST_LEFT )
2624 pViewMin->Right() -= nXFree;
2625 else if ( eHAdj == SDRTEXTHORZADJUST_RIGHT )
2626 pViewMin->Left() += nXFree;
2627 else { pViewMin->Left() += nXFree / 2; pViewMin->Right() = pViewMin->Left() + aPaperMin.Width(); }
2628
2629 long nYFree = aAnkSiz.Height() - aPaperMin.Height();
2630 if ( eVAdj == SDRTEXTVERTADJUST_TOP )
2631 pViewMin->Bottom() -= nYFree;
2632 else if ( eVAdj == SDRTEXTVERTADJUST_BOTTOM )
2633 pViewMin->Top() += nYFree;
2634 else { pViewMin->Top() += nYFree / 2; pViewMin->Bottom() = pViewMin->Top() + aPaperMin.Height(); }
2635 }
2636
2637 if( IsVerticalWriting() )
2638 aPaperMin.Width() = 0;
2639 else
2640 aPaperMin.Height() = 0;
2641
2642 if( eHAdj != SDRTEXTHORZADJUST_BLOCK )
2643 aPaperMin.Width()=0;
2644
2645 // For complete vertical adjust support, set paper min height to 0, here.
2646 if(SDRTEXTVERTADJUST_BLOCK != eVAdj )
2647 aPaperMin.Height() = 0;
2648
2649 if (pPaperMin!=NULL) *pPaperMin=aPaperMin;
2650 if (pPaperMax!=NULL) *pPaperMax=aPaperMax;
2651 if (pViewInit!=NULL) *pViewInit=aViewInit;
2652 }
2653 void SdrObjCustomShape::EndTextEdit( SdrOutliner& rOutl )
2654 {
2655 SdrTextObj::EndTextEdit( rOutl );
2656 InvalidateRenderGeometry();
2657 }
2658 void SdrObjCustomShape::TakeTextAnchorRect( Rectangle& rAnchorRect ) const
2659 {
2660 if ( GetTextBounds( rAnchorRect ) )
2661 {
2662 Point aRotateRef( maSnapRect.Center() );
2663 rAnchorRect.Left() += GetTextLeftDistance();
2664 rAnchorRect.Top() += GetTextUpperDistance();
2665 rAnchorRect.Right() -= GetTextRightDistance();
2666 rAnchorRect.Bottom() -= GetTextLowerDistance();
2667 ImpJustifyRect( rAnchorRect );
2668
2669 if ( rAnchorRect.GetWidth() < 2 )
2670 rAnchorRect.Right() = rAnchorRect.Left() + 1; // minimal width is 2
2671 if ( rAnchorRect.GetHeight() < 2 )
2672 rAnchorRect.Bottom() = rAnchorRect.Top() + 1; // minimal height is 2
2673 if ( aGeo.nDrehWink )
2674 {
2675 Point aP( rAnchorRect.TopLeft() );
2676 RotatePoint( aP, aRotateRef, aGeo.nSin, aGeo. nCos );
2677 rAnchorRect.SetPos( aP );
2678 }
2679 }
2680 else
2681 SdrTextObj::TakeTextAnchorRect( rAnchorRect );
2682 }
2683 void SdrObjCustomShape::TakeTextRect( SdrOutliner& rOutliner, Rectangle& rTextRect, bool bNoEditText,
2684 Rectangle* pAnchorRect, bool /*bLineWidth*/) const
2685 {
2686 Rectangle aAnkRect; // Rect in which we anchor
2687 TakeTextAnchorRect(aAnkRect);
2688 SdrTextVertAdjust eVAdj=GetTextVerticalAdjust();
2689 SdrTextHorzAdjust eHAdj=GetTextHorizontalAdjust();
2690 sal_uIntPtr nStat0=rOutliner.GetControlWord();
2691 Size aNullSize;
2692
2693 rOutliner.SetControlWord(nStat0|EE_CNTRL_AUTOPAGESIZE);
2694 rOutliner.SetMinAutoPaperSize(aNullSize);
2695 sal_Int32 nMaxAutoPaperWidth = 1000000;
2696 sal_Int32 nMaxAutoPaperHeight= 1000000;
2697
2698 long nAnkWdt=aAnkRect.GetWidth();
2699 long nAnkHgt=aAnkRect.GetHeight();
2700
2701 if (((SdrTextWordWrapItem&)(GetMergedItem(SDRATTR_TEXT_WORDWRAP))).GetValue())
2702 {
2703 if ( IsVerticalWriting() )
2704 nMaxAutoPaperHeight = nAnkHgt;
2705 else
2706 nMaxAutoPaperWidth = nAnkWdt;
2707 }
2708 if(SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting())
2709 {
2710 rOutliner.SetMinAutoPaperSize(Size(nAnkWdt, 0));
2711 }
2712
2713 if(SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting())
2714 {
2715 rOutliner.SetMinAutoPaperSize(Size(0, nAnkHgt));
2716 }
2717 rOutliner.SetMaxAutoPaperSize( Size( nMaxAutoPaperWidth, nMaxAutoPaperHeight ) );
2718 rOutliner.SetPaperSize( aNullSize );
2719
2720 // put text into the Outliner - if necessary the use the text from the EditOutliner
2721 OutlinerParaObject* pPara= GetOutlinerParaObject();
2722 if (pEdtOutl && !bNoEditText)
2723 pPara=pEdtOutl->CreateParaObject();
2724
2725 if (pPara)
2726 {
2727 bool bHitTest = false;
2728 if( pModel )
2729 bHitTest = &pModel->GetHitTestOutliner() == &rOutliner;
2730
2731 const SdrTextObj* pTestObj = rOutliner.GetTextObj();
2732 if( !pTestObj || !bHitTest || pTestObj != this ||
2733 pTestObj->GetOutlinerParaObject() != GetOutlinerParaObject() )
2734 {
2735 if( bHitTest )
2736 rOutliner.SetTextObj( this );
2737
2738 rOutliner.SetUpdateMode(sal_True);
2739 rOutliner.SetText(*pPara);
2740 }
2741 }
2742 else
2743 {
2744 rOutliner.SetTextObj( NULL );
2745 }
2746 if (pEdtOutl && !bNoEditText && pPara)
2747 delete pPara;
2748
2749 rOutliner.SetUpdateMode(sal_True);
2750 rOutliner.SetControlWord(nStat0);
2751
2752 SdrText* pText = getActiveText();
2753 if( pText )
2754 pText->CheckPortionInfo( rOutliner );
2755
2756 Point aTextPos(aAnkRect.TopLeft());
2757 Size aTextSiz(rOutliner.GetPaperSize()); // GetPaperSize() has a little added tolerance, no?
2758
2759 // For draw objects containing text correct horizontal/vertical alignment if text is bigger
2760 // than the object itself. Without that correction, the text would always be
2761 // formatted to the left edge (or top edge when vertical) of the draw object.
2762
2763 if( !IsTextFrame() )
2764 {
2765 if(aAnkRect.GetWidth() < aTextSiz.Width() && !IsVerticalWriting())
2766 {
2767 // Horizontal case here. Correct only if eHAdj == SDRTEXTHORZADJUST_BLOCK,
2768 // else the alignment is wanted.
2769 if(SDRTEXTHORZADJUST_BLOCK == eHAdj)
2770 {
2771 eHAdj = SDRTEXTHORZADJUST_CENTER;
2772 }
2773 }
2774
2775 if(aAnkRect.GetHeight() < aTextSiz.Height() && IsVerticalWriting())
2776 {
2777 // Vertical case here. Correct only if eHAdj == SDRTEXTVERTADJUST_BLOCK,
2778 // else the alignment is wanted.
2779 if(SDRTEXTVERTADJUST_BLOCK == eVAdj)
2780 {
2781 eVAdj = SDRTEXTVERTADJUST_CENTER;
2782 }
2783 }
2784 }
2785
2786 if (eHAdj==SDRTEXTHORZADJUST_CENTER || eHAdj==SDRTEXTHORZADJUST_RIGHT)
2787 {
2788 long nFreeWdt=aAnkRect.GetWidth()-aTextSiz.Width();
2789 if (eHAdj==SDRTEXTHORZADJUST_CENTER)
2790 aTextPos.X()+=nFreeWdt/2;
2791 if (eHAdj==SDRTEXTHORZADJUST_RIGHT)
2792 aTextPos.X()+=nFreeWdt;
2793 }
2794 if (eVAdj==SDRTEXTVERTADJUST_CENTER || eVAdj==SDRTEXTVERTADJUST_BOTTOM)
2795 {
2796 long nFreeHgt=aAnkRect.GetHeight()-aTextSiz.Height();
2797 if (eVAdj==SDRTEXTVERTADJUST_CENTER)
2798 aTextPos.Y()+=nFreeHgt/2;
2799 if (eVAdj==SDRTEXTVERTADJUST_BOTTOM)
2800 aTextPos.Y()+=nFreeHgt;
2801 }
2802 if (aGeo.nDrehWink!=0)
2803 RotatePoint(aTextPos,aAnkRect.TopLeft(),aGeo.nSin,aGeo.nCos);
2804
2805 if (pAnchorRect)
2806 *pAnchorRect=aAnkRect;
2807
2808 // using rTextRect together with ContourFrame doesn't always work correctly
2809 rTextRect=Rectangle(aTextPos,aTextSiz);
2810 }
2811
2812 void SdrObjCustomShape::NbcSetOutlinerParaObject(OutlinerParaObject* pTextObject)
2813 {
2814 SdrTextObj::NbcSetOutlinerParaObject( pTextObject );
2815 SetBoundRectDirty();
2816 SetRectsDirty(sal_True);
2817 InvalidateRenderGeometry();
2818 }
2819
2820 SdrObjCustomShape* SdrObjCustomShape::Clone() const
2821 {
2822 return CloneHelper< SdrObjCustomShape >();
2823 }
2824
2825 SdrObjCustomShape& SdrObjCustomShape::operator=(const SdrObjCustomShape& rObj)
2826 {
2827 if( this == &rObj )
2828 return *this;
2829 SdrTextObj::operator=( rObj );
2830 aName = rObj.aName;
2831 fObjectRotation = rObj.fObjectRotation;
2832 InvalidateRenderGeometry();
2833 return *this;
2834 }
2835
2836
2837 void SdrObjCustomShape::TakeObjNameSingul(XubString& rName) const
2838 {
2839 rName = ImpGetResStr(STR_ObjNameSingulCUSTOMSHAPE);
2840 String aNm( GetName() );
2841 if( aNm.Len() )
2842 {
2843 rName += sal_Unicode(' ');
2844 rName += sal_Unicode('\'');
2845 rName += aNm;
2846 rName += sal_Unicode('\'');
2847 }
2848 }
2849
2850 void SdrObjCustomShape::TakeObjNamePlural(XubString& rName) const
2851 {
2852 rName=ImpGetResStr(STR_ObjNamePluralCUSTOMSHAPE);
2853 }
2854
2855 basegfx::B2DPolyPolygon SdrObjCustomShape::TakeXorPoly() const
2856 {
2857 return GetLineGeometry( (SdrObjCustomShape*)this, sal_False );
2858 }
2859
2860 basegfx::B2DPolyPolygon SdrObjCustomShape::TakeContour() const
2861 {
2862 const SdrObject* pSdrObject = GetSdrObjectFromCustomShape();
2863 if ( pSdrObject )
2864 return pSdrObject->TakeContour();
2865 return basegfx::B2DPolyPolygon();
2866 }
2867
2868 SdrObject* SdrObjCustomShape::DoConvertToPolyObj(sal_Bool bBezier, bool bAddText) const
2869 {
2870 // #i37011#
2871 SdrObject* pRetval = 0L;
2872 SdrObject* pRenderedCustomShape = 0L;
2873
2874 if ( !mXRenderedCustomShape.is() )
2875 {
2876 // force CustomShape
2877 ((SdrObjCustomShape*)this)->GetSdrObjectFromCustomShape();
2878 }
2879
2880 if ( mXRenderedCustomShape.is() )
2881 {
2882 pRenderedCustomShape = GetSdrObjectFromXShape( mXRenderedCustomShape );
2883 }
2884
2885 if ( pRenderedCustomShape )
2886 {
2887 SdrObject* pCandidate = pRenderedCustomShape->Clone();
2888 DBG_ASSERT(pCandidate, "SdrObjCustomShape::DoConvertToPolyObj: Could not clone SdrObject (!)");
2889 pCandidate->SetModel(GetModel());
2890 pRetval = pCandidate->DoConvertToPolyObj(bBezier, bAddText);
2891 SdrObject::Free( pCandidate );
2892
2893 if(pRetval)
2894 {
2895 const sal_Bool bShadow(((SdrShadowItem&)GetMergedItem(SDRATTR_SHADOW)).GetValue());
2896 if(bShadow)
2897 {
2898 pRetval->SetMergedItem(SdrShadowItem(sal_True));
2899 }
2900 }
2901
2902 if(bAddText && HasText() && !IsTextPath())
2903 {
2904 pRetval = ImpConvertAddText(pRetval, bBezier);
2905 }
2906 }
2907
2908 return pRetval;
2909 }
2910
2911 void SdrObjCustomShape::NbcSetStyleSheet( SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr )
2912 {
2913 // #i40944#
2914 InvalidateRenderGeometry();
2915 SdrObject::NbcSetStyleSheet( pNewStyleSheet, bDontRemoveHardAttr );
2916 }
2917
2918 void SdrObjCustomShape::SetPage( SdrPage* pNewPage )
2919 {
2920 SdrTextObj::SetPage( pNewPage );
2921
2922 if( pNewPage )
2923 {
2924 // invalidating rectangles by SetRectsDirty is not sufficient,
2925 // AdjustTextFrameWidthAndHeight() also has to be made, both
2926 // actions are done by NbcSetSnapRect
2927 Rectangle aTmp( aRect ); //creating temporary rectangle #i61108#
2928 NbcSetSnapRect( aTmp );
2929 }
2930 }
2931
2932 SdrObjGeoData* SdrObjCustomShape::NewGeoData() const
2933 {
2934 return new SdrAShapeObjGeoData;
2935 }
2936
2937 void SdrObjCustomShape::SaveGeoData(SdrObjGeoData& rGeo) const
2938 {
2939 SdrTextObj::SaveGeoData( rGeo );
2940 SdrAShapeObjGeoData& rAGeo=(SdrAShapeObjGeoData&)rGeo;
2941 rAGeo.fObjectRotation = fObjectRotation;
2942 rAGeo.bMirroredX = IsMirroredX();
2943 rAGeo.bMirroredY = IsMirroredY();
2944
2945 const OUString sAdjustmentValues( "AdjustmentValues" );
2946 Any* pAny( ( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ).GetPropertyValueByName( sAdjustmentValues ) );
2947 if ( pAny )
2948 *pAny >>= rAGeo.aAdjustmentSeq;
2949 }
2950
2951 void SdrObjCustomShape::RestGeoData(const SdrObjGeoData& rGeo)
2952 {
2953 SdrTextObj::RestGeoData( rGeo );
2954 SdrAShapeObjGeoData& rAGeo=(SdrAShapeObjGeoData&)rGeo;
2955 fObjectRotation = rAGeo.fObjectRotation;
2956 SetMirroredX( rAGeo.bMirroredX );
2957 SetMirroredY( rAGeo.bMirroredY );
2958
2959 SdrCustomShapeGeometryItem rGeometryItem = (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
2960 const OUString sAdjustmentValues( "AdjustmentValues" );
2961 PropertyValue aPropVal;
2962 aPropVal.Name = sAdjustmentValues;
2963 aPropVal.Value <<= rAGeo.aAdjustmentSeq;
2964 rGeometryItem.SetPropertyValue( aPropVal );
2965 SetMergedItem( rGeometryItem );
2966
2967 InvalidateRenderGeometry();
2968 }
2969
2970 void SdrObjCustomShape::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/)
2971 {
2972 // break up matrix
2973 basegfx::B2DTuple aScale;
2974 basegfx::B2DTuple aTranslate;
2975 double fRotate, fShearX;
2976 rMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
2977
2978 // #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings
2979 // in X and Y which equal a 180 degree rotation. Recognize it and react accordingly
2980 if(basegfx::fTools::less(aScale.getX(), 0.0) && basegfx::fTools::less(aScale.getY(), 0.0))
2981 {
2982 aScale.setX(fabs(aScale.getX()));
2983 aScale.setY(fabs(aScale.getY()));
2984 fRotate = fmod(fRotate + F_PI, F_2PI);
2985 }
2986
2987 // reset object shear and rotations
2988 aGeo.nDrehWink = 0;
2989 aGeo.RecalcSinCos();
2990 aGeo.nShearWink = 0;
2991 aGeo.RecalcTan();
2992
2993 // force metric to pool metric
2994 const SfxMapUnit eMapUnit(GetObjectMapUnit());
2995 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
2996 {
2997 switch(eMapUnit)
2998 {
2999 case SFX_MAPUNIT_TWIP :
3000 {
3001 // position
3002 aTranslate.setX(ImplMMToTwips(aTranslate.getX()));
3003 aTranslate.setY(ImplMMToTwips(aTranslate.getY()));
3004
3005 // size
3006 aScale.setX(ImplMMToTwips(aScale.getX()));
3007 aScale.setY(ImplMMToTwips(aScale.getY()));
3008
3009 break;
3010 }
3011 default:
3012 {
3013 OSL_FAIL("TRSetBaseGeometry: Missing unit translation to PoolMetric!");
3014 }
3015 }
3016 }
3017
3018 // if anchor is used, make position relative to it
3019 if( pModel && pModel->IsWriter() )
3020 {
3021 if(GetAnchorPos().X() || GetAnchorPos().Y())
3022 {
3023 aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
3024 }
3025 }
3026
3027 // build and set BaseRect (use scale)
3028 Point aPoint = Point();
3029 Size aSize(FRound(aScale.getX()), FRound(aScale.getY()));
3030 // fdo#47434 We need a valid rectangle here
3031 if( !aSize.Height() ) aSize.setHeight( 1 );
3032 if( !aSize.Width() ) aSize.setWidth( 1 );
3033
3034 Rectangle aBaseRect(aPoint, aSize);
3035 SetSnapRect(aBaseRect);
3036
3037 // shear?
3038 if(!basegfx::fTools::equalZero(fShearX))
3039 {
3040 GeoStat aGeoStat;
3041 aGeoStat.nShearWink = FRound((atan(fShearX) / F_PI180) * 100.0);
3042 aGeoStat.RecalcTan();
3043 Shear(Point(), aGeoStat.nShearWink, aGeoStat.nTan, sal_False);
3044 }
3045
3046 // rotation?
3047 if(!basegfx::fTools::equalZero(fRotate))
3048 {
3049 GeoStat aGeoStat;
3050
3051 // #i78696#
3052 // fRotate is mathematically correct, but aGeoStat.nDrehWink is
3053 // mirrored -> mirror value here
3054 aGeoStat.nDrehWink = NormAngle360(FRound(-fRotate / F_PI18000));
3055 aGeoStat.RecalcSinCos();
3056 Rotate(Point(), aGeoStat.nDrehWink, aGeoStat.nSin, aGeoStat.nCos);
3057 }
3058
3059 // translate?
3060 if(!aTranslate.equalZero())
3061 {
3062 Move(Size(FRound(aTranslate.getX()), FRound(aTranslate.getY())));
3063 }
3064 }
3065
3066 // taking fObjectRotation instead of aGeo.nWink
3067 sal_Bool SdrObjCustomShape::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const
3068 {
3069 // get turn and shear
3070 double fRotate = fObjectRotation * F_PI180;
3071 double fShearX = (aGeo.nShearWink / 100.0) * F_PI180;
3072
3073 // get aRect, this is the unrotated snaprect
3074 Rectangle aRectangle(aRect);
3075
3076 sal_Bool bMirroredX = IsMirroredX();
3077 sal_Bool bMirroredY = IsMirroredY();
3078 if ( bMirroredX || bMirroredY )
3079 { // we have to retrieve the unmirrored rect
3080
3081 GeoStat aNewGeo( aGeo );
3082
3083 if ( bMirroredX )
3084 {
3085 Polygon aPol( Rect2Poly( aRect, aNewGeo ) );
3086 Rectangle aBoundRect( aPol.GetBoundRect() );
3087
3088 Point aRef1( ( aBoundRect.Left() + aBoundRect.Right() ) >> 1, aBoundRect.Top() );
3089 Point aRef2( aRef1.X(), aRef1.Y() + 1000 );
3090 sal_uInt16 i;
3091 sal_uInt16 nPntAnz=aPol.GetSize();
3092 for (i=0; i<nPntAnz; i++)
3093 {
3094 MirrorPoint(aPol[i],aRef1,aRef2);
3095 }
3096 // mirror polygon and move it a bit
3097 Polygon aPol0(aPol);
3098 aPol[0]=aPol0[1];
3099 aPol[1]=aPol0[0];
3100 aPol[2]=aPol0[3];
3101 aPol[3]=aPol0[2];
3102 aPol[4]=aPol0[1];
3103 Poly2Rect(aPol,aRectangle,aNewGeo);
3104 }
3105 if ( bMirroredY )
3106 {
3107 Polygon aPol( Rect2Poly( aRectangle, aNewGeo ) );
3108 Rectangle aBoundRect( aPol.GetBoundRect() );
3109
3110 Point aRef1( aBoundRect.Left(), ( aBoundRect.Top() + aBoundRect.Bottom() ) >> 1 );
3111 Point aRef2( aRef1.X() + 1000, aRef1.Y() );
3112 sal_uInt16 i;
3113 sal_uInt16 nPntAnz=aPol.GetSize();
3114 for (i=0; i<nPntAnz; i++)
3115 {
3116 MirrorPoint(aPol[i],aRef1,aRef2);
3117 }
3118 // mirror polygon and move it a bit
3119 Polygon aPol0(aPol);
3120 aPol[0]=aPol0[1];
3121 aPol[1]=aPol0[0];
3122 aPol[2]=aPol0[3];
3123 aPol[3]=aPol0[2];
3124 aPol[4]=aPol0[1];
3125 Poly2Rect(aPol,aRectangle,aNewGeo);
3126 }
3127 }
3128
3129 // fill other values
3130 basegfx::B2DTuple aScale(aRectangle.GetWidth(), aRectangle.GetHeight());
3131 basegfx::B2DTuple aTranslate(aRectangle.Left(), aRectangle.Top());
3132
3133 // position may be relative to anchorpos, convert
3134 if( pModel && pModel->IsWriter() )
3135 {
3136 if(GetAnchorPos().X() || GetAnchorPos().Y())
3137 {
3138 aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
3139 }
3140 }
3141
3142 // force MapUnit to 100th mm
3143 const SfxMapUnit eMapUnit(GetObjectMapUnit());
3144 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
3145 {
3146 switch(eMapUnit)
3147 {
3148 case SFX_MAPUNIT_TWIP :
3149 {
3150 // position
3151 aTranslate.setX(ImplTwipsToMM(aTranslate.getX()));
3152 aTranslate.setY(ImplTwipsToMM(aTranslate.getY()));
3153
3154 // size
3155 aScale.setX(ImplTwipsToMM(aScale.getX()));
3156 aScale.setY(ImplTwipsToMM(aScale.getY()));
3157
3158 break;
3159 }
3160 default:
3161 {
3162 OSL_FAIL("TRGetBaseGeometry: Missing unit translation to 100th mm!");
3163 }
3164 }
3165 }
3166
3167 // build matrix
3168 rMatrix = basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
3169 aScale,
3170 basegfx::fTools::equalZero(fShearX) ? 0.0 : tan(fShearX),
3171 basegfx::fTools::equalZero(fRotate) ? 0.0 : -fRotate,
3172 aTranslate);
3173
3174 return sal_False;
3175 }
3176
3177 sdr::contact::ViewContact* SdrObjCustomShape::CreateObjectSpecificViewContact()
3178 {
3179 return new sdr::contact::ViewContactOfSdrObjCustomShape(*this);
3180 }
3181
3182 // #i33136#
3183 bool SdrObjCustomShape::doConstructOrthogonal(const OUString& rName)
3184 {
3185 bool bRetval(false);
3186 static OUString Imps_sNameASOrtho_quadrat( "quadrat" );
3187 static OUString Imps_sNameASOrtho_round_quadrat( "round-quadrat" );
3188 static OUString Imps_sNameASOrtho_circle( "circle" );
3189 static OUString Imps_sNameASOrtho_circle_pie( "circle-pie" );
3190 static OUString Imps_sNameASOrtho_ring( "ring" );
3191
3192 if(Imps_sNameASOrtho_quadrat.equalsIgnoreAsciiCase(rName))
3193 {
3194 bRetval = true;
3195 }
3196 else if(Imps_sNameASOrtho_round_quadrat.equalsIgnoreAsciiCase(rName))
3197 {
3198 bRetval = true;
3199 }
3200 else if(Imps_sNameASOrtho_circle.equalsIgnoreAsciiCase(rName))
3201 {
3202 bRetval = true;
3203 }
3204 else if(Imps_sNameASOrtho_circle_pie.equalsIgnoreAsciiCase(rName))
3205 {
3206 bRetval = true;
3207 }
3208 else if(Imps_sNameASOrtho_ring.equalsIgnoreAsciiCase(rName))
3209 {
3210 bRetval = true;
3211 }
3212
3213 return bRetval;
3214 }
3215
3216 // #i37011# centralize throw-away of render geometry
3217 void SdrObjCustomShape::InvalidateRenderGeometry()
3218 {
3219 mXRenderedCustomShape = 0L;
3220 SdrObject::Free( mpLastShadowGeometry );
3221 mpLastShadowGeometry = 0L;
3222 }
3223
3224 void SdrObjCustomShape::impl_setUnoShape(const uno::Reference<uno::XInterface>& rxUnoShape)
3225 {
3226 SdrTextObj::impl_setUnoShape(rxUnoShape);
3227
3228 // The shape engine is created with _current_ shape. This means we
3229 // _must_ reset it when the shape changes.
3230 mxCustomShapeEngine.set(0);
3231 }
3232
3233 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE