Branch data Line data Source code
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 "ShapeFactory.hxx"
21 : : #include "ViewDefines.hxx"
22 : : #include "Stripe.hxx"
23 : : #include "CommonConverters.hxx"
24 : : #include "macros.hxx"
25 : : #include "PropertyMapper.hxx"
26 : : #include <comphelper/InlineContainer.hxx>
27 : : #include <com/sun/star/beans/XPropertySet.hpp>
28 : : #include <com/sun/star/drawing/CircleKind.hpp>
29 : : #include <com/sun/star/drawing/DoubleSequence.hpp>
30 : : #include <com/sun/star/drawing/FlagSequence.hpp>
31 : : #include <com/sun/star/drawing/FillStyle.hpp>
32 : : #include <com/sun/star/drawing/LineStyle.hpp>
33 : : #include <com/sun/star/drawing/NormalsKind.hpp>
34 : : #include <com/sun/star/drawing/PointSequence.hpp>
35 : : #include <com/sun/star/drawing/PolygonKind.hpp>
36 : : #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
37 : : #include <com/sun/star/drawing/ProjectionMode.hpp>
38 : : #include <com/sun/star/drawing/ShadeMode.hpp>
39 : : #include <com/sun/star/drawing/TextFitToSizeType.hpp>
40 : : #include <com/sun/star/drawing/TextureProjectionMode.hpp>
41 : : #include <com/sun/star/text/XText.hpp>
42 : : #include <com/sun/star/uno/Any.hxx>
43 : :
44 : :
45 : : #include <editeng/unoprnms.hxx>
46 : : #include <rtl/math.hxx>
47 : : #include <svx/svdocirc.hxx>
48 : : #include <svx/svdopath.hxx>
49 : :
50 : : #include <basegfx/point/b2dpoint.hxx>
51 : : #include <basegfx/matrix/b3dhommatrix.hxx>
52 : :
53 : : #include <algorithm>
54 : :
55 : : using namespace ::com::sun::star;
56 : : using ::com::sun::star::uno::Reference;
57 : :
58 : : //.............................................................................
59 : : namespace chart
60 : : {
61 : : //.............................................................................
62 : :
63 : : //-----------------------------------------------------------------------------
64 : : //-----------------------------------------------------------------------------
65 : : // set a name/CID at a shape (is used for selection handling)
66 : : //-----------------------------------------------------------------------------
67 : : //-----------------------------------------------------------------------------
68 : :
69 : 38905 : void ShapeFactory::setShapeName( const uno::Reference< drawing::XShape >& xShape
70 : : , const rtl::OUString& rName )
71 : : {
72 [ + - ]: 38905 : if(!xShape.is())
73 : 38905 : return;
74 [ + - ]: 38905 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
75 : : OSL_ENSURE(xProp.is(), "shape offers no XPropertySet");
76 [ + - ]: 38905 : if( xProp.is())
77 : : {
78 : : try
79 : : {
80 [ + - ]: 38905 : xProp->setPropertyValue( C2U( UNO_NAME_MISC_OBJ_NAME )
81 [ + - ][ + - ]: 38905 : , uno::makeAny( rName ) );
[ + - ][ # # ]
82 : : }
83 [ # # ]: 0 : catch( const uno::Exception& e )
84 : : {
85 : : ASSERT_EXCEPTION( e );
86 : : }
87 : 38905 : }
88 : : }
89 : :
90 : : //-----------------------------------------------------------------------------
91 : :
92 : 2233 : rtl::OUString ShapeFactory::getShapeName( const uno::Reference< drawing::XShape >& xShape )
93 : : {
94 : 2233 : rtl::OUString aRet;
95 : :
96 [ + - ]: 2233 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
97 : : OSL_ENSURE(xProp.is(), "shape offers no XPropertySet");
98 [ + - ]: 2233 : if( xProp.is())
99 : : {
100 : : try
101 : : {
102 [ + - ][ + - ]: 2233 : xProp->getPropertyValue( C2U( UNO_NAME_MISC_OBJ_NAME ) ) >>= aRet;
[ + - ][ # # ]
103 : : }
104 [ # # ]: 0 : catch( const uno::Exception& e )
105 : : {
106 : : ASSERT_EXCEPTION( e );
107 : : }
108 : : }
109 : :
110 : 2233 : return aRet;
111 : : }
112 : :
113 : : //-----------------------------------------------------------------------------
114 : :
115 : 2289 : uno::Reference< drawing::XShapes > ShapeFactory::getChartRootShape(
116 : : const uno::Reference< drawing::XDrawPage>& xDrawPage )
117 : : {
118 : 2289 : uno::Reference< drawing::XShapes > xRet;
119 [ + - ]: 2289 : uno::Reference< drawing::XShapes > xShapes( xDrawPage, uno::UNO_QUERY );
120 [ + - ]: 2289 : if( xShapes.is() )
121 : : {
122 [ + - ][ + - ]: 2289 : sal_Int32 nCount = xShapes->getCount();
123 : 2289 : uno::Reference< drawing::XShape > xShape;
124 [ + + ]: 2289 : for( sal_Int32 nN = nCount; nN--; )
125 : : {
126 [ + - ][ + - ]: 2233 : if( xShapes->getByIndex( nN ) >>= xShape )
[ + - ][ + - ]
127 : : {
128 [ + - ][ + - ]: 2233 : if( ShapeFactory::getShapeName( xShape ).equals(C2U("com.sun.star.chart2.shapes")) )
[ + - ]
129 : : {
130 [ + - ][ + - ]: 2233 : xRet = uno::Reference< drawing::XShapes >( xShape, uno::UNO_QUERY );
131 : 2233 : break;
132 : : }
133 : : }
134 : 2289 : }
135 : : }
136 : 2289 : return xRet;
137 : : }
138 : :
139 : : //-----------------------------------------------------------------------------
140 : :
141 : 1177 : uno::Reference< drawing::XShapes > ShapeFactory::getOrCreateChartRootShape(
142 : : const uno::Reference< drawing::XDrawPage>& xDrawPage )
143 : : {
144 : 1177 : uno::Reference< drawing::XShapes > xRet( ShapeFactory::getChartRootShape( xDrawPage ) );
145 [ + + ]: 1177 : if( !xRet.is() )
146 : : {
147 : : //create the root shape
148 : : xRet = this->createGroup2D(
149 : : uno::Reference<drawing::XShapes>( xDrawPage, uno::UNO_QUERY )
150 [ + - ][ + - ]: 56 : , C2U("com.sun.star.chart2.shapes") );
[ + - ][ + - ]
151 : : }
152 : 1177 : return xRet;
153 : : }
154 : :
155 : : //-----------------------------------------------------------------------------
156 : : //-----------------------------------------------------------------------------
157 : : // diverse PolyPolygon create methods
158 : : //-----------------------------------------------------------------------------
159 : : //-----------------------------------------------------------------------------
160 : :
161 : 1501 : uno::Any createPolyPolygon_Cube(
162 : : const drawing::Direction3D& rSize, double fRoundedEdge, bool bRounded = true )
163 : : {
164 : : OSL_PRECOND(fRoundedEdge>=0, "fRoundedEdge needs to be >= 0");
165 : :
166 : : // always use extra points, so set percent diagonal to 0.4 which is 0% in the UI (old Chart comment)
167 [ + - ][ - + ]: 1501 : if( fRoundedEdge == 0.0 && bRounded)
168 : 0 : fRoundedEdge = 0.4 / 200.0;
169 [ + - ]: 1501 : else if(!bRounded)
170 : 1501 : fRoundedEdge = 0.0;
171 : :
172 : : //fWidthH stands for Half Width
173 [ + - ]: 1501 : const double fWidthH = rSize.DirectionX >=0.0? rSize.DirectionX/2.0 : -rSize.DirectionX/2.0;
174 : 1501 : const double fHeight = rSize.DirectionY;
175 : :
176 [ + - ]: 1501 : const double fHeightSign = fHeight >= 0.0 ? 1.0 : -1.0;
177 : :
178 : 1501 : const double fOffset = (fWidthH * fRoundedEdge) * 1.05; // increase by 5% for safety
179 [ - + ][ # # ]: 1501 : const bool bRoundEdges = fRoundedEdge && fOffset < fWidthH && 2.0 * fOffset < fHeightSign*fHeight;
[ # # ]
180 [ - + ]: 1501 : const sal_Int32 nPointCount = bRoundEdges ? 13 : 5;
181 : :
182 : : //--------------------------------------
183 [ + - ]: 1501 : drawing::PolyPolygonShape3D aPP;
184 : :
185 [ + - ]: 1501 : aPP.SequenceX.realloc(1);
186 [ + - ]: 1501 : aPP.SequenceY.realloc(1);
187 [ + - ]: 1501 : aPP.SequenceZ.realloc(1);
188 : :
189 [ + - ]: 1501 : drawing::DoubleSequence* pOuterSequenceX = aPP.SequenceX.getArray();
190 [ + - ]: 1501 : drawing::DoubleSequence* pOuterSequenceY = aPP.SequenceY.getArray();
191 [ + - ]: 1501 : drawing::DoubleSequence* pOuterSequenceZ = aPP.SequenceZ.getArray();
192 : :
193 [ + - ]: 1501 : pOuterSequenceX->realloc(nPointCount);
194 [ + - ]: 1501 : pOuterSequenceY->realloc(nPointCount);
195 [ + - ]: 1501 : pOuterSequenceZ->realloc(nPointCount);
196 : :
197 [ + - ]: 1501 : double* pInnerSequenceX = pOuterSequenceX->getArray();
198 [ + - ]: 1501 : double* pInnerSequenceY = pOuterSequenceY->getArray();
199 [ + - ]: 1501 : double* pInnerSequenceZ = pOuterSequenceZ->getArray();
200 : :
201 [ + + ]: 9006 : for(sal_Int32 nN = nPointCount; nN--;)
202 : 7505 : *pInnerSequenceZ++ = 0.0;
203 : :
204 [ + - ]: 1501 : if(nPointCount == 5)
205 : : {
206 : 1501 : *pInnerSequenceY++ = 0.0;
207 : 1501 : *pInnerSequenceY++ = 0.0;
208 : 1501 : *pInnerSequenceY++ = fHeight;
209 : 1501 : *pInnerSequenceY++ = fHeight;
210 : 1501 : *pInnerSequenceY++ = 0.0;
211 : :
212 : 1501 : *pInnerSequenceX++ = -fWidthH;
213 : 1501 : *pInnerSequenceX++ = fWidthH;
214 : 1501 : *pInnerSequenceX++ = fWidthH;
215 : 1501 : *pInnerSequenceX++ = -fWidthH;
216 : 1501 : *pInnerSequenceX++ = -fWidthH;
217 : : }
218 : : else
219 : : {
220 : 0 : *pInnerSequenceY++ = 0.0;
221 : 0 : *pInnerSequenceY++ = 0.0;
222 : 0 : *pInnerSequenceY++ = 0.0;
223 : 0 : *pInnerSequenceY++ = fHeightSign*fOffset;
224 : 0 : *pInnerSequenceY++ = fHeight - fHeightSign*fOffset;
225 : 0 : *pInnerSequenceY++ = fHeight;
226 : 0 : *pInnerSequenceY++ = fHeight;
227 : 0 : *pInnerSequenceY++ = fHeight;
228 : 0 : *pInnerSequenceY++ = fHeight;
229 : 0 : *pInnerSequenceY++ = fHeight - fHeightSign*fOffset;
230 : 0 : *pInnerSequenceY++ = fHeightSign*fOffset;
231 : 0 : *pInnerSequenceY++ = 0.0;
232 : 0 : *pInnerSequenceY++ = 0.0;
233 : :
234 : 0 : *pInnerSequenceX++ = -fWidthH + fOffset;
235 : 0 : *pInnerSequenceX++ = fWidthH - fOffset;
236 : 0 : *pInnerSequenceX++ = fWidthH;
237 : 0 : *pInnerSequenceX++ = fWidthH;
238 : 0 : *pInnerSequenceX++ = fWidthH;
239 : 0 : *pInnerSequenceX++ = fWidthH;
240 : 0 : *pInnerSequenceX++ = fWidthH - fOffset;
241 : 0 : *pInnerSequenceX++ = -fWidthH + fOffset;
242 : 0 : *pInnerSequenceX++ = -fWidthH;
243 : 0 : *pInnerSequenceX++ = -fWidthH;
244 : 0 : *pInnerSequenceX++ = -fWidthH;
245 : 0 : *pInnerSequenceX++ = -fWidthH;
246 : 0 : *pInnerSequenceX++ = -fWidthH + fOffset;
247 : : }
248 [ + - ][ + - ]: 1501 : return uno::Any( &aPP, ::getCppuType((const drawing::PolyPolygonShape3D*)0) );
249 : : }
250 : :
251 : 0 : uno::Any createPolyPolygon_Cylinder(
252 : : double fHeight
253 : : , double fRadius
254 : : , sal_Int32& nVerticalSegmentCount )
255 : : {
256 : : //fHeight may be negative
257 : : OSL_PRECOND(fRadius>0, "The radius of a cylinder needs to be > 0");
258 : :
259 : : //--------------------------------------
260 [ # # ]: 0 : drawing::PolyPolygonShape3D aPP;
261 : :
262 : 0 : nVerticalSegmentCount=1;
263 : :
264 [ # # ]: 0 : aPP.SequenceX.realloc(3);
265 [ # # ]: 0 : aPP.SequenceY.realloc(3);
266 [ # # ]: 0 : aPP.SequenceZ.realloc(3);
267 : :
268 [ # # ]: 0 : drawing::DoubleSequence* pOuterSequenceX = aPP.SequenceX.getArray();
269 [ # # ]: 0 : drawing::DoubleSequence* pOuterSequenceY = aPP.SequenceY.getArray();
270 [ # # ]: 0 : drawing::DoubleSequence* pOuterSequenceZ = aPP.SequenceZ.getArray();
271 : :
272 [ # # ]: 0 : pOuterSequenceX->realloc(2);
273 [ # # ]: 0 : pOuterSequenceY->realloc(2);
274 [ # # ]: 0 : pOuterSequenceZ->realloc(2);
275 : :
276 [ # # ]: 0 : double* pInnerSequenceX = pOuterSequenceX->getArray();
277 [ # # ]: 0 : double* pInnerSequenceY = pOuterSequenceY->getArray();
278 [ # # ]: 0 : double* pInnerSequenceZ = pOuterSequenceZ->getArray();
279 : :
280 : 0 : double fY1 = 0.0;
281 : 0 : double fY2 = fHeight;
282 : :
283 [ # # ]: 0 : if( fHeight<0.0 )
284 : 0 : ::std::swap(fY1,fY2);
285 : :
286 : : //----------------------------
287 [ # # ]: 0 : for(sal_Int32 nN = 2; nN--;)
288 : 0 : *pInnerSequenceZ++ = 0.0;
289 : :
290 : 0 : *pInnerSequenceX++ = 0.0;
291 : 0 : *pInnerSequenceY++ = fY1;
292 : :
293 : 0 : *pInnerSequenceX++ = fRadius;
294 : 0 : *pInnerSequenceY++ = fY1;
295 : : //----------------------------
296 : :
297 : 0 : pOuterSequenceX++;pOuterSequenceY++;pOuterSequenceZ++;
298 [ # # ]: 0 : pOuterSequenceX->realloc(2);
299 [ # # ]: 0 : pOuterSequenceY->realloc(2);
300 [ # # ]: 0 : pOuterSequenceZ->realloc(2);
301 : :
302 [ # # ]: 0 : pInnerSequenceX = pOuterSequenceX->getArray();
303 [ # # ]: 0 : pInnerSequenceY = pOuterSequenceY->getArray();
304 [ # # ]: 0 : pInnerSequenceZ = pOuterSequenceZ->getArray();
305 : :
306 : : //----------------------------
307 [ # # ]: 0 : for(sal_Int32 nN = 2; nN--;)
308 : 0 : *pInnerSequenceZ++ = 0.0;
309 : :
310 : 0 : *pInnerSequenceX++ = fRadius;
311 : 0 : *pInnerSequenceY++ = fY1;
312 : :
313 : 0 : *pInnerSequenceX++ = fRadius;
314 : 0 : *pInnerSequenceY++ = fY2;
315 : : //----------------------------
316 : :
317 : 0 : pOuterSequenceX++;pOuterSequenceY++;pOuterSequenceZ++;
318 [ # # ]: 0 : pOuterSequenceX->realloc(2);
319 [ # # ]: 0 : pOuterSequenceY->realloc(2);
320 [ # # ]: 0 : pOuterSequenceZ->realloc(2);
321 : :
322 [ # # ]: 0 : pInnerSequenceX = pOuterSequenceX->getArray();
323 [ # # ]: 0 : pInnerSequenceY = pOuterSequenceY->getArray();
324 [ # # ]: 0 : pInnerSequenceZ = pOuterSequenceZ->getArray();
325 : :
326 : : //----------------------------
327 [ # # ]: 0 : for(sal_Int32 nN = 2; nN--;)
328 : 0 : *pInnerSequenceZ++ = 0.0;
329 : :
330 : 0 : *pInnerSequenceX++ = fRadius;
331 : 0 : *pInnerSequenceY++ = fY2;
332 : :
333 : 0 : *pInnerSequenceX++ = 0.0;
334 : 0 : *pInnerSequenceY++ = fY2;
335 : : //----------------------------
336 : :
337 [ # # ][ # # ]: 0 : return uno::Any( &aPP, ::getCppuType((const drawing::PolyPolygonShape3D*)0) );
338 : : }
339 : :
340 : 0 : uno::Any createPolyPolygon_Cone( double fHeight, double fRadius, double fTopHeight
341 : : , sal_Int32& nVerticalSegmentCount )
342 : : {
343 : : OSL_PRECOND(fRadius>0, "The radius of a cone needs to be > 0");
344 : :
345 : : //for stacked charts we need cones without top -> fTopHeight != 0 resp. bTopless == true
346 : : //fTopHeight indicates the high of the cutted top only (not the full height)
347 : 0 : bool bTopless = !::rtl::math::approxEqual( fHeight, fHeight + fTopHeight );
348 : :
349 : 0 : double r1= 0.0, r2 = fRadius;
350 [ # # ]: 0 : if(bTopless)
351 : : // #i63212# fHeight may be negative, fTopHeight is always positive -> use fabs(fHeight)
352 : 0 : r1 = fRadius * (fTopHeight)/(fabs(fHeight)+fTopHeight);
353 : :
354 : 0 : nVerticalSegmentCount=1;
355 [ # # ]: 0 : drawing::PolyPolygonShape3D aPP;
356 : :
357 [ # # ]: 0 : aPP.SequenceX.realloc(2);
358 [ # # ]: 0 : aPP.SequenceY.realloc(2);
359 [ # # ]: 0 : aPP.SequenceZ.realloc(2);
360 : :
361 [ # # ]: 0 : drawing::DoubleSequence* pOuterSequenceX = aPP.SequenceX.getArray();
362 [ # # ]: 0 : drawing::DoubleSequence* pOuterSequenceY = aPP.SequenceY.getArray();
363 [ # # ]: 0 : drawing::DoubleSequence* pOuterSequenceZ = aPP.SequenceZ.getArray();
364 : :
365 [ # # ]: 0 : pOuterSequenceX->realloc(2);
366 [ # # ]: 0 : pOuterSequenceY->realloc(2);
367 [ # # ]: 0 : pOuterSequenceZ->realloc(2);
368 : :
369 [ # # ]: 0 : double* pInnerSequenceX = pOuterSequenceX->getArray();
370 [ # # ]: 0 : double* pInnerSequenceY = pOuterSequenceY->getArray();
371 [ # # ]: 0 : double* pInnerSequenceZ = pOuterSequenceZ->getArray();
372 : :
373 : 0 : double fX1 = 0.0;
374 : 0 : double fX2 = r2;
375 : 0 : double fX3 = r1;
376 : :
377 : 0 : double fY1 = 0.0;
378 : 0 : double fY2 = 0.0;
379 : 0 : double fY3 = fHeight;
380 : :
381 [ # # ]: 0 : if( fHeight<0.0 )
382 : : {
383 : 0 : ::std::swap(fX1,fX3);
384 : 0 : ::std::swap(fY1,fY3);
385 : : }
386 : :
387 : : //----------------------------
388 [ # # ]: 0 : for(sal_Int32 nN = 2; nN--;)
389 : 0 : *pInnerSequenceZ++ = 0.0;
390 : :
391 : 0 : *pInnerSequenceY++ = fY1;
392 : 0 : *pInnerSequenceX++ = fX1;
393 : :
394 : 0 : *pInnerSequenceY++ = fY2;
395 : 0 : *pInnerSequenceX++ = fX2;
396 : : //----------------------------
397 : :
398 : 0 : pOuterSequenceX++;pOuterSequenceY++;pOuterSequenceZ++;
399 [ # # ]: 0 : pOuterSequenceX->realloc(2);
400 [ # # ]: 0 : pOuterSequenceY->realloc(2);
401 [ # # ]: 0 : pOuterSequenceZ->realloc(2);
402 : :
403 [ # # ]: 0 : pInnerSequenceX = pOuterSequenceX->getArray();
404 [ # # ]: 0 : pInnerSequenceY = pOuterSequenceY->getArray();
405 [ # # ]: 0 : pInnerSequenceZ = pOuterSequenceZ->getArray();
406 : :
407 : : //----------------------------
408 [ # # ]: 0 : for(sal_Int32 nN = 2; nN--;)
409 : 0 : *pInnerSequenceZ++ = 0.0;
410 : :
411 : 0 : *pInnerSequenceY++ = fY2;
412 : 0 : *pInnerSequenceX++ = fX2;
413 : :
414 : 0 : *pInnerSequenceY++ = fY3;
415 : 0 : *pInnerSequenceX++ = fX3;
416 : : //----------------------------
417 : :
418 [ # # ][ # # ]: 0 : return uno::Any( &aPP, ::getCppuType((const drawing::PolyPolygonShape3D*)0) );
419 : : }
420 : :
421 : : //-----------------------------------------------------------------------------
422 : : //-----------------------------------------------------------------------------
423 : : // methods for 3D shape creation
424 : : //-----------------------------------------------------------------------------
425 : : //-----------------------------------------------------------------------------
426 : :
427 : : uno::Reference<drawing::XShape>
428 : 1501 : ShapeFactory::createCube(
429 : : const uno::Reference<drawing::XShapes>& xTarget
430 : : , const drawing::Position3D& rPosition, const drawing::Direction3D& rSize
431 : : , sal_Int32 nRotateZAngleHundredthDegree
432 : : , const uno::Reference< beans::XPropertySet >& xSourceProp
433 : : , const tPropertyNameMap& rPropertyNameMap
434 : : , bool bRounded )
435 : : {
436 [ - + ]: 1501 : if( !xTarget.is() )
437 [ # # ]: 0 : return 0;
438 [ - + ]: 1501 : if( bRounded )
439 : : {
440 : : try
441 : : {
442 [ # # ]: 0 : if( xSourceProp.is() )
443 : : {
444 : : drawing::LineStyle aLineStyle;
445 [ # # ][ # # ]: 0 : xSourceProp->getPropertyValue( C2U( "BorderStyle" ) ) >>= aLineStyle;
[ # # ][ # # ]
[ # # ]
446 [ # # ]: 0 : if( aLineStyle == drawing::LineStyle_SOLID )
447 : 0 : bRounded = false;
448 : : }
449 : : }
450 [ # # ]: 0 : catch( const uno::Exception& e )
451 : : {
452 : : ASSERT_EXCEPTION( e );
453 : : }
454 : : }
455 [ + - ]: 1501 : uno::Reference<drawing::XShape> xShape = impl_createCube( xTarget, rPosition, rSize, nRotateZAngleHundredthDegree, bRounded );
456 [ + - ]: 1501 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
457 [ + + ]: 1501 : if( xSourceProp.is())
458 [ + - ]: 36 : PropertyMapper::setMappedProperties( xProp, xSourceProp, rPropertyNameMap );
459 : 1501 : return xShape;
460 : : }
461 : :
462 : : uno::Reference<drawing::XShape>
463 : 1501 : ShapeFactory::impl_createCube(
464 : : const uno::Reference<drawing::XShapes>& xTarget
465 : : , const drawing::Position3D& rPosition, const drawing::Direction3D& rSize
466 : : , sal_Int32 nRotateZAngleHundredthDegree
467 : : , bool bRounded )
468 : : {
469 [ - + ]: 1501 : if( !xTarget.is() )
470 [ # # ]: 0 : return 0;
471 : :
472 : : //create shape
473 : : uno::Reference< drawing::XShape > xShape(
474 [ + - ]: 1501 : m_xShapeFactory->createInstance( C2U(
475 [ + - ][ + - ]: 1501 : "com.sun.star.drawing.Shape3DExtrudeObject") ), uno::UNO_QUERY );
[ + - ]
476 [ + - ][ + - ]: 1501 : xTarget->add(xShape);
477 : :
478 : : //set properties
479 [ + - ]: 1501 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
480 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
481 [ + - ]: 1501 : if( xProp.is())
482 : : {
483 : : try
484 : : {
485 : : //depth
486 : 1501 : double fDepth = rSize.DirectionZ;
487 [ - + ]: 1501 : if(fDepth<0)
488 : 0 : fDepth*=-1.0;
489 [ + - ]: 1501 : xProp->setPropertyValue( C2U( UNO_NAME_3D_EXTRUDE_DEPTH )
490 [ + - ][ + - ]: 1501 : , uno::makeAny((sal_Int32)fDepth) );
[ + - ]
491 : :
492 : : //PercentDiagonal
493 [ - + ]: 1501 : sal_Int16 nPercentDiagonal = bRounded ? 3 : 0;
494 [ + - ]: 1501 : xProp->setPropertyValue( C2U( UNO_NAME_3D_PERCENT_DIAGONAL )
495 [ + - ][ + - ]: 1501 : , uno::makeAny( nPercentDiagonal ) );
[ + - ]
496 : :
497 : : //Polygon
498 [ + - ]: 1501 : xProp->setPropertyValue( C2U( UNO_NAME_3D_POLYPOLYGON3D )
499 [ + - ][ + - ]: 1501 : , createPolyPolygon_Cube( rSize, double(nPercentDiagonal)/200.0,bRounded) );
[ + - ]
500 : :
501 : : //Matrix for position
502 : : {
503 [ + - ]: 1501 : ::basegfx::B3DHomMatrix aM;
504 [ - + ]: 1501 : if(nRotateZAngleHundredthDegree!=0)
505 [ # # ]: 0 : aM.rotate(0.0,0.0,-nRotateZAngleHundredthDegree/18000.00*F_PI);
506 : : aM.translate(rPosition.PositionX
507 : : , rPosition.PositionY
508 [ + - ]: 1501 : , rPosition.PositionZ - (fDepth/2.0));
509 [ + - ]: 1501 : drawing::HomogenMatrix aHM = B3DHomMatrixToHomogenMatrix(aM);
510 [ + - ]: 1501 : xProp->setPropertyValue( C2U( UNO_NAME_3D_TRANSFORM_MATRIX )
511 [ + - ][ + - ]: 1501 : , uno::makeAny(aHM) );
[ + - ][ + - ]
[ # # ]
512 : : }
513 : : }
514 [ # # ]: 0 : catch( const uno::Exception& e )
515 : : {
516 : : ASSERT_EXCEPTION( e );
517 : : }
518 : : }
519 : 1501 : return xShape;
520 : : }
521 : :
522 : : uno::Reference<drawing::XShape>
523 : 0 : ShapeFactory::createCylinder(
524 : : const uno::Reference<drawing::XShapes>& xTarget
525 : : , const drawing::Position3D& rPosition, const drawing::Direction3D& rSize
526 : : , sal_Int32 nRotateZAngleHundredthDegree )
527 : : {
528 : : return impl_createConeOrCylinder(
529 : 0 : xTarget, rPosition, rSize, 0.0, nRotateZAngleHundredthDegree, true );
530 : : }
531 : :
532 : : uno::Reference<drawing::XShape>
533 : 0 : ShapeFactory::createPyramid(
534 : : const uno::Reference<drawing::XShapes>& xTarget
535 : : , const drawing::Position3D& rPosition, const drawing::Direction3D& rSize
536 : : , double fTopHeight, bool bRotateZ
537 : : , const uno::Reference< beans::XPropertySet >& xSourceProp
538 : : , const tPropertyNameMap& rPropertyNameMap )
539 : : {
540 [ # # ]: 0 : if( !xTarget.is() )
541 [ # # ]: 0 : return 0;
542 : :
543 [ # # ]: 0 : Reference< drawing::XShapes > xGroup( ShapeFactory::createGroup3D( xTarget, rtl::OUString() ) );
544 : :
545 : 0 : sal_Bool bDoubleSided = false;
546 : 0 : short nRotatedTexture = 0;
547 : :
548 : 0 : const double fWidth = rSize.DirectionX;
549 : 0 : const double fDepth = rSize.DirectionZ;
550 : 0 : const double fHeight = rSize.DirectionY;
551 : :
552 : 0 : drawing::Position3D aBottomP1( rPosition.PositionX, rPosition.PositionY, rPosition.PositionZ - fDepth/2.0 );
553 [ # # ]: 0 : if(bRotateZ)
554 : 0 : aBottomP1.PositionY -= fWidth/2.0;
555 : : else
556 : 0 : aBottomP1.PositionX -= fWidth/2.0;
557 : 0 : drawing::Position3D aBottomP2( aBottomP1 );
558 [ # # ]: 0 : if(bRotateZ)
559 : 0 : aBottomP2.PositionY += fWidth;
560 : : else
561 : 0 : aBottomP2.PositionX += fWidth;
562 : 0 : drawing::Position3D aBottomP3( aBottomP2 );
563 : 0 : drawing::Position3D aBottomP4( aBottomP1 );
564 : 0 : aBottomP3.PositionZ += fDepth;
565 : 0 : aBottomP4.PositionZ += fDepth;
566 : :
567 : 0 : const double fTopFactor = (fTopHeight)/(fabs(fHeight)+fTopHeight);
568 : 0 : drawing::Position3D aTopP1( rPosition.PositionX, rPosition.PositionY, rPosition.PositionZ - fDepth*fTopFactor/2.0 );
569 [ # # ]: 0 : if(bRotateZ)
570 : : {
571 : 0 : aTopP1.PositionY -= fWidth*fTopFactor/2.0;
572 : 0 : aTopP1.PositionX += fHeight;
573 : : }
574 : : else
575 : : {
576 : 0 : aTopP1.PositionX -= fWidth*fTopFactor/2.0;
577 : 0 : aTopP1.PositionY += fHeight;
578 : : }
579 : 0 : drawing::Position3D aTopP2( aTopP1 );
580 [ # # ]: 0 : if(bRotateZ)
581 : 0 : aTopP2.PositionY += fWidth*fTopFactor;
582 : : else
583 : 0 : aTopP2.PositionX += fWidth*fTopFactor;
584 : 0 : drawing::Position3D aTopP3( aTopP2 );
585 : 0 : drawing::Position3D aTopP4( aTopP1 );
586 : 0 : aTopP3.PositionZ += fDepth*fTopFactor;
587 : 0 : aTopP4.PositionZ += fDepth*fTopFactor;
588 : :
589 [ # # ]: 0 : Stripe aStripeBottom( aBottomP1, aBottomP4, aBottomP3, aBottomP2 );
590 : :
591 : 0 : drawing::Position3D aNormalsBottomP1( aBottomP1 );
592 : 0 : drawing::Position3D aNormalsBottomP2( aBottomP2 );
593 : 0 : drawing::Position3D aNormalsBottomP3( aBottomP3 );
594 : 0 : drawing::Position3D aNormalsBottomP4( aBottomP4 );
595 : 0 : drawing::Position3D aNormalsTopP1( aBottomP1 );
596 : 0 : drawing::Position3D aNormalsTopP2( aBottomP2 );
597 : 0 : drawing::Position3D aNormalsTopP3( aBottomP3 );
598 : 0 : drawing::Position3D aNormalsTopP4( aBottomP4 );
599 [ # # ]: 0 : if( bRotateZ )
600 : : {
601 : 0 : aNormalsTopP1.PositionX += fHeight;
602 : 0 : aNormalsTopP2.PositionX += fHeight;
603 : 0 : aNormalsTopP3.PositionX += fHeight;
604 : 0 : aNormalsTopP4.PositionX += fHeight;
605 : : }
606 : : else
607 : : {
608 : 0 : aNormalsTopP1.PositionY += fHeight;
609 : 0 : aNormalsTopP2.PositionY += fHeight;
610 : 0 : aNormalsTopP3.PositionY += fHeight;
611 : 0 : aNormalsTopP4.PositionY += fHeight;
612 : : }
613 : :
614 : 0 : bool bInvertPolygon = false;
615 : 0 : bool bInvertNormals = false;
616 : :
617 [ # # ]: 0 : if(bRotateZ)
618 : : {
619 : : //bars
620 [ # # ]: 0 : if(fHeight>=0.0)
621 : : {
622 : 0 : nRotatedTexture = 2;
623 : 0 : bInvertNormals = true;
624 [ # # ]: 0 : aStripeBottom = Stripe( aBottomP1, aBottomP4, aBottomP3, aBottomP2 );
625 : : }
626 : : else
627 : : {
628 : 0 : bInvertPolygon = true;
629 : 0 : nRotatedTexture = 1;
630 [ # # ]: 0 : aStripeBottom = Stripe( aBottomP2, aBottomP3, aBottomP4, aBottomP1 );
631 : : }
632 : : }
633 : : else
634 : : {
635 : : //columns
636 [ # # ]: 0 : if(fHeight>=0.0)
637 : : {
638 : 0 : bInvertPolygon = true;
639 : 0 : nRotatedTexture = 2;
640 [ # # ]: 0 : aStripeBottom = Stripe( aBottomP2, aBottomP3, aBottomP4, aBottomP1 );
641 : : }
642 : : else
643 : : {
644 : 0 : nRotatedTexture = 3;
645 : 0 : bInvertNormals = true;
646 [ # # ]: 0 : aStripeBottom = Stripe( aBottomP4, aBottomP3, aBottomP2, aBottomP1 );
647 : : }
648 : : }
649 [ # # ]: 0 : aStripeBottom.InvertNormal(true);
650 : :
651 [ # # ]: 0 : Stripe aStripe1( aTopP2, aTopP1, aBottomP1, aBottomP2 );
652 [ # # ]: 0 : Stripe aStripe2( aTopP3, aTopP2, aBottomP2, aBottomP3 );
653 [ # # ]: 0 : Stripe aStripe3( aTopP4, aTopP3, aBottomP3, aBottomP4 );
654 [ # # ]: 0 : Stripe aStripe4( aTopP1, aTopP4, aBottomP4, aBottomP1 );
655 : :
656 [ # # ]: 0 : if( bInvertPolygon )
657 : : {
658 [ # # ]: 0 : aStripe1 = Stripe( aBottomP1, aTopP1, aTopP2, aBottomP2 );
659 [ # # ]: 0 : aStripe2 = Stripe( aBottomP2, aTopP2, aTopP3, aBottomP3 );
660 [ # # ]: 0 : aStripe3 = Stripe( aBottomP3, aTopP3, aTopP4, aBottomP4 );
661 [ # # ]: 0 : aStripe4 = Stripe( aBottomP4, aTopP4, aTopP1, aBottomP1 );
662 : : }
663 : :
664 [ # # ]: 0 : Stripe aNormalsStripe1( aNormalsTopP1, aNormalsBottomP1, aNormalsBottomP2, aNormalsTopP2 );
665 [ # # ]: 0 : Stripe aNormalsStripe2( aNormalsTopP2, aNormalsBottomP2, aNormalsBottomP3, aNormalsTopP3 );
666 [ # # ]: 0 : Stripe aNormalsStripe3( aNormalsTopP3, aNormalsBottomP3, aNormalsBottomP4, aNormalsTopP4 );
667 [ # # ]: 0 : Stripe aNormalsStripe4( aNormalsTopP4, aNormalsBottomP4, aNormalsBottomP1, aNormalsTopP1 );
668 : :
669 [ # # ]: 0 : if( bInvertNormals )
670 : : {
671 [ # # ]: 0 : aNormalsStripe1 = Stripe( aNormalsTopP2, aNormalsBottomP2, aNormalsBottomP1, aNormalsTopP1 );
672 [ # # ]: 0 : aNormalsStripe2 = Stripe( aNormalsTopP3, aNormalsBottomP3, aNormalsBottomP2, aNormalsTopP2 );
673 [ # # ]: 0 : aNormalsStripe3 = Stripe( aNormalsTopP4, aNormalsBottomP4, aNormalsBottomP3, aNormalsTopP3 );
674 [ # # ]: 0 : aNormalsStripe4 = Stripe( aNormalsTopP1, aNormalsBottomP1, aNormalsBottomP4, aNormalsTopP4 );
675 : : }
676 : :
677 [ # # ][ # # ]: 0 : aStripe1.SetManualNormal( aNormalsStripe1.getNormal() );
678 [ # # ][ # # ]: 0 : aStripe2.SetManualNormal( aNormalsStripe2.getNormal() );
679 [ # # ][ # # ]: 0 : aStripe3.SetManualNormal( aNormalsStripe3.getNormal() );
680 [ # # ][ # # ]: 0 : aStripe4.SetManualNormal( aNormalsStripe4.getNormal() );
681 : :
682 : 0 : const bool bFlatNormals = false;
683 [ # # ]: 0 : ShapeFactory::createStripe( xGroup, aStripe1, xSourceProp, rPropertyNameMap, bDoubleSided, nRotatedTexture, bFlatNormals );
684 [ # # ]: 0 : ShapeFactory::createStripe( xGroup, aStripe2, xSourceProp, rPropertyNameMap, bDoubleSided, nRotatedTexture, bFlatNormals );
685 [ # # ]: 0 : ShapeFactory::createStripe( xGroup, aStripe3, xSourceProp, rPropertyNameMap, bDoubleSided, nRotatedTexture, bFlatNormals );
686 [ # # ]: 0 : ShapeFactory::createStripe( xGroup, aStripe4, xSourceProp, rPropertyNameMap, bDoubleSided, nRotatedTexture, bFlatNormals );
687 [ # # ]: 0 : ShapeFactory::createStripe( xGroup, aStripeBottom, xSourceProp, rPropertyNameMap, bDoubleSided, nRotatedTexture, bFlatNormals );
688 : :
689 [ # # ]: 0 : return Reference< drawing::XShape >( xGroup, uno::UNO_QUERY );
690 : : }
691 : :
692 : : uno::Reference<drawing::XShape>
693 : 0 : ShapeFactory::createCone(
694 : : const uno::Reference<drawing::XShapes>& xTarget
695 : : , const drawing::Position3D& rPosition, const drawing::Direction3D& rSize
696 : : , double fTopHeight, sal_Int32 nRotateZAngleHundredthDegree )
697 : : {
698 : 0 : return impl_createConeOrCylinder( xTarget, rPosition, rSize, fTopHeight, nRotateZAngleHundredthDegree );
699 : : }
700 : :
701 : : uno::Reference<drawing::XShape>
702 : 0 : ShapeFactory::impl_createConeOrCylinder(
703 : : const uno::Reference<drawing::XShapes>& xTarget
704 : : , const drawing::Position3D& rPosition, const drawing::Direction3D& rSize
705 : : , double fTopHeight, sal_Int32 nRotateZAngleHundredthDegree
706 : : , bool bCylinder )
707 : : {
708 [ # # ]: 0 : if( !xTarget.is() )
709 [ # # ]: 0 : return 0;
710 : :
711 : : //create shape
712 : : uno::Reference< drawing::XShape > xShape(
713 [ # # ]: 0 : m_xShapeFactory->createInstance( C2U(
714 [ # # ][ # # ]: 0 : "com.sun.star.drawing.Shape3DLatheObject") ), uno::UNO_QUERY );
[ # # ]
715 [ # # ][ # # ]: 0 : xTarget->add(xShape);
716 : :
717 : 0 : double fWidth = rSize.DirectionX/2.0; //The depth will be corrrected within Matrix
718 : 0 : double fRadius = fWidth; //!!!!!!!! problem in drawing layer: rotation object calculates wrong needed size -> wrong camera (it's a problem with bounding boxes)
719 : 0 : double fHeight = rSize.DirectionY;
720 : :
721 : : //set properties
722 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
723 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
724 [ # # ]: 0 : if( xProp.is())
725 : : {
726 : : try
727 : : {
728 : : //PercentDiagonal
729 : 0 : sal_Int16 nPercentDiagonal = 5;
730 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_PERCENT_DIAGONAL )
731 [ # # ][ # # ]: 0 : , uno::makeAny( nPercentDiagonal ) );
[ # # ]
732 : :
733 : : //Polygon
734 : 0 : sal_Int32 nVerticalSegmentCount = 0;
735 : : uno::Any aPPolygon = bCylinder ? createPolyPolygon_Cylinder(
736 : : fHeight, fRadius, nVerticalSegmentCount)
737 : : : createPolyPolygon_Cone(
738 [ # # ][ # # ]: 0 : fHeight, fRadius, fTopHeight, nVerticalSegmentCount);
[ # # ]
739 [ # # ][ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_POLYPOLYGON3D ), aPPolygon );
[ # # ]
740 : :
741 : : //Matrix for position
742 : : {
743 [ # # ]: 0 : ::basegfx::B3DHomMatrix aM;
744 [ # # ]: 0 : if(nRotateZAngleHundredthDegree!=0)
745 [ # # ]: 0 : aM.rotate(0.0,0.0,-nRotateZAngleHundredthDegree/18000.00*F_PI);
746 : : //stretch the symmetric objects to given depth
747 [ # # ]: 0 : aM.scale(1.0,1.0,rSize.DirectionZ/rSize.DirectionX);
748 [ # # ]: 0 : aM.translate(rPosition.PositionX, rPosition.PositionY, rPosition.PositionZ);
749 [ # # ]: 0 : drawing::HomogenMatrix aHM = B3DHomMatrixToHomogenMatrix(aM);
750 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_TRANSFORM_MATRIX )
751 [ # # ][ # # ]: 0 : , uno::makeAny(aHM) );
[ # # ][ # # ]
752 : : }
753 : :
754 : : //Segments
755 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_HORZ_SEGS )
756 [ # # ][ # # ]: 0 : , uno::makeAny(CHART_3DOBJECT_SEGMENTCOUNT) );
[ # # ]
757 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_VERT_SEGS )
758 [ # # ][ # # ]: 0 : , uno::makeAny((sal_Int32)nVerticalSegmentCount) );//depends on point count of the used polygon
[ # # ]
759 : :
760 : : //Reduced lines
761 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_REDUCED_LINE_GEOMETRY )
762 [ # # ][ # # ]: 0 : , uno::makeAny((sal_Bool)sal_True) );
[ # # ][ # # ]
763 : : }
764 [ # # ]: 0 : catch( const uno::Exception& e )
765 : : {
766 : : ASSERT_EXCEPTION( e );
767 : : }
768 : : }
769 : 0 : return xShape;
770 : : }
771 : :
772 : : //------------------------------------------------------------------------------------------------------------
773 : : //------------------------------------------------------------------------------------------------------------
774 : : //------------------------------------------------------------------------------------------------------------
775 : :
776 : 152 : void appendAndCloseBezierCoords( drawing::PolyPolygonBezierCoords& rReturn, const drawing::PolyPolygonBezierCoords& rAdd, sal_Bool bAppendInverse )
777 : : {
778 [ - + ]: 152 : if(!rAdd.Coordinates.getLength())
779 : 0 : return;
780 : 152 : sal_Int32 nAddCount = rAdd.Coordinates[0].getLength();
781 [ - + ]: 152 : if(!nAddCount)
782 : 0 : return;
783 : :
784 : 152 : sal_Int32 nOldCount = rReturn.Coordinates[0].getLength();
785 : :
786 : 152 : rReturn.Coordinates[0].realloc(nOldCount+nAddCount+1);
787 : 152 : rReturn.Flags[0].realloc(nOldCount+nAddCount+1);
788 : :
789 [ + + ]: 3040 : for(sal_Int32 nN=0;nN<nAddCount; nN++ )
790 : : {
791 [ + - ]: 2888 : sal_Int32 nAdd = bAppendInverse ? (nAddCount-1-nN) : nN;
792 : 2888 : rReturn.Coordinates[0][nOldCount+nN] = rAdd.Coordinates[0][nAdd];
793 : 2888 : rReturn.Flags[0][nOldCount+nN] = rAdd.Flags[0][nAdd];
794 : : }
795 : :
796 : : //close
797 : 152 : rReturn.Coordinates[0][nOldCount+nAddCount] = rReturn.Coordinates[0][0];
798 : 152 : rReturn.Flags[0][nOldCount+nAddCount] = rReturn.Flags[0][0];
799 : : }
800 : :
801 : : //------------------------------------------------------------------------------------------------------------
802 : :
803 : 304 : drawing::PolyPolygonBezierCoords getCircularArcBezierCoords(
804 : : double fStartAngleRadian, double fWidthAngleRadian, double fUnitRadius
805 : : , const ::basegfx::B2DHomMatrix& rTransformationFromUnitCircle
806 : : , const double fAngleSubdivisionRadian )
807 : : {
808 : : //at least one polygon is created using two normal and two control points
809 : : //if the angle is larger it is separated into multiple sub angles
810 : :
811 [ + - ]: 304 : drawing::PolyPolygonBezierCoords aReturn = drawing::PolyPolygonBezierCoords();
812 : 304 : sal_Int32 nSegmentCount = static_cast< sal_Int32 >( fWidthAngleRadian/fAngleSubdivisionRadian );
813 [ + - ]: 304 : if( fWidthAngleRadian > fAngleSubdivisionRadian*nSegmentCount )
814 : 304 : nSegmentCount++;
815 : :
816 : 304 : double fFirstSegmentAngle = fAngleSubdivisionRadian;
817 : 304 : double fLastSegmentAngle = fAngleSubdivisionRadian;
818 [ - + ]: 304 : if(nSegmentCount==1)
819 : : {
820 : 0 : fFirstSegmentAngle = fWidthAngleRadian;
821 : 0 : fLastSegmentAngle = 0.0;
822 : : }
823 : : else
824 : : {
825 : 304 : double fFirstAngleOnSubDevision = (static_cast<sal_Int32>(fStartAngleRadian/fAngleSubdivisionRadian)+1)*fAngleSubdivisionRadian;
826 [ + - ]: 304 : if( !::rtl::math::approxEqual( fStartAngleRadian, fFirstAngleOnSubDevision ) )
827 : 304 : fFirstSegmentAngle = fFirstAngleOnSubDevision-fStartAngleRadian;
828 : :
829 [ + - ]: 304 : if(nSegmentCount>1)
830 : : {
831 : 304 : fLastSegmentAngle = fWidthAngleRadian-fFirstSegmentAngle-fAngleSubdivisionRadian*(nSegmentCount-2);
832 [ - + ]: 304 : if( fLastSegmentAngle<0 )
833 : 0 : nSegmentCount--;
834 [ + + ]: 304 : if( fLastSegmentAngle>fAngleSubdivisionRadian )
835 : : {
836 : 152 : fLastSegmentAngle-=fAngleSubdivisionRadian;
837 : 152 : nSegmentCount++;
838 : : }
839 : : }
840 : : }
841 : :
842 : 304 : sal_Int32 nPointCount = 1 + 3*nSegmentCount; //first point of next segment equals last point of former segment
843 : :
844 [ + - ][ + - ]: 304 : aReturn.Coordinates = drawing::PointSequenceSequence(1);
[ + - ]
845 [ + - ][ + - ]: 304 : aReturn.Flags = drawing::FlagSequenceSequence(1);
[ + - ]
846 : :
847 [ + - ]: 304 : drawing::PointSequence aPoints(nPointCount);
848 [ + - ]: 304 : drawing::FlagSequence aFlags(nPointCount);
849 : :
850 : : //
851 : :
852 : : //!! applying matrix to vector does ignore translation, so it is important to use a B2DPoint here instead of B2DVector
853 : 304 : ::basegfx::B2DPoint P0,P1,P2,P3;
854 [ + - ]: 304 : ::basegfx::B2DPoint POrigin = rTransformationFromUnitCircle * ::basegfx::B2DPoint(0.0, 0.0);
855 : :
856 : 304 : sal_Int32 nPoint=0;
857 : 304 : double fCurrentRotateAngle = fStartAngleRadian;
858 [ + + ]: 2128 : for(sal_Int32 nSegment=0; nSegment<nSegmentCount; nSegment++)
859 : : {
860 : 1824 : double fCurrentSegmentAngle = fAngleSubdivisionRadian;
861 [ + + ]: 1824 : if(nSegment==0)//first segment gets only a smaller peace until the next subdevision
862 : 304 : fCurrentSegmentAngle = fFirstSegmentAngle;
863 [ + + ]: 1520 : else if(nSegment==(nSegmentCount-1)) //the last segment gets the rest angle that does not fit into equal pieces
864 : 304 : fCurrentSegmentAngle = fLastSegmentAngle;
865 : :
866 : : //first create untransformed points for a unit circle arc:
867 : 1824 : const double fCos = cos(fCurrentSegmentAngle/2.0);
868 : 1824 : const double fSin = sin(fCurrentSegmentAngle/2.0);
869 : 1824 : P0.setX(fCos);
870 : 1824 : P3.setX(fCos);
871 : 1824 : P0.setY(-fSin);
872 : 1824 : P3.setY(-P0.getY());
873 : :
874 : 1824 : P1.setX((4.0-fCos)/3.0);
875 : 1824 : P2.setX(P1.getX());
876 : 1824 : P1.setY((1.0-fCos)*(fCos-3.0)/(3.0*fSin));
877 : 1824 : P2.setY(-P1.getY());
878 : : //transform thus startangle equals NULL
879 [ + - ]: 1824 : ::basegfx::B2DHomMatrix aStart;
880 [ + - ]: 1824 : aStart.rotate(fCurrentSegmentAngle/2.0 + fCurrentRotateAngle );
881 : 1824 : fCurrentRotateAngle+=fCurrentSegmentAngle;
882 : :
883 [ + - ]: 1824 : aStart.scale( fUnitRadius, fUnitRadius );
884 : :
885 : : //apply given transformation to get final points
886 [ + - ][ + - ]: 1824 : P0 = rTransformationFromUnitCircle*(aStart*P0);
887 [ + - ][ + - ]: 1824 : P1 = rTransformationFromUnitCircle*(aStart*P1);
888 [ + - ][ + - ]: 1824 : P2 = rTransformationFromUnitCircle*(aStart*P2);
889 [ + - ][ + - ]: 1824 : P3 = rTransformationFromUnitCircle*(aStart*P3);
890 : :
891 [ + - ]: 1824 : aPoints[nPoint].X = static_cast< sal_Int32 >( P0.getX());
892 [ + - ]: 1824 : aPoints[nPoint].Y = static_cast< sal_Int32 >( P0.getY());
893 [ + - ]: 1824 : aFlags [nPoint++] = drawing::PolygonFlags_NORMAL;
894 : :
895 [ + - ]: 1824 : aPoints[nPoint].X = static_cast< sal_Int32 >( P1.getX());
896 [ + - ]: 1824 : aPoints[nPoint].Y = static_cast< sal_Int32 >( P1.getY());
897 [ + - ]: 1824 : aFlags[nPoint++] = drawing::PolygonFlags_CONTROL;
898 : :
899 [ + - ]: 1824 : aPoints[nPoint].X = static_cast< sal_Int32 >( P2.getX());
900 [ + - ]: 1824 : aPoints[nPoint].Y = static_cast< sal_Int32 >( P2.getY());
901 [ + - ]: 1824 : aFlags [nPoint++] = drawing::PolygonFlags_CONTROL;
902 : :
903 [ + + ]: 1824 : if(nSegment==(nSegmentCount-1))
904 : : {
905 [ + - ]: 304 : aPoints[nPoint].X = static_cast< sal_Int32 >( P3.getX());
906 [ + - ]: 304 : aPoints[nPoint].Y = static_cast< sal_Int32 >( P3.getY());
907 [ + - ]: 304 : aFlags [nPoint++] = drawing::PolygonFlags_NORMAL;
908 : : }
909 [ + - ]: 1824 : }
910 : :
911 [ + - ][ + - ]: 304 : aReturn.Coordinates[0] = aPoints;
912 [ + - ][ + - ]: 304 : aReturn.Flags[0] = aFlags;
913 : :
914 [ + - ][ + - ]: 304 : return aReturn;
915 : : }
916 : :
917 : : //------------------------------------------------------------------------------------------------------------
918 : :
919 : 152 : drawing::PolyPolygonBezierCoords getRingBezierCoords(
920 : : double fUnitCircleInnerRadius
921 : : , double fUnitCircleOuterRadius
922 : : , double fStartAngleRadian, double fWidthAngleRadian
923 : : , ::basegfx::B2DHomMatrix aTransformationFromUnitCircle
924 : : , const double fAngleSubdivisionRadian )
925 : : {
926 [ + - ]: 152 : drawing::PolyPolygonBezierCoords aReturn = drawing::PolyPolygonBezierCoords();
927 : :
928 [ + - ][ + - ]: 152 : aReturn.Coordinates = drawing::PointSequenceSequence(1);
[ + - ]
929 [ + - ][ + - ]: 152 : aReturn.Flags = drawing::FlagSequenceSequence(1);
[ + - ]
930 : :
931 : : drawing::PolyPolygonBezierCoords aOuterArc = getCircularArcBezierCoords(
932 [ + - ]: 152 : fStartAngleRadian, fWidthAngleRadian, fUnitCircleOuterRadius, aTransformationFromUnitCircle, fAngleSubdivisionRadian );
933 [ + - ][ + - ]: 152 : aReturn.Coordinates[0] = aOuterArc.Coordinates[0];
[ + - ]
934 [ + - ][ + - ]: 152 : aReturn.Flags[0] = aOuterArc.Flags[0];
[ + - ]
935 : :
936 : : drawing::PolyPolygonBezierCoords aInnerArc = getCircularArcBezierCoords(
937 [ + - ]: 152 : fStartAngleRadian, fWidthAngleRadian, fUnitCircleInnerRadius, aTransformationFromUnitCircle, fAngleSubdivisionRadian );
938 [ + - ]: 152 : appendAndCloseBezierCoords( aReturn, aInnerArc, sal_True );
939 : :
940 [ + - ][ + - ]: 152 : return aReturn;
941 : : }
942 : :
943 : : //------------------------------------------------------------------------------------------------------------
944 : :
945 : : uno::Reference< drawing::XShape >
946 : 152 : ShapeFactory::createPieSegment2D(
947 : : const uno::Reference< drawing::XShapes >& xTarget
948 : : , double fUnitCircleStartAngleDegree, double fUnitCircleWidthAngleDegree
949 : : , double fUnitCircleInnerRadius, double fUnitCircleOuterRadius
950 : : , const drawing::Direction3D& rOffset
951 : : , const drawing::HomogenMatrix& rUnitCircleToScene )
952 : : {
953 [ - + ]: 152 : if( !xTarget.is() )
954 [ # # ]: 0 : return 0;
955 : :
956 [ - + ]: 152 : while(fUnitCircleWidthAngleDegree>360)
957 : 0 : fUnitCircleWidthAngleDegree -= 360.0;
958 [ - + ]: 152 : while(fUnitCircleWidthAngleDegree<0)
959 : 0 : fUnitCircleWidthAngleDegree += 360.0;
960 : :
961 : : //create shape
962 : : uno::Reference< drawing::XShape > xShape(
963 [ + - ]: 152 : m_xShapeFactory->createInstance(
964 [ + - ][ + - ]: 152 : C2U("com.sun.star.drawing.ClosedBezierShape") ), uno::UNO_QUERY );
[ + - ]
965 [ + - ][ + - ]: 152 : xTarget->add(xShape); //need to add the shape before setting of properties
966 : :
967 : : //set properties
968 [ + - ]: 152 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
969 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
970 [ + - ]: 152 : if( xProp.is())
971 : : {
972 : : try
973 : : {
974 [ + - ][ + - ]: 152 : ::basegfx::B2DHomMatrix aTransformationFromUnitCircle( IgnoreZ( HomogenMatrixToB3DHomMatrix(rUnitCircleToScene) ) );
[ + - ]
975 [ + - ]: 152 : aTransformationFromUnitCircle.translate(rOffset.DirectionX,rOffset.DirectionY);
976 : :
977 : 152 : const double fAngleSubdivisionRadian = F_PI/10.0;
978 : :
979 : : drawing::PolyPolygonBezierCoords aCoords = getRingBezierCoords(
980 : : fUnitCircleInnerRadius, fUnitCircleOuterRadius
981 : : , fUnitCircleStartAngleDegree*F_PI/180.0, fUnitCircleWidthAngleDegree*F_PI/180.0
982 [ + - ][ + - ]: 152 : , aTransformationFromUnitCircle, fAngleSubdivisionRadian );
[ + - ]
983 : :
984 [ + - ][ + - ]: 152 : xProp->setPropertyValue( C2U( "PolyPolygonBezier" ), uno::makeAny( aCoords ) );
[ + - ][ + - ]
[ + - ][ + - ]
[ # # ]
985 : : }
986 [ # # ]: 0 : catch( const uno::Exception& e )
987 : : {
988 : : ASSERT_EXCEPTION( e );
989 : : }
990 : : }
991 : :
992 : 152 : return xShape;
993 : : }
994 : :
995 : : //------------------------------------------------------------------------------------------------------------
996 : :
997 : : uno::Reference< drawing::XShape >
998 : 0 : ShapeFactory::createPieSegment(
999 : : const uno::Reference< drawing::XShapes >& xTarget
1000 : : , double fUnitCircleStartAngleDegree, double fUnitCircleWidthAngleDegree
1001 : : , double fUnitCircleInnerRadius, double fUnitCircleOuterRadius
1002 : : , const drawing::Direction3D& rOffset
1003 : : , const drawing::HomogenMatrix& rUnitCircleToScene
1004 : : , double fDepth )
1005 : : {
1006 [ # # ]: 0 : if( !xTarget.is() )
1007 [ # # ]: 0 : return 0;
1008 : :
1009 [ # # ]: 0 : while(fUnitCircleWidthAngleDegree>360)
1010 : 0 : fUnitCircleWidthAngleDegree -= 360.0;
1011 [ # # ]: 0 : while(fUnitCircleWidthAngleDegree<0)
1012 : 0 : fUnitCircleWidthAngleDegree += 360.0;
1013 : :
1014 : : //create shape
1015 : : uno::Reference< drawing::XShape > xShape(
1016 [ # # ]: 0 : m_xShapeFactory->createInstance( C2U(
1017 [ # # ][ # # ]: 0 : "com.sun.star.drawing.Shape3DExtrudeObject") ), uno::UNO_QUERY );
[ # # ]
1018 [ # # ][ # # ]: 0 : xTarget->add(xShape); //need to add the shape before setting of properties
1019 : :
1020 : : //set properties
1021 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
1022 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
1023 [ # # ]: 0 : if( xProp.is())
1024 : : {
1025 : : try
1026 : : {
1027 [ # # ][ # # ]: 0 : ::basegfx::B2DHomMatrix aTransformationFromUnitCircle( IgnoreZ( HomogenMatrixToB3DHomMatrix(rUnitCircleToScene) ) );
[ # # ]
1028 [ # # ]: 0 : aTransformationFromUnitCircle.translate(rOffset.DirectionX,rOffset.DirectionY);
1029 : :
1030 : 0 : const double fAngleSubdivisionRadian = F_PI/32.0;
1031 : :
1032 : : drawing::PolyPolygonBezierCoords aCoords = getRingBezierCoords(
1033 : : fUnitCircleInnerRadius, fUnitCircleOuterRadius
1034 : : , fUnitCircleStartAngleDegree*F_PI/180.0, fUnitCircleWidthAngleDegree*F_PI/180.0
1035 [ # # ][ # # ]: 0 : , aTransformationFromUnitCircle, fAngleSubdivisionRadian );
[ # # ]
1036 : :
1037 : : //depth
1038 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_EXTRUDE_DEPTH )
1039 [ # # ][ # # ]: 0 : , uno::makeAny((sal_Int32)fDepth) );
[ # # ]
1040 : :
1041 : : //PercentDiagonal
1042 : 0 : sal_Int16 nPercentDiagonal = 0;
1043 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_PERCENT_DIAGONAL )
1044 [ # # ][ # # ]: 0 : , uno::makeAny( nPercentDiagonal ) );
[ # # ]
1045 : :
1046 : : //Polygon
1047 [ # # ]: 0 : drawing::PolyPolygonShape3D aPoly( BezierToPoly(aCoords) );
1048 [ # # ]: 0 : ShapeFactory::closePolygon( aPoly );
1049 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_POLYPOLYGON3D )
1050 [ # # ][ # # ]: 0 : , uno::makeAny( aPoly ) );
[ # # ]
1051 : :
1052 : : //DoubleSided
1053 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_DOUBLE_SIDED )
1054 [ # # ][ # # ]: 0 : , uno::makeAny( (sal_Bool)true) );
[ # # ]
1055 : :
1056 : : //Reduced lines
1057 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_REDUCED_LINE_GEOMETRY )
1058 [ # # ][ # # ]: 0 : , uno::makeAny((sal_Bool)sal_True) );
[ # # ]
1059 : :
1060 : : //TextureProjectionMode
1061 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_TEXTURE_PROJ_Y )
1062 [ # # ][ # # ]: 0 : , uno::makeAny( drawing::TextureProjectionMode_OBJECTSPECIFIC ) );
[ # # ]
1063 : :
1064 : : //TextureProjectionMode
1065 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_TEXTURE_PROJ_X )
1066 [ # # ][ # # ]: 0 : , uno::makeAny( drawing::TextureProjectionMode_PARALLEL ) );
[ # # ]
1067 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_TEXTURE_PROJ_Y )
1068 [ # # ][ # # ]: 0 : , uno::makeAny( drawing::TextureProjectionMode_OBJECTSPECIFIC ) );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1069 : : }
1070 [ # # ]: 0 : catch( const uno::Exception& e )
1071 : : {
1072 : : ASSERT_EXCEPTION( e );
1073 : : }
1074 : : }
1075 : 0 : return xShape;
1076 : : }
1077 : :
1078 : : //------------------------------------------------------------------------------------------------------------
1079 : : //------------------------------------------------------------------------------------------------------------
1080 : : //------------------------------------------------------------------------------------------------------------
1081 : :
1082 : : uno::Reference< drawing::XShape >
1083 : 438 : ShapeFactory::createStripe( const uno::Reference< drawing::XShapes >& xTarget
1084 : : , const Stripe& rStripe
1085 : : , const uno::Reference< beans::XPropertySet >& xSourceProp
1086 : : , const tPropertyNameMap& rPropertyNameMap
1087 : : , sal_Bool bDoubleSided
1088 : : , short nRotatedTexture
1089 : : , bool bFlatNormals )
1090 : : {
1091 [ - + ]: 438 : if( !xTarget.is() )
1092 [ # # ]: 0 : return 0;
1093 : :
1094 : : //create shape
1095 : : uno::Reference< drawing::XShape > xShape(
1096 [ + - ]: 438 : m_xShapeFactory->createInstance( C2U(
1097 [ + - ][ + - ]: 438 : "com.sun.star.drawing.Shape3DPolygonObject" ) ), uno::UNO_QUERY );
[ + - ]
1098 [ + - ][ + - ]: 438 : xTarget->add(xShape);
1099 : :
1100 : : //set properties
1101 [ + - ]: 438 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
1102 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
1103 [ + - ]: 438 : if( xProp.is())
1104 : : {
1105 : : try
1106 : : {
1107 : : //Polygon
1108 [ + - ]: 438 : xProp->setPropertyValue( C2U( UNO_NAME_3D_POLYPOLYGON3D )
1109 [ + - ][ + - ]: 438 : , rStripe.getPolyPolygonShape3D() );
[ + - ]
1110 : :
1111 : : //TexturePolygon
1112 [ + - ]: 438 : xProp->setPropertyValue( C2U( UNO_NAME_3D_TEXTUREPOLYGON3D )
1113 [ + - ][ + - ]: 438 : , rStripe.getTexturePolygon( nRotatedTexture ) );
[ + - ]
1114 : :
1115 : : //Normals Polygon
1116 [ + - ]: 438 : xProp->setPropertyValue( C2U( UNO_NAME_3D_NORMALSPOLYGON3D )
1117 [ + - ][ + - ]: 438 : , rStripe.getNormalsPolygon() );
[ + - ]
1118 : : //NormalsKind
1119 [ + - ]: 438 : if(bFlatNormals)
1120 [ + - ]: 438 : xProp->setPropertyValue( C2U( UNO_NAME_3D_NORMALS_KIND )
1121 [ + - ][ + - ]: 438 : , uno::makeAny( drawing::NormalsKind_FLAT ) );
[ + - ]
1122 : :
1123 : : //LineOnly
1124 [ + - ]: 438 : xProp->setPropertyValue( C2U( UNO_NAME_3D_LINEONLY )
1125 [ + - ][ + - ]: 438 : , uno::makeAny( (sal_Bool)false) );
[ + - ]
1126 : :
1127 : : //DoubleSided
1128 [ + - ]: 438 : xProp->setPropertyValue( C2U( UNO_NAME_3D_DOUBLE_SIDED )
1129 [ + - ][ + - ]: 438 : , uno::makeAny(bDoubleSided) );
[ + - ][ # # ]
1130 : :
1131 [ + - ]: 438 : if( xSourceProp.is())
1132 [ + - ]: 438 : PropertyMapper::setMappedProperties( xProp, xSourceProp, rPropertyNameMap );
1133 : : }
1134 [ # # ]: 0 : catch( const uno::Exception& e )
1135 : : {
1136 : : ASSERT_EXCEPTION( e );
1137 : : }
1138 : : }
1139 : 438 : return xShape;
1140 : : }
1141 : :
1142 : : uno::Reference< drawing::XShape >
1143 : 0 : ShapeFactory::createArea3D( const uno::Reference< drawing::XShapes >& xTarget
1144 : : , const drawing::PolyPolygonShape3D& rPolyPolygon
1145 : : , double fDepth )
1146 : : {
1147 [ # # ]: 0 : if( !xTarget.is() )
1148 [ # # ]: 0 : return 0;
1149 : :
1150 [ # # ]: 0 : if( !rPolyPolygon.SequenceX.getLength())
1151 [ # # ]: 0 : return 0;
1152 : :
1153 : : //create shape
1154 : : uno::Reference< drawing::XShape > xShape(
1155 [ # # ]: 0 : m_xShapeFactory->createInstance( C2U(
1156 [ # # ][ # # ]: 0 : "com.sun.star.drawing.Shape3DExtrudeObject") ), uno::UNO_QUERY );
[ # # ]
1157 [ # # ][ # # ]: 0 : xTarget->add(xShape);
1158 : :
1159 : : //set properties
1160 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
1161 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
1162 [ # # ]: 0 : if( xProp.is())
1163 : : {
1164 : : try
1165 : : {
1166 : : //depth
1167 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_EXTRUDE_DEPTH )
1168 [ # # ][ # # ]: 0 : , uno::makeAny((sal_Int32)fDepth) );
[ # # ]
1169 : :
1170 : : //PercentDiagonal
1171 : 0 : sal_Int16 nPercentDiagonal = 0;
1172 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_PERCENT_DIAGONAL )
1173 [ # # ][ # # ]: 0 : , uno::makeAny( nPercentDiagonal ) );
[ # # ]
1174 : :
1175 : : //Polygon
1176 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_POLYPOLYGON3D )
1177 [ # # ][ # # ]: 0 : , uno::makeAny( rPolyPolygon ) );
[ # # ]
1178 : :
1179 : : //DoubleSided
1180 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_DOUBLE_SIDED )
1181 [ # # ][ # # ]: 0 : , uno::makeAny( (sal_Bool)true) );
[ # # ]
1182 : :
1183 : : //the z component of the polygon is now ignored by the drawing layer,
1184 : : //so we nned to translate the object via transformation matrix
1185 : :
1186 : : //Matrix for position
1187 [ # # ][ # # ]: 0 : if( rPolyPolygon.SequenceZ.getLength()&& rPolyPolygon.SequenceZ[0].getLength() )
[ # # ]
1188 : : {
1189 [ # # ]: 0 : ::basegfx::B3DHomMatrix aM;
1190 : : aM.translate( 0
1191 : : , 0
1192 [ # # ]: 0 : , rPolyPolygon.SequenceZ[0][0] );
1193 [ # # ]: 0 : drawing::HomogenMatrix aHM = B3DHomMatrixToHomogenMatrix(aM);
1194 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_TRANSFORM_MATRIX )
1195 [ # # ][ # # ]: 0 : , uno::makeAny(aHM) );
[ # # ][ # # ]
[ # # ]
1196 : : }
1197 : : }
1198 [ # # ]: 0 : catch( const uno::Exception& e )
1199 : : {
1200 : : ASSERT_EXCEPTION( e );
1201 : : }
1202 : : }
1203 : 0 : return xShape;
1204 : : }
1205 : :
1206 : : uno::Reference< drawing::XShape >
1207 : 10915 : ShapeFactory::createArea2D( const uno::Reference< drawing::XShapes >& xTarget
1208 : : , const drawing::PolyPolygonShape3D& rPolyPolygon )
1209 : : {
1210 [ - + ]: 10915 : if( !xTarget.is() )
1211 [ # # ]: 0 : return 0;
1212 : :
1213 : : //create shape
1214 : : uno::Reference< drawing::XShape > xShape(
1215 [ + - ]: 10915 : m_xShapeFactory->createInstance( C2U(
1216 [ + - ][ + - ]: 10915 : "com.sun.star.drawing.PolyPolygonShape") ), uno::UNO_QUERY );
[ + - ]
1217 [ + - ][ + - ]: 10915 : xTarget->add(xShape);
1218 : :
1219 : : //set properties
1220 [ + - ]: 10915 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
1221 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
1222 [ + - ]: 10915 : if( xProp.is())
1223 : : {
1224 : : try
1225 : : {
1226 : : //UNO_NAME_POLYGON "Polygon" drawing::PointSequence*
1227 [ + - ]: 10915 : drawing::PointSequenceSequence aPoints( PolyToPointSequence(rPolyPolygon) );
1228 : :
1229 : : //Polygon
1230 [ + - ]: 10915 : xProp->setPropertyValue( C2U( UNO_NAME_POLYPOLYGON )
1231 [ + - ][ + - ]: 10915 : , uno::makeAny( aPoints ) );
[ + - ]
1232 : :
1233 : : //ZOrder
1234 : : //an area should always be behind other shapes
1235 [ + - ]: 10915 : xProp->setPropertyValue( C2U( UNO_NAME_MISC_OBJ_ZORDER )
1236 [ + - ][ + - ]: 10915 : , uno::makeAny( sal_Int32(0) ) );
[ + - ][ + - ]
[ # # ]
1237 : : }
1238 [ # # ]: 0 : catch( const uno::Exception& e )
1239 : : {
1240 : : ASSERT_EXCEPTION( e );
1241 : : }
1242 : : }
1243 : 10915 : return xShape;
1244 : : }
1245 : :
1246 : : enum SymbolType { SYMBOL_SQUARE=0
1247 : : , SYMBOL_DIAMOND
1248 : : , SYMBOL_ARROW_DOWN
1249 : : , SYMBOL_ARROW_UP
1250 : : , SYMBOL_ARROW_RIGHT
1251 : : , SYMBOL_ARROW_LEFT
1252 : : , SYMBOL_BOWTIE
1253 : : , SYMBOL_SANDGLASS
1254 : : , SYMBOL_CIRCLE
1255 : : , SYMBOL_STAR
1256 : : , SYMBOL_X
1257 : : , SYMBOL_PLUS
1258 : : , SYMBOL_ASTERISK
1259 : : , SYMBOL_HORIZONTAL_BAR
1260 : : , SYMBOL_VERTICAL_BAR
1261 : : , SYMBOL_COUNT
1262 : : };
1263 : :
1264 : 0 : sal_Int32 ShapeFactory::getSymbolCount()
1265 : : {
1266 : 0 : return SYMBOL_COUNT;
1267 : : }
1268 : :
1269 : 0 : drawing::PolyPolygonShape3D createPolyPolygon_Symbol( const drawing::Position3D& rPos
1270 : : , const drawing::Direction3D& rSize
1271 : : , sal_Int32 nStandardSymbol )
1272 : : {
1273 [ # # ]: 0 : if(nStandardSymbol<0)
1274 : 0 : nStandardSymbol*=-1;
1275 : 0 : nStandardSymbol = nStandardSymbol%ShapeFactory::getSymbolCount();
1276 : 0 : SymbolType eSymbolType=static_cast<SymbolType>(nStandardSymbol);
1277 : :
1278 : 0 : const double& fX = rPos.PositionX;
1279 : 0 : const double& fY = rPos.PositionY;
1280 : :
1281 : 0 : const double fWidthH = rSize.DirectionX/2.0; //fWidthH stands for Half Width
1282 : 0 : const double fHeightH = rSize.DirectionY/2.0; //fHeightH stands for Half Height
1283 : :
1284 : 0 : const sal_Int32 nQuarterCount = 35; // points inside a quadrant, used in case circle
1285 : :
1286 : 0 : sal_Int32 nPointCount = 4; //all arrow symbols only need 4 points
1287 [ # # # # : 0 : switch( eSymbolType )
# # # ]
1288 : : {
1289 : : case SYMBOL_SQUARE:
1290 : : case SYMBOL_DIAMOND:
1291 : : case SYMBOL_BOWTIE:
1292 : : case SYMBOL_SANDGLASS:
1293 : : case SYMBOL_HORIZONTAL_BAR:
1294 : : case SYMBOL_VERTICAL_BAR:
1295 : 0 : nPointCount = 5;
1296 : 0 : break;
1297 : : case SYMBOL_X:
1298 : 0 : nPointCount = 13;
1299 : 0 : break;
1300 : : case SYMBOL_PLUS:
1301 : 0 : nPointCount = 13;
1302 : 0 : break;
1303 : : case SYMBOL_STAR:
1304 : 0 : nPointCount = 9;
1305 : 0 : break;
1306 : : case SYMBOL_ASTERISK:
1307 : 0 : nPointCount = 19;
1308 : 0 : break;
1309 : : case SYMBOL_CIRCLE:
1310 : 0 : nPointCount = 5 + 4 * nQuarterCount;
1311 : 0 : break;
1312 : : default:
1313 : 0 : break;
1314 : : }
1315 : :
1316 : : //--------------------------------------
1317 : 0 : drawing::PolyPolygonShape3D aPP;
1318 : :
1319 [ # # ]: 0 : aPP.SequenceX.realloc(1);
1320 [ # # ]: 0 : aPP.SequenceY.realloc(1);
1321 [ # # ]: 0 : aPP.SequenceZ.realloc(1);
1322 : :
1323 [ # # ]: 0 : drawing::DoubleSequence* pOuterSequenceX = aPP.SequenceX.getArray();
1324 [ # # ]: 0 : drawing::DoubleSequence* pOuterSequenceY = aPP.SequenceY.getArray();
1325 [ # # ]: 0 : drawing::DoubleSequence* pOuterSequenceZ = aPP.SequenceZ.getArray();
1326 : :
1327 [ # # ]: 0 : pOuterSequenceX->realloc(nPointCount);
1328 [ # # ]: 0 : pOuterSequenceY->realloc(nPointCount);
1329 [ # # ]: 0 : pOuterSequenceZ->realloc(nPointCount);
1330 : :
1331 [ # # ]: 0 : double* pInnerSequenceX = pOuterSequenceX->getArray();
1332 [ # # ]: 0 : double* pInnerSequenceY = pOuterSequenceY->getArray();
1333 [ # # ]: 0 : double* pInnerSequenceZ = pOuterSequenceZ->getArray();
1334 : :
1335 [ # # ]: 0 : for(sal_Int32 nN = nPointCount; nN--;)
1336 : 0 : *pInnerSequenceZ++ = 0.0;
1337 : :
1338 [ # # # # : 0 : switch(eSymbolType)
# # # # #
# # # # #
# # ]
1339 : : {
1340 : : case SYMBOL_SQUARE:
1341 : : {
1342 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1343 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1344 : :
1345 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1346 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1347 : :
1348 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1349 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1350 : :
1351 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1352 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1353 : :
1354 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1355 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1356 : 0 : break;
1357 : : }
1358 : : case SYMBOL_ARROW_UP:
1359 : : {
1360 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1361 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1362 : :
1363 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1364 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1365 : :
1366 : 0 : *pInnerSequenceX++ = fX;
1367 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1368 : :
1369 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1370 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1371 : 0 : break;
1372 : : }
1373 : : case SYMBOL_ARROW_DOWN:
1374 : : {
1375 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1376 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1377 : :
1378 : 0 : *pInnerSequenceX++ = fX;
1379 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1380 : :
1381 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1382 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1383 : :
1384 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1385 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1386 : 0 : break;
1387 : : }
1388 : : case SYMBOL_ARROW_RIGHT:
1389 : : {
1390 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1391 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1392 : :
1393 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1394 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1395 : :
1396 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1397 : 0 : *pInnerSequenceY++ = fY;
1398 : :
1399 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1400 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1401 : 0 : break;
1402 : : }
1403 : : case SYMBOL_ARROW_LEFT:
1404 : : {
1405 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1406 : 0 : *pInnerSequenceY++ = fY;
1407 : :
1408 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1409 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1410 : :
1411 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1412 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1413 : :
1414 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1415 : 0 : *pInnerSequenceY++ = fY;
1416 : 0 : break;
1417 : : }
1418 : : case SYMBOL_BOWTIE:
1419 : : {
1420 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1421 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1422 : :
1423 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1424 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1425 : :
1426 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1427 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1428 : :
1429 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1430 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1431 : :
1432 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1433 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1434 : 0 : break;
1435 : : }
1436 : : case SYMBOL_SANDGLASS:
1437 : : {
1438 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1439 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1440 : :
1441 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1442 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1443 : :
1444 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1445 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1446 : :
1447 : :
1448 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1449 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1450 : :
1451 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1452 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1453 : 0 : break;
1454 : : }
1455 : : case SYMBOL_DIAMOND:
1456 : : {
1457 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1458 : 0 : *pInnerSequenceY++ = fY;
1459 : :
1460 : 0 : *pInnerSequenceX++ = fX;
1461 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1462 : :
1463 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1464 : 0 : *pInnerSequenceY++ = fY;
1465 : :
1466 : 0 : *pInnerSequenceX++ = fX;
1467 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1468 : :
1469 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1470 : 0 : *pInnerSequenceY++ = fY;
1471 : 0 : break;
1472 : : }
1473 : : case SYMBOL_HORIZONTAL_BAR:
1474 : : {
1475 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1476 : 0 : *pInnerSequenceY++ = fY-0.2*fHeightH;
1477 : :
1478 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1479 : 0 : *pInnerSequenceY++ = fY-0.2*fHeightH;
1480 : :
1481 : :
1482 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1483 : 0 : *pInnerSequenceY++ = fY+0.2*fHeightH;
1484 : :
1485 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1486 : 0 : *pInnerSequenceY++ = fY+0.2*fHeightH;
1487 : :
1488 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1489 : 0 : *pInnerSequenceY++ = fY-0.2*fHeightH;
1490 : 0 : break;
1491 : : }
1492 : : case SYMBOL_VERTICAL_BAR:
1493 : : {
1494 : 0 : *pInnerSequenceX++ = fX-0.2*fWidthH;
1495 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1496 : :
1497 : 0 : *pInnerSequenceX++ = fX+0.2*fWidthH;
1498 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1499 : :
1500 : :
1501 : 0 : *pInnerSequenceX++ = fX+0.2*fWidthH;
1502 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1503 : :
1504 : 0 : *pInnerSequenceX++ = fX-0.2*fWidthH;
1505 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1506 : :
1507 : 0 : *pInnerSequenceX++ = fX-0.2*fWidthH;
1508 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1509 : :
1510 : 0 : break;
1511 : : }
1512 : : case SYMBOL_CIRCLE:
1513 : : {
1514 : 0 : double fOmega = 1.5707963267948966192 / (nQuarterCount + 1.0);
1515 : : // one point in the middle of each edge to get full size bounding rectangle
1516 : 0 : *pInnerSequenceX++ = fX + fWidthH;
1517 : 0 : *pInnerSequenceY++ = fY;
1518 : : // 0 to PI/2
1519 [ # # ]: 0 : for (sal_Int32 i = 1; i <= nQuarterCount; ++i)
1520 : : {
1521 : 0 : *pInnerSequenceX++ = fX + fWidthH * cos( i * fOmega );
1522 : 0 : *pInnerSequenceY++ = fY - fHeightH * sin( i * fOmega );
1523 : : }
1524 : : // PI/2 to PI
1525 : 0 : *pInnerSequenceX++ = fX;
1526 : 0 : *pInnerSequenceY++ = fY - fHeightH;
1527 [ # # ]: 0 : for (sal_Int32 i = 1; i <= nQuarterCount; ++i)
1528 : : {
1529 : 0 : *pInnerSequenceX++ = fX - fWidthH * sin( i * fOmega);
1530 : 0 : *pInnerSequenceY++ = fY - fHeightH * cos( i * fOmega);
1531 : : }
1532 : : // PI to 3/2*PI
1533 : 0 : *pInnerSequenceX++ = fX - fWidthH;
1534 : 0 : *pInnerSequenceY++ = fY;
1535 [ # # ]: 0 : for (sal_Int32 i = 1; i <= nQuarterCount; ++i)
1536 : : {
1537 : 0 : *pInnerSequenceX++ = fX - fWidthH * cos( i * fOmega);
1538 : 0 : *pInnerSequenceY++ = fY + fHeightH * sin( i * fOmega);
1539 : : }
1540 : : // 3/2*PI to 2*PI
1541 : 0 : *pInnerSequenceX++ = fX;
1542 : 0 : *pInnerSequenceY++ = fY + fHeightH;
1543 [ # # ]: 0 : for (sal_Int32 i = 1; i <= nQuarterCount; ++i)
1544 : : {
1545 : 0 : *pInnerSequenceX++ = fX + fWidthH * sin(i * fOmega);
1546 : 0 : *pInnerSequenceY++ = fY + fHeightH * cos(i * fOmega);
1547 : : }
1548 : : // close polygon
1549 : 0 : *pInnerSequenceX++ = fX + fWidthH;
1550 : 0 : *pInnerSequenceY++ = fY;
1551 : 0 : break;
1552 : : }
1553 : : case SYMBOL_STAR:
1554 : : {
1555 : 0 : *pInnerSequenceX++ = fX;
1556 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1557 : :
1558 : 0 : *pInnerSequenceX++ = fX+0.2*fWidthH;
1559 : 0 : *pInnerSequenceY++ = fY-0.2*fHeightH;
1560 : :
1561 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1562 : 0 : *pInnerSequenceY++ = fY;
1563 : :
1564 : 0 : *pInnerSequenceX++ = fX+0.2*fWidthH;
1565 : 0 : *pInnerSequenceY++ = fY+0.2*fHeightH;
1566 : :
1567 : 0 : *pInnerSequenceX++ = fX;
1568 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1569 : :
1570 : 0 : *pInnerSequenceX++ = fX-0.2*fWidthH;
1571 : 0 : *pInnerSequenceY++ = fY+0.2*fHeightH;
1572 : :
1573 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1574 : 0 : *pInnerSequenceY++ = fY;
1575 : :
1576 : 0 : *pInnerSequenceX++ = fX-0.2*fWidthH;
1577 : 0 : *pInnerSequenceY++ = fY-0.2*fHeightH;
1578 : :
1579 : 0 : *pInnerSequenceX++ = fX;
1580 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1581 : 0 : break;
1582 : : }
1583 : : case SYMBOL_X:
1584 : : {
1585 : 0 : const double fScaleX = fWidthH / 128.0;
1586 : 0 : const double fScaleY = fHeightH / 128.0;
1587 : 0 : const double fSmall = sqrt(200.0);
1588 : 0 : const double fLarge = 128.0 - fSmall;
1589 : :
1590 : 0 : *pInnerSequenceX++ = fX;
1591 : 0 : *pInnerSequenceY++ = fY - fScaleY * fSmall;
1592 : :
1593 : 0 : *pInnerSequenceX++ = fX - fScaleX * fLarge;
1594 : 0 : *pInnerSequenceY++ = fY - fHeightH;
1595 : :
1596 : 0 : *pInnerSequenceX++ = fX - fWidthH;
1597 : 0 : *pInnerSequenceY++ = fY - fScaleY * fLarge;
1598 : :
1599 : 0 : *pInnerSequenceX++ = fX - fScaleX * fSmall;
1600 : 0 : *pInnerSequenceY++ = fY;
1601 : :
1602 : 0 : *pInnerSequenceX++ = fX - fWidthH;
1603 : 0 : *pInnerSequenceY++ = fY + fScaleY * fLarge;
1604 : :
1605 : 0 : *pInnerSequenceX++ = fX - fScaleX * fLarge;
1606 : 0 : *pInnerSequenceY++ = fY + fHeightH;
1607 : :
1608 : 0 : *pInnerSequenceX++ = fX;
1609 : 0 : *pInnerSequenceY++ = fY + fScaleY * fSmall;
1610 : :
1611 : 0 : *pInnerSequenceX++ = fX + fScaleX * fLarge;
1612 : 0 : *pInnerSequenceY++ = fY + fHeightH;
1613 : :
1614 : 0 : *pInnerSequenceX++ = fX + fWidthH;
1615 : 0 : *pInnerSequenceY++ = fY + fScaleY * fLarge;
1616 : :
1617 : 0 : *pInnerSequenceX++ = fX + fScaleX * fSmall;
1618 : 0 : *pInnerSequenceY++ = fY;
1619 : :
1620 : 0 : *pInnerSequenceX++ = fX + fWidthH;
1621 : 0 : *pInnerSequenceY++ = fY - fScaleY * fLarge;
1622 : :
1623 : 0 : *pInnerSequenceX++ = fX + fScaleX * fLarge;
1624 : 0 : *pInnerSequenceY++ = fY - fHeightH;
1625 : :
1626 : 0 : *pInnerSequenceX++ = fX;
1627 : 0 : *pInnerSequenceY++ = fY - fScaleY * fSmall;
1628 : 0 : break;
1629 : :
1630 : : }
1631 : : case SYMBOL_PLUS:
1632 : : {
1633 : 0 : const double fScaleX = fWidthH / 128.0;
1634 : 0 : const double fScaleY = fHeightH / 128.0;
1635 : 0 : const double fHalf = 10.0; //half line width on 256 size square
1636 : 0 : const double fdX = fScaleX * fHalf;
1637 : 0 : const double fdY = fScaleY * fHalf;
1638 : :
1639 : 0 : *pInnerSequenceX++ = fX-fdX;
1640 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1641 : :
1642 : 0 : *pInnerSequenceX++ = fX-fdX;
1643 : 0 : *pInnerSequenceY++ = fY-fdY;
1644 : :
1645 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1646 : 0 : *pInnerSequenceY++ = fY-fdY;
1647 : :
1648 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1649 : 0 : *pInnerSequenceY++ = fY+fdY;
1650 : :
1651 : 0 : *pInnerSequenceX++ = fX-fdX;
1652 : 0 : *pInnerSequenceY++ = fY+fdY;
1653 : :
1654 : 0 : *pInnerSequenceX++ = fX-fdX;
1655 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1656 : :
1657 : 0 : *pInnerSequenceX++ = fX+fdX;
1658 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1659 : :
1660 : 0 : *pInnerSequenceX++ = fX+fdX;
1661 : 0 : *pInnerSequenceY++ = fY+fdY;
1662 : :
1663 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1664 : 0 : *pInnerSequenceY++ = fY+fdY;
1665 : :
1666 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1667 : 0 : *pInnerSequenceY++ = fY-fdY;
1668 : :
1669 : 0 : *pInnerSequenceX++ = fX+fdX;
1670 : 0 : *pInnerSequenceY++ = fY-fdY;
1671 : :
1672 : 0 : *pInnerSequenceX++ = fX+fdY;
1673 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1674 : :
1675 : 0 : *pInnerSequenceX++ = fX-fdX;
1676 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1677 : 0 : break;
1678 : :
1679 : : }
1680 : : case SYMBOL_ASTERISK:
1681 : : {
1682 : 0 : const double fHalf = 10.0; // half line width on 256 size square
1683 : 0 : const double fTwoY = fHalf * sqrt(3.0);
1684 : 0 : const double fFourY = (128.0 - 2.0 * fHalf ) / sqrt(3.0);
1685 : 0 : const double fThreeX = 128.0 - fHalf;
1686 : 0 : const double fThreeY = fHalf * sqrt(3.0) + fFourY;
1687 : 0 : const double fFiveX = 2.0 * fHalf;
1688 : :
1689 : 0 : const double fScaleX = fWidthH / 128.0;
1690 : 0 : const double fScaleY = fHeightH / 128.0;
1691 : :
1692 : : //1
1693 : 0 : *pInnerSequenceX++ = fX-fScaleX * fHalf;
1694 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1695 : : //2
1696 : 0 : *pInnerSequenceX++ = fX-fScaleX * fHalf;
1697 : 0 : *pInnerSequenceY++ = fY-fScaleY * fTwoY;
1698 : : //3
1699 : 0 : *pInnerSequenceX++ = fX-fScaleX * fThreeX;
1700 : 0 : *pInnerSequenceY++ = fY-fScaleY * fThreeY;
1701 : : //4
1702 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1703 : 0 : *pInnerSequenceY++ = fY-fScaleY * fFourY;
1704 : : //5
1705 : 0 : *pInnerSequenceX++ = fX-fScaleX * fFiveX;
1706 : 0 : *pInnerSequenceY++ = fY;
1707 : : //6 as 4
1708 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1709 : 0 : *pInnerSequenceY++ = fY+fScaleY * fFourY;
1710 : : //7 as 3
1711 : 0 : *pInnerSequenceX++ = fX-fScaleX * fThreeX;
1712 : 0 : *pInnerSequenceY++ = fY+fScaleY * fThreeY;
1713 : : //8 as 2
1714 : 0 : *pInnerSequenceX++ = fX-fScaleX * fHalf;
1715 : 0 : *pInnerSequenceY++ = fY+fScaleY * fTwoY;
1716 : : //9 as 1
1717 : 0 : *pInnerSequenceX++ = fX-fScaleX * fHalf;
1718 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1719 : : //10 as 1
1720 : 0 : *pInnerSequenceX++ = fX+fScaleX * fHalf;
1721 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1722 : : //11 as 2
1723 : 0 : *pInnerSequenceX++ = fX+fScaleX * fHalf;
1724 : 0 : *pInnerSequenceY++ = fY+fScaleY * fTwoY;
1725 : : //12 as 3
1726 : 0 : *pInnerSequenceX++ = fX+fScaleX * fThreeX;
1727 : 0 : *pInnerSequenceY++ = fY+fScaleY * fThreeY;
1728 : : //13 as 4
1729 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1730 : 0 : *pInnerSequenceY++ = fY+fScaleY * fFourY;
1731 : : //14 as 5
1732 : 0 : *pInnerSequenceX++ = fX+fScaleX * fFiveX;
1733 : 0 : *pInnerSequenceY++ = fY;
1734 : : //15 as 4
1735 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1736 : 0 : *pInnerSequenceY++ = fY-fScaleY * fFourY;
1737 : : //16 as 3
1738 : 0 : *pInnerSequenceX++ = fX+fScaleX * fThreeX;
1739 : 0 : *pInnerSequenceY++ = fY-fScaleY * fThreeY;
1740 : : //17 as 2
1741 : 0 : *pInnerSequenceX++ = fX+fScaleX * fHalf;
1742 : 0 : *pInnerSequenceY++ = fY-fScaleY * fTwoY;
1743 : : // 18 as 1
1744 : 0 : *pInnerSequenceX++ = fX+fScaleX * fHalf;
1745 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1746 : : // 19 = 1, closing
1747 : 0 : *pInnerSequenceX++ = fX-fScaleX * fHalf;
1748 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1749 : 0 : break;
1750 : : }
1751 : : default: //case SYMBOL_SQUARE:
1752 : : {
1753 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1754 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1755 : :
1756 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1757 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1758 : :
1759 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1760 : 0 : *pInnerSequenceY++ = fY+fHeightH;
1761 : :
1762 : 0 : *pInnerSequenceX++ = fX+fWidthH;
1763 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1764 : :
1765 : 0 : *pInnerSequenceX++ = fX-fWidthH;
1766 : 0 : *pInnerSequenceY++ = fY-fHeightH;
1767 : 0 : break;
1768 : : }
1769 : : }
1770 : :
1771 : 0 : return aPP;
1772 : : }
1773 : :
1774 : : uno::Reference< drawing::XShape >
1775 : 0 : ShapeFactory::createSymbol2D(
1776 : : const uno::Reference< drawing::XShapes >& xTarget
1777 : : , const drawing::Position3D& rPosition
1778 : : , const drawing::Direction3D& rSize
1779 : : , sal_Int32 nStandardSymbol
1780 : : , sal_Int32 nBorderColor
1781 : : , sal_Int32 nFillColor )
1782 : : {
1783 [ # # ]: 0 : if( !xTarget.is() )
1784 [ # # ]: 0 : return 0;
1785 : :
1786 : : //create shape
1787 : : uno::Reference< drawing::XShape > xShape(
1788 [ # # ]: 0 : m_xShapeFactory->createInstance( C2U(
1789 [ # # ][ # # ]: 0 : "com.sun.star.drawing.PolyPolygonShape") ), uno::UNO_QUERY );
[ # # ]
1790 [ # # ][ # # ]: 0 : xTarget->add(xShape);
1791 : :
1792 : : //set properties
1793 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
1794 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
1795 [ # # ]: 0 : if( xProp.is())
1796 : : {
1797 : : try
1798 : : {
1799 : : drawing::PointSequenceSequence aPoints( PolyToPointSequence(
1800 [ # # ][ # # ]: 0 : createPolyPolygon_Symbol( rPosition, rSize, nStandardSymbol ) ));
[ # # ]
1801 : :
1802 : : //Polygon
1803 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_POLYPOLYGON )
1804 [ # # ][ # # ]: 0 : , uno::makeAny( aPoints ) );
[ # # ]
1805 : :
1806 : : //LineColor
1807 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_LINECOLOR )
1808 [ # # ][ # # ]: 0 : , uno::makeAny( nBorderColor ) );
[ # # ]
1809 : :
1810 : : //FillColor
1811 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_FILLCOLOR )
1812 [ # # ][ # # ]: 0 : , uno::makeAny( nFillColor ) );
[ # # ][ # # ]
[ # # ]
1813 : : }
1814 [ # # ]: 0 : catch( const uno::Exception& e )
1815 : : {
1816 : : ASSERT_EXCEPTION( e );
1817 : : }
1818 : : }
1819 : 0 : return xShape;
1820 : : }
1821 : :
1822 : : uno::Reference< drawing::XShape >
1823 : 0 : ShapeFactory::createGraphic2D(
1824 : : const uno::Reference< drawing::XShapes >& xTarget
1825 : : , const drawing::Position3D& rPosition
1826 : : , const drawing::Direction3D& rSize
1827 : : , const uno::Reference< graphic::XGraphic >& xGraphic )
1828 : : {
1829 [ # # ][ # # ]: 0 : if( !xTarget.is() || !xGraphic.is() )
[ # # ]
1830 [ # # ]: 0 : return 0;
1831 : :
1832 : : // @todo: change this to a rectangle shape with a fill bitmap for
1833 : : // performance reasons (ask AW, said CL)
1834 : :
1835 : : //create shape
1836 : : uno::Reference< drawing::XShape > xShape(
1837 [ # # ]: 0 : m_xShapeFactory->createInstance( C2U(
1838 [ # # ][ # # ]: 0 : "com.sun.star.drawing.GraphicObjectShape") ), uno::UNO_QUERY );
[ # # ]
1839 [ # # ][ # # ]: 0 : xTarget->add(xShape);
1840 : :
1841 : : try
1842 : : {
1843 : : // assume position is upper left corner. Transform to center.
1844 : : drawing::Position3D aCenterPosition(
1845 : : rPosition.PositionX - (rSize.DirectionX / 2.0),
1846 : : rPosition.PositionY - (rSize.DirectionY / 2.0),
1847 : 0 : rPosition.PositionZ );
1848 [ # # ][ # # ]: 0 : xShape->setPosition( Position3DToAWTPoint( aCenterPosition ));
[ # # ]
1849 [ # # ][ # # ]: 0 : xShape->setSize( Direction3DToAWTSize( rSize ));
[ # # ][ # # ]
1850 : : }
1851 [ # # ]: 0 : catch( const uno::Exception & e )
1852 : : {
1853 : : ASSERT_EXCEPTION( e );
1854 : : }
1855 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
1856 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
1857 [ # # ]: 0 : if( xProp.is())
1858 : : {
1859 : : try
1860 : : {
1861 [ # # ][ # # ]: 0 : xProp->setPropertyValue( C2U("Graphic"), uno::makeAny( xGraphic ));
[ # # ][ # # ]
[ # # ]
1862 : : }
1863 [ # # ]: 0 : catch( const uno::Exception& e )
1864 : : {
1865 : : ASSERT_EXCEPTION( e );
1866 : : }
1867 : : }
1868 : 0 : return xShape;
1869 : : }
1870 : :
1871 : : uno::Reference< drawing::XShapes >
1872 : 30593 : ShapeFactory::createGroup2D( const uno::Reference< drawing::XShapes >& xTarget
1873 : : , ::rtl::OUString aName )
1874 : : {
1875 [ - + ]: 30593 : if( !xTarget.is() )
1876 : 0 : return 0;
1877 : : try
1878 : : {
1879 : : //create and add to target
1880 : : uno::Reference< drawing::XShape > xShape(
1881 [ + - ]: 30593 : m_xShapeFactory->createInstance( C2U(
1882 [ + - ][ + - ]: 30593 : "com.sun.star.drawing.GroupShape" ) ), uno::UNO_QUERY );
[ + - ]
1883 [ + - ][ + - ]: 30593 : xTarget->add(xShape);
1884 : :
1885 : : //set name
1886 [ + + ]: 30593 : if(!aName.isEmpty())
1887 [ + - ]: 17088 : setShapeName( xShape , aName );
1888 : :
1889 : : {//workaround
1890 : : //need this null size as otherwise empty group shapes where painted with a gray border
1891 [ + - ][ + - ]: 30593 : xShape->setSize(awt::Size(0,0));
1892 : : }
1893 : :
1894 : : //return
1895 : : uno::Reference< drawing::XShapes > xShapes =
1896 [ + - ]: 30593 : uno::Reference<drawing::XShapes>( xShape, uno::UNO_QUERY );
1897 [ # # ]: 30593 : return xShapes;
1898 : : }
1899 : 0 : catch( const uno::Exception& e )
1900 : : {
1901 : : ASSERT_EXCEPTION( e );
1902 : : }
1903 : 0 : return 0;
1904 : : }
1905 : :
1906 : : uno::Reference< drawing::XShapes >
1907 : 722 : ShapeFactory::createGroup3D( const uno::Reference< drawing::XShapes >& xTarget
1908 : : , ::rtl::OUString aName )
1909 : : {
1910 [ - + ]: 722 : if( !xTarget.is() )
1911 : 0 : return 0;
1912 : : try
1913 : : {
1914 : : //create shape
1915 : : uno::Reference< drawing::XShape > xShape(
1916 [ + - ]: 722 : m_xShapeFactory->createInstance( C2U(
1917 [ + - ][ + - ]: 722 : "com.sun.star.drawing.Shape3DSceneObject" ) ), uno::UNO_QUERY );
[ + - ]
1918 : :
1919 [ + - ][ + - ]: 722 : xTarget->add(xShape);
1920 : :
1921 : : //it is necessary to set the transform matrix to initialize the scene properly
1922 : : //otherwise all objects which are placed into this Group will not be visible
1923 : : //the following should be unnecessary after a the bug is fixed
1924 : : {
1925 : : //set properties
1926 [ + - ]: 722 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
1927 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
1928 [ + - ]: 722 : if( xProp.is())
1929 : : {
1930 : : try
1931 : : {
1932 [ + - ]: 722 : ::basegfx::B3DHomMatrix aM;
1933 [ + - ]: 722 : xProp->setPropertyValue( C2U( UNO_NAME_3D_TRANSFORM_MATRIX )
1934 [ + - ][ + - ]: 722 : , uno::makeAny(B3DHomMatrixToHomogenMatrix(aM)) );
[ + - ][ + - ]
[ + - ][ # # ]
1935 : : }
1936 [ # # ]: 0 : catch( const uno::Exception& e )
1937 : : {
1938 : : ASSERT_EXCEPTION( e );
1939 : : }
1940 : 722 : }
1941 : : }
1942 : :
1943 : : //set name
1944 [ + + ]: 722 : if(!aName.isEmpty())
1945 [ + - ]: 541 : setShapeName( xShape , aName );
1946 : :
1947 : : //return
1948 : : uno::Reference< drawing::XShapes > xShapes =
1949 [ + - ]: 722 : uno::Reference<drawing::XShapes>( xShape, uno::UNO_QUERY );
1950 [ # # ]: 722 : return xShapes;
1951 : : }
1952 : 0 : catch( const uno::Exception& e )
1953 : : {
1954 : : ASSERT_EXCEPTION( e );
1955 : : }
1956 : 0 : return 0;
1957 : : }
1958 : :
1959 : : uno::Reference< drawing::XShape >
1960 : 0 : ShapeFactory::createCircle2D( const uno::Reference< drawing::XShapes >& xTarget
1961 : : , const drawing::Position3D& rPosition
1962 : : , const drawing::Direction3D& rSize )
1963 : : {
1964 [ # # ]: 0 : if( !xTarget.is() )
1965 [ # # ]: 0 : return 0;
1966 : :
1967 : : //create shape
1968 : : uno::Reference< drawing::XShape > xShape(
1969 [ # # ]: 0 : m_xShapeFactory->createInstance( C2U(
1970 [ # # ][ # # ]: 0 : "com.sun.star.drawing.EllipseShape") ), uno::UNO_QUERY );
[ # # ]
1971 [ # # ][ # # ]: 0 : xTarget->add(xShape);
1972 : :
1973 : : try
1974 : : {
1975 : : drawing::Position3D aCenterPosition(
1976 : : rPosition.PositionX - (rSize.DirectionX / 2.0),
1977 : : rPosition.PositionY - (rSize.DirectionY / 2.0),
1978 : 0 : rPosition.PositionZ );
1979 [ # # ][ # # ]: 0 : xShape->setPosition( Position3DToAWTPoint( aCenterPosition ));
[ # # ]
1980 [ # # ][ # # ]: 0 : xShape->setSize( Direction3DToAWTSize( rSize ));
[ # # ][ # # ]
1981 : : }
1982 [ # # ]: 0 : catch( const uno::Exception & e )
1983 : : {
1984 : : ASSERT_EXCEPTION( e );
1985 : : }
1986 : :
1987 : : //set properties
1988 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
1989 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
1990 [ # # ]: 0 : if( xProp.is())
1991 : : {
1992 : : try
1993 : : {
1994 : 0 : drawing::CircleKind eKind = drawing::CircleKind_FULL;
1995 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_CIRCKIND )
1996 [ # # ][ # # ]: 0 : , uno::makeAny( eKind ) );
[ # # ][ # # ]
1997 : : }
1998 [ # # ]: 0 : catch( const uno::Exception& e )
1999 : : {
2000 : : ASSERT_EXCEPTION( e );
2001 : : }
2002 : : }
2003 : 0 : return xShape;
2004 : : }
2005 : :
2006 : : uno::Reference< drawing::XShape >
2007 : 0 : ShapeFactory::createLine3D( const uno::Reference< drawing::XShapes >& xTarget
2008 : : , const drawing::PolyPolygonShape3D& rPoints
2009 : : , const VLineProperties& rLineProperties )
2010 : : {
2011 [ # # ]: 0 : if( !xTarget.is() )
2012 [ # # ]: 0 : return 0;
2013 : :
2014 [ # # ]: 0 : if(!rPoints.SequenceX.getLength())
2015 [ # # ]: 0 : return NULL;
2016 : :
2017 : : //create shape
2018 : : uno::Reference< drawing::XShape > xShape(
2019 [ # # ]: 0 : m_xShapeFactory->createInstance( C2U(
2020 [ # # ][ # # ]: 0 : "com.sun.star.drawing.Shape3DPolygonObject") ), uno::UNO_QUERY );
[ # # ]
2021 [ # # ][ # # ]: 0 : xTarget->add(xShape);
2022 : :
2023 : : //set properties
2024 [ # # ]: 0 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
2025 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
2026 [ # # ]: 0 : if( xProp.is())
2027 : : {
2028 : : try
2029 : : {
2030 : : //Polygon
2031 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_POLYPOLYGON3D )
2032 [ # # ][ # # ]: 0 : , uno::makeAny( rPoints ) );
[ # # ]
2033 : :
2034 : : //LineOnly
2035 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_3D_LINEONLY )
2036 [ # # ][ # # ]: 0 : , uno::makeAny( (sal_Bool)true ) );
[ # # ]
2037 : :
2038 : : //Transparency
2039 [ # # ]: 0 : if(rLineProperties.Transparence.hasValue())
2040 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_LINETRANSPARENCE )
2041 [ # # ][ # # ]: 0 : , rLineProperties.Transparence );
2042 : :
2043 : : //LineStyle
2044 [ # # ]: 0 : if(rLineProperties.LineStyle.hasValue())
2045 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_LINESTYLE )
2046 [ # # ][ # # ]: 0 : , rLineProperties.LineStyle );
2047 : :
2048 : : //LineWidth
2049 [ # # ]: 0 : if(rLineProperties.Width.hasValue())
2050 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_LINEWIDTH )
2051 [ # # ][ # # ]: 0 : , rLineProperties.Width );
2052 : :
2053 : : //LineColor
2054 [ # # ]: 0 : if(rLineProperties.Color.hasValue())
2055 [ # # ]: 0 : xProp->setPropertyValue( C2U( UNO_NAME_LINECOLOR )
2056 [ # # ][ # # ]: 0 : , rLineProperties.Color );
[ # # ]
2057 : : //, uno::makeAny( sal_Int32( Color(COL_RED).GetColor()) ) );
2058 : : }
2059 [ # # ]: 0 : catch( const uno::Exception& e )
2060 : : {
2061 : : ASSERT_EXCEPTION( e );
2062 : : }
2063 : : }
2064 : 0 : return xShape;
2065 : : }
2066 : :
2067 : : uno::Reference< drawing::XShape >
2068 : 6082 : ShapeFactory::createLine2D( const uno::Reference< drawing::XShapes >& xTarget
2069 : : , const drawing::PointSequenceSequence& rPoints
2070 : : , const VLineProperties* pLineProperties )
2071 : : {
2072 [ - + ]: 6082 : if( !xTarget.is() )
2073 [ # # ]: 0 : return 0;
2074 : :
2075 [ - + ]: 6082 : if(!rPoints.getLength())
2076 [ # # ]: 0 : return NULL;
2077 : :
2078 : : //create shape
2079 : : uno::Reference< drawing::XShape > xShape(
2080 [ + - ]: 6082 : m_xShapeFactory->createInstance( C2U(
2081 [ + - ][ + - ]: 6082 : "com.sun.star.drawing.PolyLineShape") ), uno::UNO_QUERY );
[ + - ]
2082 [ + - ][ + - ]: 6082 : xTarget->add(xShape);
2083 : :
2084 : : //set properties
2085 [ + - ]: 6082 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
2086 : : OSL_ENSURE(xProp.is(), "created shape offers no XPropertySet");
2087 [ + - ]: 6082 : if( xProp.is())
2088 : : {
2089 : : try
2090 : : {
2091 : : //Polygon
2092 [ + - ]: 6082 : xProp->setPropertyValue( C2U( UNO_NAME_POLYPOLYGON )
2093 [ + - ][ + - ]: 6082 : , uno::makeAny( rPoints ) );
[ + - ]
2094 : :
2095 [ + + ]: 6082 : if(pLineProperties)
2096 : : {
2097 : : //Transparency
2098 [ + - ]: 5312 : if(pLineProperties->Transparence.hasValue())
2099 [ + - ]: 5312 : xProp->setPropertyValue( C2U( UNO_NAME_LINETRANSPARENCE )
2100 [ + - ][ + - ]: 5312 : , pLineProperties->Transparence );
2101 : :
2102 : : //LineStyle
2103 [ + - ]: 5312 : if(pLineProperties->LineStyle.hasValue())
2104 [ + - ]: 5312 : xProp->setPropertyValue( C2U( UNO_NAME_LINESTYLE )
2105 [ + - ][ + - ]: 5312 : , pLineProperties->LineStyle );
2106 : :
2107 : : //LineWidth
2108 [ + - ]: 5312 : if(pLineProperties->Width.hasValue())
2109 [ + - ]: 5312 : xProp->setPropertyValue( C2U( UNO_NAME_LINEWIDTH )
2110 [ + - ][ + - ]: 5312 : , pLineProperties->Width );
2111 : :
2112 : : //LineColor
2113 [ + - ]: 5312 : if(pLineProperties->Color.hasValue())
2114 [ + - ]: 5312 : xProp->setPropertyValue( C2U( UNO_NAME_LINECOLOR )
2115 [ + - ][ + - ]: 5312 : , pLineProperties->Color );
2116 : :
2117 : : //LineDashName
2118 [ - + ]: 5312 : if(pLineProperties->DashName.hasValue())
2119 [ # # ]: 0 : xProp->setPropertyValue( C2U( "LineDashName" )
2120 [ # # ][ # # ]: 0 : , pLineProperties->DashName );
[ # # ]
2121 : : }
2122 : : }
2123 [ # # ]: 0 : catch( const uno::Exception& e )
2124 : : {
2125 : : ASSERT_EXCEPTION( e );
2126 : : }
2127 : : }
2128 : 6082 : return xShape;
2129 : : }
2130 : :
2131 : 27601 : uno::Any ShapeFactory::makeTransformation( const awt::Point& rScreenPosition2D, double fRotationAnglePi )
2132 : : {
2133 [ + - ]: 27601 : ::basegfx::B2DHomMatrix aM;
2134 : : //As autogrow is active the rectangle is automatically expanded to that side
2135 : : //to which the text is not adjusted.
2136 : : // aM.scale( 1, 1 ); Oops? A scale with this parameters is neutral, line commented out
2137 [ + - ]: 27601 : aM.rotate( fRotationAnglePi );
2138 [ + - ]: 27601 : aM.translate( rScreenPosition2D.X, rScreenPosition2D.Y );
2139 [ + - ][ + - ]: 27601 : uno::Any aATransformation = uno::makeAny( B2DHomMatrixToHomogenMatrix3(aM) );
2140 [ + - ]: 27601 : return aATransformation;
2141 : : }
2142 : :
2143 : 5367 : void ShapeFactory::makeShapeInvisible( const uno::Reference< drawing::XShape >& xShape )
2144 : : {
2145 [ + - ]: 5367 : uno::Reference< beans::XPropertySet > xShapeProp( xShape, uno::UNO_QUERY );
2146 : : OSL_ENSURE(xShapeProp.is(), "created shape offers no XPropertySet");
2147 [ + - ]: 5367 : if( xShapeProp.is())
2148 : : {
2149 : : try
2150 : : {
2151 [ + - ][ + - ]: 5367 : xShapeProp->setPropertyValue( C2U("LineStyle"), uno::makeAny( drawing::LineStyle_NONE ));
[ + - ][ + - ]
2152 [ + - ][ + - ]: 5367 : xShapeProp->setPropertyValue( C2U("FillStyle"), uno::makeAny( drawing::FillStyle_NONE ));
[ + - ][ # # ]
[ + - ]
2153 : : }
2154 [ # # ]: 0 : catch( const uno::Exception& e )
2155 : : {
2156 : : ASSERT_EXCEPTION( e );
2157 : : }
2158 : 5367 : }
2159 : 5367 : }
2160 : :
2161 : 5347 : uno::Reference< drawing::XShape > ShapeFactory::createInvisibleRectangle(
2162 : : const uno::Reference< drawing::XShapes >& xTarget
2163 : : , const awt::Size& rSize )
2164 : : {
2165 : : try
2166 : : {
2167 [ - + ]: 5347 : if(!xTarget.is())
2168 [ # # ]: 0 : return 0;
2169 : :
2170 [ + - ]: 5347 : uno::Reference< drawing::XShape > xShape( m_xShapeFactory->createInstance(
2171 [ + - ][ + - ]: 5347 : C2U( "com.sun.star.drawing.RectangleShape" )), uno::UNO_QUERY );
[ + - ]
2172 [ + - ][ + - ]: 5347 : if( xTarget.is() && xShape.is())
[ + - ]
2173 : : {
2174 [ + - ][ + - ]: 5347 : xTarget->add( xShape );
2175 [ + - ]: 5347 : ShapeFactory::makeShapeInvisible( xShape );
2176 [ + - ][ + - ]: 5347 : xShape->setSize( rSize );
2177 : : }
2178 [ # # ]: 5347 : return xShape;
2179 : : }
2180 : 0 : catch( const uno::Exception & ex )
2181 : : {
2182 : : ASSERT_EXCEPTION( ex );
2183 : : }
2184 : 0 : return 0;
2185 : : }
2186 : :
2187 : : uno::Reference< drawing::XShape >
2188 : 18205 : ShapeFactory::createText( const uno::Reference< drawing::XShapes >& xTarget
2189 : : , const ::rtl::OUString& rText
2190 : : , const tNameSequence& rPropNames
2191 : : , const tAnySequence& rPropValues
2192 : : , const uno::Any& rATransformation )
2193 : : {
2194 [ - + ]: 18205 : if( !xTarget.is() )
2195 [ # # ]: 0 : return 0;
2196 : :
2197 [ - + ]: 18205 : if(rText.isEmpty())
2198 [ # # ]: 0 : return 0;
2199 : :
2200 : : //create shape and add to page
2201 : : uno::Reference< drawing::XShape > xShape(
2202 [ + - ]: 18205 : m_xShapeFactory->createInstance( C2U(
2203 [ + - ][ + - ]: 18205 : "com.sun.star.drawing.TextShape" ) ), uno::UNO_QUERY );
[ + - ]
2204 [ + - ][ + - ]: 18205 : xTarget->add(xShape);
2205 : :
2206 : : //set text
2207 [ + - ]: 18205 : uno::Reference< text::XTextRange > xTextRange( xShape, uno::UNO_QUERY );
2208 [ + - ]: 18205 : if( xTextRange.is() )
2209 [ + - ][ + - ]: 18205 : xTextRange->setString( rText );
2210 : :
2211 [ + - ]: 18205 : uno::Reference< beans::XPropertySet > xProp( xShape, uno::UNO_QUERY );
2212 [ + - ]: 18205 : if( xProp.is() )
2213 : : {
2214 : : //set properties
2215 [ + - ]: 18205 : PropertyMapper::setMultiProperties( rPropNames, rPropValues, xProp );
2216 : :
2217 : : //set position matrix
2218 : : //the matrix needs to be set at the end behind autogrow and such position influencing properties
2219 : : try
2220 : : {
2221 [ + - ][ + - ]: 18205 : xProp->setPropertyValue( C2U( "Transformation" ), rATransformation );
[ + - ][ # # ]
2222 : : }
2223 [ # # ]: 0 : catch( const uno::Exception& e )
2224 : : {
2225 : : ASSERT_EXCEPTION( e );
2226 : : }
2227 : : }
2228 : 18205 : return xShape;
2229 : : }
2230 : :
2231 : 16014 : rtl::OUString ShapeFactory::getStackedString( const rtl::OUString& rString, bool bStacked )
2232 : : {
2233 : 16014 : sal_Int32 nLen = rString.getLength();
2234 [ - + ][ + + ]: 16014 : if(!bStacked || !nLen)
2235 : 15877 : return rString;
2236 : :
2237 : 137 : rtl::OUStringBuffer aStackStr;
2238 : :
2239 : : //add a newline after each letter
2240 : : //as we do not no letters here add a newline after each char
2241 [ + + ]: 598 : for( sal_Int32 nPosSrc=0; nPosSrc < nLen; nPosSrc++ )
2242 : : {
2243 [ + + ]: 461 : if( nPosSrc )
2244 [ + - ]: 324 : aStackStr.append( sal_Unicode('\r') );
2245 [ + - ]: 461 : aStackStr.append(rString[nPosSrc]);
2246 : : }
2247 [ + - ]: 16014 : return aStackStr.makeStringAndClear();
2248 : : }
2249 : :
2250 : 296 : bool ShapeFactory::hasPolygonAnyLines( drawing::PolyPolygonShape3D& rPoly)
2251 : : {
2252 : : // #i67757# check all contained polygons, if at least one polygon contains 2 or more points, return true
2253 [ + - ]: 296 : for( sal_Int32 nIdx = 0, nCount = rPoly.SequenceX.getLength(); nIdx < nCount; ++nIdx )
2254 [ + - ]: 296 : if( rPoly.SequenceX[ nIdx ].getLength() > 1 )
2255 : 296 : return true;
2256 : 296 : return false;
2257 : : }
2258 : :
2259 : 0 : bool ShapeFactory::isPolygonEmptyOrSinglePoint( drawing::PolyPolygonShape3D& rPoly)
2260 : : {
2261 : : // true, if empty polypolygon or one polygon with one point
2262 : 0 : return (rPoly.SequenceX.getLength() == 0) ||
2263 [ # # ][ # # ]: 0 : ((rPoly.SequenceX.getLength() == 1) && (rPoly.SequenceX[0].getLength() <= 1));
[ # # ]
2264 : : }
2265 : :
2266 : 0 : void ShapeFactory::closePolygon( drawing::PolyPolygonShape3D& rPoly)
2267 : : {
2268 : : OSL_ENSURE( rPoly.SequenceX.getLength() <= 1, "ShapeFactory::closePolygon - single polygon expected" );
2269 : : //add a last point == first point
2270 [ # # ][ # # ]: 0 : if(isPolygonEmptyOrSinglePoint(rPoly))
2271 : 0 : return;
2272 [ # # ][ # # ]: 0 : drawing::Position3D aFirst(rPoly.SequenceX[0][0],rPoly.SequenceY[0][0],rPoly.SequenceZ[0][0]);
[ # # ][ # # ]
[ # # ][ # # ]
2273 [ # # ]: 0 : AddPointToPoly( rPoly, aFirst );
2274 : : }
2275 : :
2276 : 104 : awt::Size ShapeFactory::calculateNewSizeRespectingAspectRatio(
2277 : : const awt::Size& rTargetSize
2278 : : , const awt::Size& rSourceSizeWithCorrectAspectRatio )
2279 : : {
2280 : 104 : awt::Size aNewSize;
2281 : :
2282 : 104 : double fFactorWidth = double(rTargetSize.Width)/double(rSourceSizeWithCorrectAspectRatio.Width);
2283 : 104 : double fFactorHeight = double(rTargetSize.Height)/double(rSourceSizeWithCorrectAspectRatio.Height);
2284 [ + - ]: 104 : double fFactor = std::min(fFactorWidth,fFactorHeight);
2285 : 104 : aNewSize.Width=static_cast<sal_Int32>(fFactor*rSourceSizeWithCorrectAspectRatio.Width);
2286 : 104 : aNewSize.Height=static_cast<sal_Int32>(fFactor*rSourceSizeWithCorrectAspectRatio.Height);
2287 : :
2288 : 104 : return aNewSize;
2289 : : }
2290 : :
2291 : 104 : awt::Point ShapeFactory::calculateTopLeftPositionToCenterObject(
2292 : : const awt::Point& rTargetAreaPosition
2293 : : , const awt::Size& rTargetAreaSize
2294 : : , const awt::Size& rObjectSize )
2295 : : {
2296 : 104 : awt::Point aNewPosition(rTargetAreaPosition);
2297 : 104 : aNewPosition.X += static_cast<sal_Int32>(double(rTargetAreaSize.Width-rObjectSize.Width)/2.0);
2298 : 104 : aNewPosition.Y += static_cast<sal_Int32>(double(rTargetAreaSize.Height-rObjectSize.Height)/2.0);
2299 : 104 : return aNewPosition;
2300 : : }
2301 : :
2302 : 1944 : ::basegfx::B2IRectangle ShapeFactory::getRectangleOfShape(
2303 : : const uno::Reference< drawing::XShape >& xShape )
2304 : : {
2305 : 1944 : ::basegfx::B2IRectangle aRet;
2306 : :
2307 [ + - ]: 1944 : if( xShape.is() )
2308 : : {
2309 [ + - ][ + - ]: 1944 : awt::Point aPos = xShape->getPosition();
2310 [ + - ][ + - ]: 1944 : awt::Size aSize = xShape->getSize();
2311 [ + - ]: 1944 : aRet = BaseGFXHelper::makeRectangle(aPos,aSize);
2312 : : }
2313 : 1944 : return aRet;
2314 : :
2315 : : }
2316 : :
2317 : 31854 : awt::Size ShapeFactory::getSizeAfterRotation(
2318 : : const uno::Reference< drawing::XShape >& xShape, double fRotationAngleDegree )
2319 : : {
2320 : 31854 : awt::Size aRet(0,0);
2321 [ + - ]: 31854 : if(xShape.is())
2322 : : {
2323 [ + - ][ + - ]: 31854 : const awt::Size aSize( xShape->getSize() );
2324 : :
2325 [ + + ]: 31854 : if( ::rtl::math::approxEqual( fRotationAngleDegree, 0.0 ) )
2326 : 31592 : aRet = aSize;
2327 : : else
2328 : : {
2329 [ - + ]: 262 : while(fRotationAngleDegree>=360.0)
2330 : 0 : fRotationAngleDegree-=360.0;
2331 [ - + ]: 262 : while(fRotationAngleDegree<0.0)
2332 : 0 : fRotationAngleDegree+=360.0;
2333 [ - + ]: 262 : if(fRotationAngleDegree>270.0)
2334 : 0 : fRotationAngleDegree=360.0-fRotationAngleDegree;
2335 [ - + ]: 262 : else if(fRotationAngleDegree>180.0)
2336 : 0 : fRotationAngleDegree=fRotationAngleDegree-180.0;
2337 [ - + ]: 262 : else if(fRotationAngleDegree>90.0)
2338 : 0 : fRotationAngleDegree=180.0-fRotationAngleDegree;
2339 : :
2340 : 262 : const double fAnglePi = fRotationAngleDegree*F_PI/180.0;
2341 : :
2342 : : aRet.Height = static_cast<sal_Int32>(
2343 : 262 : aSize.Width*rtl::math::sin( fAnglePi )
2344 : 262 : + aSize.Height*rtl::math::cos( fAnglePi ));
2345 : : aRet.Width = static_cast<sal_Int32>(
2346 : 262 : aSize.Width*rtl::math::cos( fAnglePi )
2347 : 31854 : + aSize.Height*rtl::math::sin( fAnglePi ));
2348 : : }
2349 : : }
2350 : 31854 : return aRet;
2351 : : }
2352 : :
2353 : 40 : void ShapeFactory::removeSubShapes( const uno::Reference< drawing::XShapes >& xShapes )
2354 : : {
2355 [ + - ]: 40 : if( xShapes.is() )
2356 : : {
2357 [ + - ][ + - ]: 40 : sal_Int32 nSubCount = xShapes->getCount();
2358 : 40 : uno::Reference< drawing::XShape > xShape;
2359 [ + + ]: 138 : for( sal_Int32 nS = nSubCount; nS--; )
2360 : : {
2361 [ + - ][ + - ]: 98 : if( xShapes->getByIndex( nS ) >>= xShape )
[ + - ][ + - ]
2362 [ + - ][ + - ]: 98 : xShapes->remove( xShape );
2363 : 40 : }
2364 : : }
2365 : 40 : }
2366 : :
2367 : : //.............................................................................
2368 : : } //namespace chart
2369 : : //.............................................................................
2370 : :
2371 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
