?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update git submodules
[LibreOffice.git] / chart2 / source / view / diagram / VDiagram.cxx
bloba7e1dfc997b1b8cbb1c1f3146c3a675e11411e63
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 <VDiagram.hxx>
22 #include <Diagram.hxx>
23 #include <PropertyMapper.hxx>
24 #include <ViewDefines.hxx>
25 #include <Stripe.hxx>
26 #include <ObjectIdentifier.hxx>
27 #include <DiagramHelper.hxx>
28 #include <ChartType.hxx>
29 #include <BaseGFXHelper.hxx>
30 #include <ChartTypeHelper.hxx>
31 #include <ThreeDHelper.hxx>
32 #include <defines.hxx>
33 #include <editeng/unoprnms.hxx>
34 #include <svx/scene3d.hxx>
35 #include <svx/e3dsceneupdater.hxx>
36 #include <comphelper/diagnose_ex.hxx>
37
38 namespace chart
39 {
40 using namespace ::com::sun::star;
41 using namespace ::com::sun::star::chart2;
42
43 VDiagram::VDiagram(
44 const rtl::Reference<Diagram> & xDiagram, const drawing::Direction3D& rPreferredAspectRatio,
45 sal_Int32 nDimension )
46 : m_nDimensionCount(nDimension)
47 , m_xDiagram(xDiagram)
48 , m_aPreferredAspectRatio(rPreferredAspectRatio)
49 , m_fXAnglePi(0)
50 , m_fYAnglePi(0)
51 , m_fZAnglePi(0)
52 , m_bRightAngledAxes(false)
53 {
54 if( m_nDimensionCount != 3)
55 return;
56
57 xDiagram->getRotationAngle( m_fXAnglePi, m_fYAnglePi, m_fZAnglePi );
58 if( ChartTypeHelper::isSupportingRightAngledAxes(
59 m_xDiagram->getChartTypeByIndex( 0 ) ) )
60 {
61 if(xDiagram.is())
62 xDiagram->getPropertyValue(u"RightAngledAxes"_ustr) >>= m_bRightAngledAxes;
63 if( m_bRightAngledAxes )
64 {
65 ThreeDHelper::adaptRadAnglesForRightAngledAxes( m_fXAnglePi, m_fYAnglePi );
66 m_fZAnglePi=0.0;
67 }
68 }
69 }
70
71 VDiagram::~VDiagram()
72 {
73 }
74
75 void VDiagram::init( const rtl::Reference<SvxShapeGroupAnyD>& xTarget )
76 {
77 m_xTarget = xTarget;
78 }
79
80 void VDiagram::createShapes( const awt::Point& rPos, const awt::Size& rSize )
81 {
82 m_aAvailablePosIncludingAxes = rPos;
83 m_aAvailableSizeIncludingAxes = rSize;
84
85 if( m_nDimensionCount == 3 )
86 createShapes_3d();
87 else
88 createShapes_2d();
89 }
90
91 ::basegfx::B2IRectangle VDiagram::adjustPosAndSize( const awt::Point& rPos, const awt::Size& rSize )
92 {
93 ::basegfx::B2IRectangle aAllowedRect( BaseGFXHelper::makeRectangle(m_aAvailablePosIncludingAxes,m_aAvailableSizeIncludingAxes) );
94 ::basegfx::B2IRectangle aNewInnerRect( BaseGFXHelper::makeRectangle(rPos,rSize) );
95 aNewInnerRect.intersect( aAllowedRect );
96
97 if( m_nDimensionCount == 3 )
98 aNewInnerRect = adjustPosAndSize_3d( BaseGFXHelper::B2IRectangleToAWTPoint(aNewInnerRect), BaseGFXHelper::B2IRectangleToAWTSize(aNewInnerRect) );
99 else
100 aNewInnerRect = adjustPosAndSize_2d( BaseGFXHelper::B2IRectangleToAWTPoint(aNewInnerRect), BaseGFXHelper::B2IRectangleToAWTSize(aNewInnerRect) );
101
102 return aNewInnerRect;
103 }
104
105 ::basegfx::B2IRectangle VDiagram::adjustPosAndSize_2d( const awt::Point& rPos, const awt::Size& rAvailableSize )
106 {
107 m_aCurrentPosWithoutAxes = rPos;
108 m_aCurrentSizeWithoutAxes = rAvailableSize;
109 if( m_aPreferredAspectRatio.DirectionX > 0 && m_aPreferredAspectRatio.DirectionY > 0)
110 {
111 //do not change aspect ratio
112 awt::Size aAspectRatio( static_cast<sal_Int32>(m_aPreferredAspectRatio.DirectionX*FIXED_SIZE_FOR_3D_CHART_VOLUME),
113 static_cast<sal_Int32>(m_aPreferredAspectRatio.DirectionY*FIXED_SIZE_FOR_3D_CHART_VOLUME ));
114 m_aCurrentSizeWithoutAxes = ShapeFactory::calculateNewSizeRespectingAspectRatio(
115 rAvailableSize, aAspectRatio );
116 //center diagram position
117 m_aCurrentPosWithoutAxes = ShapeFactory::calculateTopLeftPositionToCenterObject(
118 rPos, rAvailableSize, m_aCurrentSizeWithoutAxes );
119
120 }
121
122 if( m_xWall2D.is() )
123 {
124 m_xWall2D->setSize( m_aCurrentSizeWithoutAxes);
125 m_xWall2D->setPosition(m_aCurrentPosWithoutAxes);
126 }
127
128 return BaseGFXHelper::makeRectangle(m_aCurrentPosWithoutAxes,m_aCurrentSizeWithoutAxes);
129 }
130
131 void VDiagram::createShapes_2d()
132 {
133 OSL_PRECOND(m_xTarget.is(), "is not proper initialized");
134 if (!m_xTarget.is())
135 return;
136
137 //create group shape
138 rtl::Reference<SvxShapeGroupAnyD> xOuterGroup_Shapes = ShapeFactory::createGroup2D(m_xTarget);
139 m_xOuterGroupShape = xOuterGroup_Shapes;
140
141 rtl::Reference<SvxShapeGroupAnyD> xGroupForWall( ShapeFactory::createGroup2D(xOuterGroup_Shapes,u"PlotAreaExcludingAxes"_ustr) );
142
143 //create independent group shape as container for datapoints and such things
144 m_xCoordinateRegionShape = ShapeFactory::createGroup2D(xOuterGroup_Shapes,u"testonly;CooContainer=XXX_CID"_ustr);
145
146 bool bAddFloorAndWall = m_xDiagram->isSupportingFloorAndWall();
147
148 //add back wall
149 {
150 m_xWall2D = ShapeFactory::createRectangle( xGroupForWall );
151
152 try
153 {
154 OSL_ENSURE( m_xDiagram.is(), "Invalid Diagram model" );
155 if( m_xDiagram.is() )
156 {
157 uno::Reference< beans::XPropertySet > xWallProp( m_xDiagram->getWall());
158 if( xWallProp.is())
159 PropertyMapper::setMappedProperties( *m_xWall2D, xWallProp, PropertyMapper::getPropertyNameMapForFillAndLineProperties() );
160 }
161 if( !bAddFloorAndWall )
162 {
163 //we always need this object as dummy object for correct scene dimensions
164 //but it should not be visible in this case:
165 ShapeFactory::makeShapeInvisible( m_xWall2D );
166 }
167 else
168 {
169 //CID for selection handling
170 OUString aWallCID( ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_DIAGRAM_WALL, u"" ) );//@todo read CID from model
171 m_xWall2D->SvxShape::setPropertyValue( UNO_NAME_MISC_OBJ_NAME, uno::Any( aWallCID ) );
172 }
173 }
174 catch( const uno::Exception& )
175 {
176 TOOLS_WARN_EXCEPTION("chart2", "" );
177 }
178 }
179
180 //position and size for diagram
181 adjustPosAndSize_2d( m_aAvailablePosIncludingAxes, m_aAvailableSizeIncludingAxes );
182 }
183
184 static E3dScene* lcl_getE3dScene( const rtl::Reference<SvxShapeGroupAnyD>& xShape )
185 {
186 return DynCastE3dScene(xShape->GetSdrObject());
187 }
188
189 static void lcl_setLightSources(
190 const uno::Reference< beans::XPropertySet > & xSource,
191 const uno::Reference< beans::XPropertySet > & xDest )
192 {
193 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_1,
194 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_1));
195 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_2,
196 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_2));
197 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_3,
198 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_3));
199 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_4,
200 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_4));
201 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_5,
202 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_5));
203 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_6,
204 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_6));
205 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_7,
206 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_7));
207 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_8,
208 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTON_8));
209
210 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_1,
211 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_1));
212 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_2,
213 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_2));
214 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_3,
215 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_3));
216 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_4,
217 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_4));
218 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_5,
219 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_5));
220 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_6,
221 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_6));
222 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_7,
223 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_7));
224 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_8,
225 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTDIRECTION_8));
226
227 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_1,
228 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_1));
229 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_2,
230 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_2));
231 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_3,
232 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_3));
233 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_4,
234 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_4));
235 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_5,
236 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_5));
237 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_6,
238 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_6));
239 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_7,
240 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_7));
241 xDest->setPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_8,
242 xSource->getPropertyValue( UNO_NAME_3D_SCENE_LIGHTCOLOR_8));
243 }
244
245 namespace
246 {
247
248 void lcl_ensureScaleValue( double& rfScale )
249 {
250 OSL_ENSURE(rfScale>0, "calculation error for automatic 3D height in chart");
251 if( rfScale<0 )
252 rfScale = 1.0;
253 else if( rfScale<0.2 )
254 rfScale = 0.2;
255 else if( rfScale>5.0 )
256 rfScale = 5.0;
257 }
258
259 }
260
261 void VDiagram::adjustAspectRatio3d( const awt::Size& rAvailableSize )
262 {
263 OSL_PRECOND(m_xAspectRatio3D.is(), "created shape offers no XPropertySet");
264 if( !m_xAspectRatio3D.is())
265 return;
266
267 try
268 {
269 double fScaleX = m_aPreferredAspectRatio.DirectionX;
270 double fScaleY = m_aPreferredAspectRatio.DirectionY;
271 double fScaleZ = m_aPreferredAspectRatio.DirectionZ;
272
273 //normalize scale factors
274 {
275 double fMax = std::max( std::max( fScaleX, fScaleY) , fScaleZ );
276 fScaleX/=fMax;
277 fScaleY/=fMax;
278 fScaleZ/=fMax;
279 }
280
281 if( fScaleX<0 || fScaleY<0 || fScaleZ<0 )
282 {
283 //calculate automatic 3D aspect ratio that fits good into the given 2D area
284 double fW = rAvailableSize.Width;
285 double fH = rAvailableSize.Height;
286
287 double sx = fabs(sin(m_fXAnglePi));
288 double sy = fabs(sin(m_fYAnglePi));
289 double cz = fabs(cos(m_fZAnglePi));
290 double sz = fabs(sin(m_fZAnglePi));
291
292 if(m_bRightAngledAxes)
293 {
294 //base equations:
295 //fH*zoomfactor == sx*fScaleZ + fScaleY;
296 //fW*zoomfactor == sy*fScaleZ + fScaleX;
297
298 if( fScaleX>0 && fScaleZ>0 )
299 {
300 //calculate fScaleY:
301 if( !::basegfx::fTools::equalZero(fW) )
302 {
303 fScaleY = (fH/fW)*(sy*fScaleZ+fScaleX)-(sx*fScaleZ);
304 lcl_ensureScaleValue( fScaleY );
305 }
306 else
307 fScaleY = 1.0;//looking from top or bottom the height is irrelevant
308 }
309 else if( fScaleY>0 && fScaleZ>0 )
310 {
311 //calculate fScaleX:
312 if( !::basegfx::fTools::equalZero(fH) )
313 {
314 fScaleX = (fW/fH)*(sx*fScaleZ+fScaleY)-(sy*fScaleZ);
315 lcl_ensureScaleValue(fScaleX);
316 }
317 else
318 fScaleX = 1.0;//looking from top or bottom height is irrelevant
319 }
320 else
321 {
322 //todo
323 OSL_FAIL("not implemented yet");
324
325 if( fScaleX<0 )
326 fScaleX = 1.0;
327 if( fScaleY<0 )
328 fScaleY = 1.0;
329 if( fScaleZ<0 )
330 fScaleZ = 1.0;
331 }
332 }
333 else
334 {
335 //base equations:
336 //fH*zoomfactor == cz*fScaleY + sz*fScaleX;
337 //fW*zoomfactor == cz*fScaleX + sz*fScaleY;
338 //==> fScaleY*(fH*sz-fW*cz) == fScaleX*(fW*sz-fH*cz);
339 if( fScaleX>0 && fScaleZ>0 )
340 {
341 //calculate fScaleY:
342 double fDivide = fH*sz-fW*cz;
343 if( !::basegfx::fTools::equalZero(fDivide) )
344 {
345 fScaleY = fScaleX*(fW*sz-fH*cz) / fDivide;
346 lcl_ensureScaleValue(fScaleY);
347 }
348 else
349 fScaleY = 1.0;//looking from top or bottom the height is irrelevant
350
351 }
352 else if( fScaleY>0 && fScaleZ>0 )
353 {
354 //calculate fScaleX:
355 double fDivide = fW*sz-fH*cz;
356 if( !::basegfx::fTools::equalZero(fDivide) )
357 {
358 fScaleX = fScaleY*(fH*sz-fW*cz) / fDivide;
359 lcl_ensureScaleValue(fScaleX);
360 }
361 else
362 fScaleX = 1.0;//looking from top or bottom height is irrelevant
363 }
364 else
365 {
366 //todo
367 OSL_FAIL("not implemented yet");
368
369 if( fScaleX<0 )
370 fScaleX = 1.0;
371 if( fScaleY<0 )
372 fScaleY = 1.0;
373 if( fScaleZ<0 )
374 fScaleZ = 1.0;
375 }
376 }
377 }
378
379 //normalize scale factors
380 {
381 double fMax = std::max( std::max( fScaleX, fScaleY) , fScaleZ );
382 fScaleX/=fMax;
383 fScaleY/=fMax;
384 fScaleZ/=fMax;
385 }
386
387 // identity matrix
388 ::basegfx::B3DHomMatrix aResult;
389 aResult.translate( -FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0,
390 -FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0,
391 -FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0 );
392 aResult.scale( fScaleX, fScaleY, fScaleZ );
393 aResult.translate( FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0,
394 FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0,
395 FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0 );
396
397 // To get the 3D aspect ratio's effect on the 2D scene size, the scene's 2D size needs to be adapted to
398 // 3D content changes here. The tooling class remembers the current 3D transformation stack
399 // and in its destructor, calculates a new 2D SnapRect for the scene and it's modified 3D geometry.
400 E3DModifySceneSnapRectUpdater aUpdater(lcl_getE3dScene(m_xOuterGroupShape));
401
402 m_xAspectRatio3D->setPropertyValue( UNO_NAME_3D_TRANSFORM_MATRIX
403 , uno::Any(BaseGFXHelper::B3DHomMatrixToHomogenMatrix( aResult )) );
404 }
405 catch( const uno::Exception& )
406 {
407 TOOLS_WARN_EXCEPTION("chart2", "" );
408 }
409 }
410
411 ::basegfx::B2IRectangle VDiagram::adjustPosAndSize_3d( const awt::Point& rPos, const awt::Size& rAvailableSize )
412 {
413 adjustAspectRatio3d( rAvailableSize );
414
415 //do not change aspect ratio of 3D scene with 2D bound rect
416 m_aCurrentSizeWithoutAxes = ShapeFactory::calculateNewSizeRespectingAspectRatio(
417 rAvailableSize, m_xOuterGroupShape->getSize() );
418 m_xOuterGroupShape->setSize( m_aCurrentSizeWithoutAxes );
419
420 //center diagram position
421 m_aCurrentPosWithoutAxes= ShapeFactory::calculateTopLeftPositionToCenterObject(
422 rPos, rAvailableSize, m_aCurrentSizeWithoutAxes );
423 m_xOuterGroupShape->setPosition(m_aCurrentPosWithoutAxes);
424
425 return BaseGFXHelper::makeRectangle(m_aCurrentPosWithoutAxes,m_aCurrentSizeWithoutAxes);
426 }
427
428 void VDiagram::createShapes_3d()
429 {
430 OSL_PRECOND(m_xTarget.is(), "is not proper initialized");
431 if (!m_xTarget.is())
432 return;
433
434 //create shape
435 rtl::Reference<Svx3DSceneObject> xShapes = ShapeFactory::createGroup3D( m_xTarget, u"PlotAreaExcludingAxes"_ustr );
436 m_xOuterGroupShape = xShapes;
437
438 rtl::Reference<SvxShapeGroupAnyD> xOuterGroup_Shapes = m_xOuterGroupShape;
439
440 //create additional group to manipulate the aspect ratio of the whole diagram:
441 {
442 rtl::Reference<Svx3DSceneObject> xAdditionalGroup = ShapeFactory::createGroup3D( xOuterGroup_Shapes );
443 xOuterGroup_Shapes = xAdditionalGroup;
444
445 m_xAspectRatio3D = std::move(xAdditionalGroup);
446 }
447
448 bool bAddFloorAndWall = m_xDiagram->isSupportingFloorAndWall();
449
450 const bool bDoubleSided = false;
451
452 //add walls
453 {
454 uno::Reference< beans::XPropertySet > xWallProp;
455 if( m_xDiagram.is() )
456 xWallProp.set( m_xDiagram->getWall() );
457
458 OUString aWallCID( ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_DIAGRAM_WALL, u"" ) );//@todo read CID from model
459 if( !bAddFloorAndWall )
460 aWallCID.clear();
461 rtl::Reference<Svx3DSceneObject> xWallGroup_Shapes = ShapeFactory::createGroup3D( xOuterGroup_Shapes, aWallCID );
462
463 CuboidPlanePosition eLeftWallPos( ThreeDHelper::getAutomaticCuboidPlanePositionForStandardLeftWall( m_xDiagram ) );
464 CuboidPlanePosition eBackWallPos( ThreeDHelper::getAutomaticCuboidPlanePositionForStandardBackWall( m_xDiagram ) );
465
466 //add left wall
467 {
468 short nRotatedTexture = ( eBackWallPos==CuboidPlanePosition_Front ) ? 3 : 1;
469 double xPos = 0.0;
470 if( eLeftWallPos==CuboidPlanePosition_Right )
471 xPos = FIXED_SIZE_FOR_3D_CHART_VOLUME;
472 Stripe aStripe( drawing::Position3D(xPos,FIXED_SIZE_FOR_3D_CHART_VOLUME,0)
473 , drawing::Direction3D(0,0,FIXED_SIZE_FOR_3D_CHART_VOLUME)
474 , drawing::Direction3D(0,-FIXED_SIZE_FOR_3D_CHART_VOLUME,0) );
475 if( eLeftWallPos==CuboidPlanePosition_Right )
476 {
477 nRotatedTexture = ( eBackWallPos==CuboidPlanePosition_Front ) ? 2 : 0;
478 aStripe = Stripe( drawing::Position3D(xPos,FIXED_SIZE_FOR_3D_CHART_VOLUME,0)
479 , drawing::Direction3D(0,-FIXED_SIZE_FOR_3D_CHART_VOLUME,0)
480 , drawing::Direction3D(0,0,FIXED_SIZE_FOR_3D_CHART_VOLUME) );
481 }
482 aStripe.InvertNormal(true);
483
484 rtl::Reference<Svx3DPolygonObject> xShape =
485 ShapeFactory::createStripe( xWallGroup_Shapes, aStripe
486 , xWallProp, PropertyMapper::getPropertyNameMapForFillAndLineProperties(), bDoubleSided, nRotatedTexture );
487 if( !bAddFloorAndWall )
488 {
489 //we always need this object as dummy object for correct scene dimensions
490 //but it should not be visible in this case:
491 ShapeFactory::makeShapeInvisible( xShape );
492 }
493 }
494 //add back wall
495 {
496 short nRotatedTexture = 0;
497 double zPos = 0.0;
498 if( eBackWallPos==CuboidPlanePosition_Front )
499 zPos = FIXED_SIZE_FOR_3D_CHART_VOLUME;
500 Stripe aStripe( drawing::Position3D(0,FIXED_SIZE_FOR_3D_CHART_VOLUME,zPos)
501 , drawing::Direction3D(0,-FIXED_SIZE_FOR_3D_CHART_VOLUME,0)
502 , drawing::Direction3D(FIXED_SIZE_FOR_3D_CHART_VOLUME,0,0) );
503 if( eBackWallPos==CuboidPlanePosition_Front )
504 {
505 aStripe = Stripe( drawing::Position3D(0,FIXED_SIZE_FOR_3D_CHART_VOLUME,zPos)
506 , drawing::Direction3D(FIXED_SIZE_FOR_3D_CHART_VOLUME,0,0)
507 , drawing::Direction3D(0,-FIXED_SIZE_FOR_3D_CHART_VOLUME,0) );
508 nRotatedTexture = 3;
509 }
510 aStripe.InvertNormal(true);
511
512 rtl::Reference<Svx3DPolygonObject> xShape =
513 ShapeFactory::createStripe(xWallGroup_Shapes, aStripe
514 , xWallProp, PropertyMapper::getPropertyNameMapForFillAndLineProperties(), bDoubleSided, nRotatedTexture );
515 if( !bAddFloorAndWall )
516 {
517 //we always need this object as dummy object for correct scene dimensions
518 //but it should not be visible in this case:
519 ShapeFactory::makeShapeInvisible( xShape );
520 }
521 }
522 }
523
524 try
525 {
526 //perspective
527 {
528 //ignore distance and focal length from file format and model completely
529 //use vrp only to indicate the distance of the camera and thus influence the perspective
530 m_xOuterGroupShape->setPropertyValue( UNO_NAME_3D_SCENE_DISTANCE, uno::Any(
531 static_cast<sal_Int32>(m_xDiagram->getCameraDistance())));
532 m_xOuterGroupShape->setPropertyValue( UNO_NAME_3D_SCENE_PERSPECTIVE,
533 m_xDiagram->getPropertyValue( UNO_NAME_3D_SCENE_PERSPECTIVE));
534 }
535
536 //light
537 {
538 m_xOuterGroupShape->setPropertyValue( UNO_NAME_3D_SCENE_SHADE_MODE,
539 m_xDiagram->getPropertyValue( UNO_NAME_3D_SCENE_SHADE_MODE));
540 m_xOuterGroupShape->setPropertyValue( UNO_NAME_3D_SCENE_AMBIENTCOLOR,
541 m_xDiagram->getPropertyValue( UNO_NAME_3D_SCENE_AMBIENTCOLOR));
542 m_xOuterGroupShape->setPropertyValue( UNO_NAME_3D_SCENE_TWO_SIDED_LIGHTING,
543 m_xDiagram->getPropertyValue( UNO_NAME_3D_SCENE_TWO_SIDED_LIGHTING));
544 lcl_setLightSources( m_xDiagram, m_xOuterGroupShape );
545 }
546
547 //rotation
548 {
549 //set diagrams rotation is set exclusively via the transformation matrix
550 //don't set a camera at all!
551 //the camera's rotation is incorporated into this matrix
552
553 ::basegfx::B3DHomMatrix aEffectiveTransformation;
554 aEffectiveTransformation.translate(-FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0, -FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0, -FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0);
555
556 if(!m_bRightAngledAxes)
557 aEffectiveTransformation.rotate(m_fXAnglePi,m_fYAnglePi,m_fZAnglePi);
558 else
559 aEffectiveTransformation.shearXY(m_fYAnglePi,-m_fXAnglePi);
560
561 //#i98497# 3D charts are rendered with wrong size
562 E3DModifySceneSnapRectUpdater aUpdater(lcl_getE3dScene(m_xOuterGroupShape));
563
564 m_xOuterGroupShape->setPropertyValue( UNO_NAME_3D_TRANSFORM_MATRIX,
565 uno::Any( BaseGFXHelper::B3DHomMatrixToHomogenMatrix( aEffectiveTransformation ) ) );
566 }
567 }
568 catch( const uno::Exception & )
569 {
570 DBG_UNHANDLED_EXCEPTION("chart2" );
571 }
572
573 //add floor plate
574 {
575 uno::Reference< beans::XPropertySet > xFloorProp;
576 if( m_xDiagram.is() )
577 xFloorProp.set( m_xDiagram->getFloor() );
578
579 Stripe aStripe( drawing::Position3D(0,0,0)
580 , drawing::Direction3D(0,0,FIXED_SIZE_FOR_3D_CHART_VOLUME)
581 , drawing::Direction3D(FIXED_SIZE_FOR_3D_CHART_VOLUME,0,0) );
582 aStripe.InvertNormal(true);
583
584 rtl::Reference<Svx3DPolygonObject> xShape =
585 ShapeFactory::createStripe(xOuterGroup_Shapes, aStripe
586 , xFloorProp, PropertyMapper::getPropertyNameMapForFillAndLineProperties(), bDoubleSided );
587
588 CuboidPlanePosition eBottomPos( ThreeDHelper::getAutomaticCuboidPlanePositionForStandardBottom( m_xDiagram ) );
589 if( !bAddFloorAndWall || (eBottomPos!=CuboidPlanePosition_Bottom) )
590 {
591 //we always need this object as dummy object for correct scene dimensions
592 //but it should not be visible in this case:
593 ShapeFactory::makeShapeInvisible( xShape );
594 }
595 else
596 {
597 OUString aFloorCID( ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_DIAGRAM_FLOOR, u"" ) );//@todo read CID from model
598 ShapeFactory::setShapeName( xShape, aFloorCID );
599 }
600 }
601
602 //create an additional scene for the smaller inner coordinate region:
603 {
604 rtl::Reference<Svx3DSceneObject> xShapes2 = ShapeFactory::createGroup3D( xOuterGroup_Shapes,u"testonly;CooContainer=XXX_CID"_ustr );
605 m_xCoordinateRegionShape = xShapes2;
606
607 try
608 {
609 double fXScale = (FIXED_SIZE_FOR_3D_CHART_VOLUME -GRID_TO_WALL_DISTANCE) /FIXED_SIZE_FOR_3D_CHART_VOLUME;
610 double fYScale = (FIXED_SIZE_FOR_3D_CHART_VOLUME -GRID_TO_WALL_DISTANCE) /FIXED_SIZE_FOR_3D_CHART_VOLUME;
611 double fZScale = (FIXED_SIZE_FOR_3D_CHART_VOLUME -GRID_TO_WALL_DISTANCE) /FIXED_SIZE_FOR_3D_CHART_VOLUME;
612
613 ::basegfx::B3DHomMatrix aM;
614 aM.translate(GRID_TO_WALL_DISTANCE/fXScale, GRID_TO_WALL_DISTANCE/fYScale, GRID_TO_WALL_DISTANCE/fZScale);
615 aM.scale( fXScale, fYScale, fZScale );
616 E3DModifySceneSnapRectUpdater aUpdater(lcl_getE3dScene(m_xOuterGroupShape));
617
618 xShapes2->SvxShape::setPropertyValue( UNO_NAME_3D_TRANSFORM_MATRIX
619 , uno::Any(BaseGFXHelper::B3DHomMatrixToHomogenMatrix(aM)) );
620 }
621 catch( const uno::Exception& )
622 {
623 TOOLS_WARN_EXCEPTION("chart2", "" );
624 }
625 }
626
627 m_aCurrentPosWithoutAxes = m_aAvailablePosIncludingAxes;
628 m_aCurrentSizeWithoutAxes = m_aAvailableSizeIncludingAxes;
629 adjustPosAndSize_3d( m_aAvailablePosIncludingAxes, m_aAvailableSizeIncludingAxes );
630 }
631
632 basegfx::B2IRectangle VDiagram::getCurrentRectangle() const
633 {
634 return BaseGFXHelper::makeRectangle(m_aCurrentPosWithoutAxes,m_aCurrentSizeWithoutAxes);
635 }
636
637 void VDiagram::reduceToMinimumSize()
638 {
639 if( !m_xOuterGroupShape.is() )
640 return;
641
642 awt::Size aMaxSize( m_aAvailableSizeIncludingAxes );
643 awt::Point aMaxPos( m_aAvailablePosIncludingAxes );
644
645 sal_Int32 nNewWidth = std::round(aMaxSize.Width/2.2);
646 sal_Int32 nNewHeight = std::round(aMaxSize.Height/2.2);
647 awt::Size aNewSize( nNewWidth, nNewHeight );
648 awt::Point aNewPos( aMaxPos );
649 aNewPos.X += nNewWidth;
650 aNewPos.Y += nNewHeight;
651
652 adjustPosAndSize( aNewPos, aNewSize );
653 }
654
655 ::basegfx::B2IRectangle VDiagram::adjustInnerSize( const ::basegfx::B2IRectangle& rConsumedOuterRect )
656 {
657 awt::Point aNewPos = m_aCurrentPosWithoutAxes;
658 awt::Size aNewSize = m_aCurrentSizeWithoutAxes;
659
660 basegfx::B2IRectangle aAvailableOuterRect =
661 BaseGFXHelper::makeRectangle(m_aAvailablePosIncludingAxes, m_aAvailableSizeIncludingAxes);
662
663 sal_Int32 nDeltaWidth = aAvailableOuterRect.getWidth() - rConsumedOuterRect.getWidth();
664 sal_Int32 nDeltaHeight = aAvailableOuterRect.getHeight() - rConsumedOuterRect.getHeight();
665 if( (aNewSize.Width + nDeltaWidth) < aAvailableOuterRect.getWidth()/3 )
666 nDeltaWidth = aAvailableOuterRect.getWidth()/3 - aNewSize.Width;
667 aNewSize.Width += nDeltaWidth;
668
669 if( (aNewSize.Height + nDeltaHeight) < aAvailableOuterRect.getHeight()/3 )
670 nDeltaHeight = aAvailableOuterRect.getHeight()/3 - aNewSize.Height;
671 aNewSize.Height += nDeltaHeight;
672
673 sal_Int32 nDiffLeft = rConsumedOuterRect.getMinX() - aAvailableOuterRect.getMinX();
674 sal_Int32 nDiffRight = aAvailableOuterRect.getMaxX() - rConsumedOuterRect.getMaxX();
675 if( nDiffLeft >= 0 )
676 aNewPos.X -= nDiffLeft;
677 else if( nDiffRight >= 0 )
678 {
679 if( nDiffRight > -nDiffLeft )
680 aNewPos.X += abs(nDiffLeft);
681 else if( nDiffRight > abs(nDeltaWidth) )
682 aNewPos.X += nDiffRight;
683 else
684 aNewPos.X += abs(nDeltaWidth);
685 }
686
687 sal_Int32 nDiffUp = rConsumedOuterRect.getMinY() - aAvailableOuterRect.getMinY();
688 sal_Int32 nDiffDown = aAvailableOuterRect.getMaxY() - rConsumedOuterRect.getMaxY();
689 if( nDiffUp >= 0 )
690 aNewPos.Y -= nDiffUp;
691 else if( nDiffDown >= 0 )
692 {
693 if( nDiffDown > -nDiffUp )
694 aNewPos.Y += abs(nDiffUp);
695 else if( nDiffDown > abs(nDeltaHeight) )
696 aNewPos.Y += nDiffDown;
697 else
698 aNewPos.Y += abs(nDeltaHeight);
699 }
700
701 return adjustPosAndSize( aNewPos, aNewSize );
702 }
703
704 } //namespace chart
705
706 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE