LibreOffice Module oox (master)  1
plotareaconverter.cxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
21 
22 #include <com/sun/star/chart/XChartDocument.hpp>
23 #include <com/sun/star/chart/XDiagramPositioning.hpp>
24 #include <com/sun/star/chart2/XChartDocument.hpp>
25 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
26 #include <com/sun/star/chart2/XDiagram.hpp>
27 #include <com/sun/star/drawing/Direction3D.hpp>
28 #include <com/sun/star/drawing/ProjectionMode.hpp>
29 #include <com/sun/star/drawing/ShadeMode.hpp>
30 #include <osl/diagnose.h>
35 #include <oox/token/namespaces.hxx>
36 #include <oox/token/properties.hxx>
37 #include <oox/token/tokens.hxx>
38 #include <tools/helpers.hxx>
39 
40 namespace oox::drawingml::chart {
41 
42 using namespace ::com::sun::star;
43 using namespace ::com::sun::star::chart2;
44 using namespace ::com::sun::star::uno;
45 
46 namespace {
47 
50 struct AxesSetModel
51 {
52  typedef ModelVector< TypeGroupModel > TypeGroupVector;
53  typedef ModelMap< sal_Int32, AxisModel > AxisMap;
54 
55  TypeGroupVector maTypeGroups;
56  AxisMap maAxes;
57 
58  explicit AxesSetModel() {}
59 };
60 
62 class AxesSetConverter : public ConverterBase< AxesSetModel >
63 {
64 public:
65  explicit AxesSetConverter( const ConverterRoot& rParent, AxesSetModel& rModel );
66 
69  void convertFromModel(
70  const Reference< XDiagram >& rxDiagram,
71  View3DModel& rView3DModel,
72  sal_Int32 nAxesSetIdx,
73  bool bSupportsVaryColorsByPoint,
74  bool bUseFixedInnerSize );
75 
77  const OUString& getAutomaticTitle() const { return maAutoTitle; }
79  bool is3dChart() const { return mb3dChart; }
81  bool isWall3dChart() const { return mbWall3dChart; }
83  bool isPieChart() const { return mbPieChart; }
84 
85 private:
86  OUString maAutoTitle;
87  bool mb3dChart;
89  bool mbPieChart;
90 };
91 
92 AxesSetConverter::AxesSetConverter( const ConverterRoot& rParent, AxesSetModel& rModel ) :
93  ConverterBase< AxesSetModel >( rParent, rModel ),
94  mb3dChart( false ),
95  mbWall3dChart( false ),
96  mbPieChart( false )
97 {
98 }
99 
100 ModelRef< AxisModel > lclGetOrCreateAxis( const AxesSetModel::AxisMap& rFromAxes, sal_Int32 nAxisIdx, sal_Int32 nDefTypeId, bool bMSO2007Doc )
101 {
102  ModelRef< AxisModel > xAxis = rFromAxes.get( nAxisIdx );
103  if( !xAxis )
104  xAxis.create( nDefTypeId, bMSO2007Doc ).mbDeleted = true; // missing axis is invisible
105  return xAxis;
106 }
107 
108 void AxesSetConverter::convertFromModel( const Reference< XDiagram >& rxDiagram,
109  View3DModel& rView3DModel, sal_Int32 nAxesSetIdx,
110  bool bSupportsVaryColorsByPoint, bool bUseFixedInnerSize)
111 {
112  // create type group converter objects for all type groups
113  typedef RefVector< TypeGroupConverter > TypeGroupConvVector;
114  TypeGroupConvVector aTypeGroups;
115  for (auto const& typeGroup : mrModel.maTypeGroups)
116  aTypeGroups.push_back( std::make_shared<TypeGroupConverter>( *this, *typeGroup ) );
117 
118  OSL_ENSURE( !aTypeGroups.empty(), "AxesSetConverter::convertFromModel - no type groups in axes set" );
119  if( aTypeGroups.empty() )
120  return;
121 
122  try
123  {
124  // first type group needed for coordinate system and axis conversion
125  TypeGroupConverter& rFirstTypeGroup = *aTypeGroups.front();
126 
127  // get automatic chart title, if there is only one type group
128  if( aTypeGroups.size() == 1 )
129  maAutoTitle = rFirstTypeGroup.getSingleSeriesTitle();
130 
131  /* Create a coordinate system. For now, all type groups from all axes sets
132  have to be inserted into one coordinate system. Later, chart2 should
133  support using one coordinate system for each axes set. */
134  Reference< XCoordinateSystem > xCoordSystem;
135  Reference< XCoordinateSystemContainer > xCoordSystemCont( rxDiagram, UNO_QUERY_THROW );
136  Sequence< Reference< XCoordinateSystem > > aCoordSystems = xCoordSystemCont->getCoordinateSystems();
137  if( aCoordSystems.hasElements() )
138  {
139  OSL_ENSURE( aCoordSystems.getLength() == 1, "AxesSetConverter::convertFromModel - too many coordinate systems" );
140  xCoordSystem = aCoordSystems[ 0 ];
141  OSL_ENSURE( xCoordSystem.is(), "AxesSetConverter::convertFromModel - invalid coordinate system" );
142  }
143  else
144  {
145  xCoordSystem = rFirstTypeGroup.createCoordinateSystem();
146  if( xCoordSystem.is() )
147  xCoordSystemCont->addCoordinateSystem( xCoordSystem );
148  }
149 
150  // 3D view settings
151  mb3dChart = rFirstTypeGroup.is3dChart();
152  mbWall3dChart = rFirstTypeGroup.isWall3dChart();
153  mbPieChart = rFirstTypeGroup.getTypeInfo().meTypeCategory == TYPECATEGORY_PIE;
154  if( mb3dChart )
155  {
156  View3DConverter aView3DConv( *this, rView3DModel );
157  aView3DConv.convertFromModel( rxDiagram, rFirstTypeGroup );
158  }
159 
160  /* Convert all chart type groups. Each type group will add its series
161  to the data provider attached to the chart document. */
162  if( xCoordSystem.is() )
163  {
164  bool bMSO2007Doc = getFilter().isMSO2007Document();
165  // convert all axes (create missing axis models)
166  ModelRef< AxisModel > xXAxis = lclGetOrCreateAxis( mrModel.maAxes, API_X_AXIS, rFirstTypeGroup.getTypeInfo().mbCategoryAxis ? C_TOKEN( catAx ) : C_TOKEN( valAx ), bMSO2007Doc );
167  ModelRef< AxisModel > xYAxis = lclGetOrCreateAxis( mrModel.maAxes, API_Y_AXIS, C_TOKEN( valAx ), bMSO2007Doc );
168 
169  AxisConverter aXAxisConv( *this, *xXAxis );
170  aXAxisConv.convertFromModel(xCoordSystem, aTypeGroups, xYAxis.get(), nAxesSetIdx,
171  API_X_AXIS, bUseFixedInnerSize);
172  AxisConverter aYAxisConv( *this, *xYAxis );
173  aYAxisConv.convertFromModel(xCoordSystem, aTypeGroups, xXAxis.get(), nAxesSetIdx,
174  API_Y_AXIS, bUseFixedInnerSize);
175 
176  if( rFirstTypeGroup.isDeep3dChart() )
177  {
178  ModelRef< AxisModel > xZAxis = lclGetOrCreateAxis( mrModel.maAxes, API_Z_AXIS, C_TOKEN( serAx ), bMSO2007Doc );
179  AxisConverter aZAxisConv( *this, *xZAxis );
180  aZAxisConv.convertFromModel(xCoordSystem, aTypeGroups, nullptr, nAxesSetIdx,
181  API_Z_AXIS, bUseFixedInnerSize);
182  }
183 
184  // convert all chart type groups, this converts all series data and formatting
185  for (auto const& typeGroup : aTypeGroups)
186  typeGroup->convertFromModel( rxDiagram, xCoordSystem, nAxesSetIdx, bSupportsVaryColorsByPoint );
187  }
188  }
189  catch( Exception& )
190  {
191  }
192 }
193 
194 } // namespace
195 
196 View3DConverter::View3DConverter( const ConverterRoot& rParent, View3DModel& rModel ) :
197  ConverterBase< View3DModel >( rParent, rModel )
198 {
199 }
200 
202 {
203 }
204 
206 {
207  namespace cssd = ::com::sun::star::drawing;
208  PropertySet aPropSet( rxDiagram );
209 
210  sal_Int32 nRotationY = 0;
211  sal_Int32 nRotationX = 0;
212  bool bRightAngled = false;
213  sal_Int32 nAmbientColor = 0;
214  sal_Int32 nLightColor = 0;
215 
216  if( rTypeGroup.getTypeInfo().meTypeCategory == TYPECATEGORY_PIE )
217  {
218  // Y rotation used as 'first pie slice angle' in 3D pie charts
219  rTypeGroup.convertPieRotation( aPropSet, mrModel.monRotationY.get( 0 ) );
220  // X rotation a.k.a. elevation (map OOXML [0..90] to Chart2 [-90,0])
221  nRotationX = getLimitedValue< sal_Int32, sal_Int32 >( mrModel.monRotationX.get( 15 ), 0, 90 ) - 90;
222  // no right-angled axes in pie charts
223  bRightAngled = false;
224  // ambient color (Gray 30%)
225  nAmbientColor = 0xB3B3B3;
226  // light color (Gray 70%)
227  nLightColor = 0x4C4C4C;
228  }
229  else // 3D bar/area/line charts
230  {
231  // Y rotation (OOXML [0..359], Chart2 [-179,180])
232  nRotationY = mrModel.monRotationY.get( 20 );
233  // X rotation a.k.a. elevation (OOXML [-90..90], Chart2 [-179,180])
234  nRotationX = getLimitedValue< sal_Int32, sal_Int32 >( mrModel.monRotationX.get( 15 ), -90, 90 );
235  // right-angled axes
236  bRightAngled = mrModel.mbRightAngled;
237  // ambient color (Gray 20%)
238  nAmbientColor = 0xCCCCCC;
239  // light color (Gray 60%)
240  nLightColor = 0x666666;
241  }
242 
243  // Y rotation (map OOXML [0..359] to Chart2 [-179,180])
244  nRotationY = NormAngle180(nRotationY);
245  /* Perspective (map OOXML [0..200] to Chart2 [0,100]). Seems that MSO 2007 is
246  buggy here, the XML plugin of MSO 2003 writes the correct perspective in
247  the range from 0 to 100. We will emulate the wrong behaviour of MSO 2007. */
248  sal_Int32 nPerspective = getLimitedValue< sal_Int32, sal_Int32 >( mrModel.mnPerspective / 2, 0, 100 );
249  // projection mode (parallel axes, if right-angled, #i90360# or if perspective is at 0%)
250  bool bParallel = bRightAngled || (nPerspective == 0);
251  cssd::ProjectionMode eProjMode = bParallel ? cssd::ProjectionMode_PARALLEL : cssd::ProjectionMode_PERSPECTIVE;
252 
253  // set rotation properties
254  aPropSet.setProperty( PROP_RightAngledAxes, bRightAngled );
255  aPropSet.setProperty( PROP_RotationVertical, nRotationY );
256  aPropSet.setProperty( PROP_RotationHorizontal, nRotationX );
257  aPropSet.setProperty( PROP_Perspective, nPerspective );
258  aPropSet.setProperty( PROP_D3DScenePerspective, eProjMode );
259 
260  // set light settings
261  aPropSet.setProperty( PROP_D3DSceneShadeMode, cssd::ShadeMode_FLAT );
262  aPropSet.setProperty( PROP_D3DSceneAmbientColor, nAmbientColor );
263  aPropSet.setProperty( PROP_D3DSceneLightOn1, false );
264  aPropSet.setProperty( PROP_D3DSceneLightOn2, true );
265  aPropSet.setProperty( PROP_D3DSceneLightColor2, nLightColor );
266  aPropSet.setProperty( PROP_D3DSceneLightDirection2, cssd::Direction3D( 0.2, 0.4, 1.0 ) );
267 }
268 
270  ConverterBase< WallFloorModel >( rParent, rModel )
271 {
272 }
273 
275 {
276 }
277 
279 {
280  bool bMSO2007Doc = getFilter().isMSO2007Document();
281  if( rxDiagram.is() )
282  {
283  PropertySet aPropSet;
284  switch( eObjType )
285  {
286  case OBJECTTYPE_FLOOR: aPropSet.set( rxDiagram->getFloor() ); break;
287  case OBJECTTYPE_WALL: aPropSet.set( rxDiagram->getWall() ); break;
288  default: OSL_FAIL( "WallFloorConverter::convertFromModel - invalid object type" );
289  }
290  if( aPropSet.is() )
292  }
293 }
294 
296  ConverterBase< DataTableModel >( rParent, rModel )
297 {
298 }
299 
301 {
302 }
303 
305 {
306  PropertySet aPropSet( rxDiagram );
308  aPropSet.setProperty( PROP_DataTableHBorder, mrModel.mbShowHBorder );
310  aPropSet.setProperty( PROP_DataTableVBorder, mrModel.mbShowVBorder);
312  aPropSet.setProperty( PROP_DataTableOutline, mrModel.mbShowOutline );
313 }
314 
316  ConverterBase< PlotAreaModel >( rParent, rModel ),
317  mb3dChart( false ),
318  mbWall3dChart( false ),
319  mbPieChart( false )
320 {
321 }
322 
324 {
325 }
326 
328 {
329  /* Create the diagram object and attach it to the chart document. One
330  diagram is used to carry all coordinate systems and data series. */
331  Reference< XDiagram > xDiagram;
332  try
333  {
334  xDiagram.set( createInstance( "com.sun.star.chart2.Diagram" ), UNO_QUERY_THROW );
335  getChartDocument()->setFirstDiagram( xDiagram );
336  }
337  catch( Exception& )
338  {
339  }
340 
341  // store all axis models in a map, keyed by axis identifier
342  typedef ModelMap< sal_Int32, AxisModel > AxisMap;
343  AxisMap aAxisMap;
344  std::vector<sal_Int32>rValAxisIds;
345  std::vector<sal_Int32>rRealValAxisIds;
346 
347  for (auto const& atypeGroup : mrModel.maTypeGroups)
348  {
349  if (atypeGroup->maAxisIds.size() > 1)
350  {
351  // let's collect which axId belongs to the Y Axis according to maTypeGroups
352  rRealValAxisIds.push_back(atypeGroup->maAxisIds[1]);
353  }
354  }
355 
356  for (auto const& axis : mrModel.maAxes)
357  {
358  OSL_ENSURE( axis->mnAxisId >= 0, "PlotAreaConverter::convertFromModel - invalid axis identifier" );
359  OSL_ENSURE( !aAxisMap.has( axis->mnAxisId ), "PlotAreaConverter::convertFromModel - axis identifiers not unique" );
360  if( axis->mnAxisId != -1 )
361  aAxisMap[ axis->mnAxisId ] = axis;
362 
363  if ( axis->mnAxisId != -1 && axis->mnTypeId == C_TOKEN(valAx) )
364  {
365  for (size_t i = 0; i < rRealValAxisIds.size(); i++)
366  {
367  if (axis->mnAxisId == rRealValAxisIds[i])
368  {
369  // let's collect which axId belongs to the Y Axis according to maAxes
370  rValAxisIds.push_back(axis->mnAxisId);
371  }
372  }
373  }
374  }
375 
376  // group the type group models into different axes sets
377  typedef ModelVector< AxesSetModel > AxesSetVector;
378  AxesSetVector aAxesSets;
379  sal_Int32 nMaxSeriesIdx = -1;
380  for (auto const& typeGroup : mrModel.maTypeGroups)
381  {
382  if( !typeGroup->maSeries.empty() )
383  {
384  // try to find a compatible axes set for the type group
385  AxesSetModel* pAxesSet = nullptr;
386  for (auto const& axesSet : aAxesSets)
387  {
388  if( axesSet->maTypeGroups.front()->maAxisIds == typeGroup->maAxisIds )
389  {
390  pAxesSet = axesSet.get();
391  if (pAxesSet)
392  break;
393  }
394  }
395 
396  // not possible to insert into an existing axes set -> start a new axes set
397  if( !pAxesSet )
398  {
399  pAxesSet = &aAxesSets.create();
400  // find axis models used by the type group
401  const std::vector<sal_Int32>& rAxisIds = typeGroup->maAxisIds;
402  if( !rAxisIds.empty() )
403  pAxesSet->maAxes[ API_X_AXIS ] = aAxisMap.get( rAxisIds[ 0 ] );
404  if( rAxisIds.size() >= 2 )
405  pAxesSet->maAxes[ API_Y_AXIS ] = aAxisMap.get( rAxisIds[ 1 ] );
406  if( rAxisIds.size() >= 3 )
407  pAxesSet->maAxes[ API_Z_AXIS ] = aAxisMap.get( rAxisIds[ 2 ] );
408  }
409 
410  // insert the type group model
411  pAxesSet->maTypeGroups.push_back( typeGroup );
412 
413  // collect the maximum series index for automatic series formatting
414  for (auto const& elemSeries : typeGroup->maSeries)
415  nMaxSeriesIdx = ::std::max( nMaxSeriesIdx, elemSeries->mnIndex );
416  }
417  }
418  getFormatter().setMaxSeriesIndex( nMaxSeriesIdx );
419 
420  // varying point colors only for single series in single chart type
421  bool bSupportsVaryColorsByPoint = mrModel.maTypeGroups.size() == 1;
422 
423  bool bIsCombinedChart = mrModel.maTypeGroups.size() == 2 &&
424  mrModel.maTypeGroups[0]->mnTypeId != mrModel.maTypeGroups[1]->mnTypeId;
425 
426  // convert all axes sets, and check which axis is attached to the first maTypeGroups
427  sal_Int32 nStartAxesSetIdx = bIsCombinedChart ? ((rValAxisIds.size() > 1 && aAxesSets.size() > 0 && aAxesSets[0]->maAxes.count( API_Y_AXIS )
428  && aAxesSets[0]->maAxes[ API_Y_AXIS ]->mnAxisId != rValAxisIds[0] ) ? 1 : 0)
429  : 0;
430  sal_Int32 nAxesSetIdx = nStartAxesSetIdx;
431 
432  bool bUseFixedInnerSize = false;
433  if (mrModel.mxLayout && !mrModel.mxLayout->mbAutoLayout)
434  bUseFixedInnerSize = mrModel.mxLayout->mnTarget == XML_inner;
435 
436  for (auto const& axesSet : aAxesSets)
437  {
438  AxesSetConverter aAxesSetConv(*this, *axesSet);
439  aAxesSetConv.convertFromModel(xDiagram, rView3DModel, nAxesSetIdx,
440  bSupportsVaryColorsByPoint, bUseFixedInnerSize);
441  if(nAxesSetIdx == nStartAxesSetIdx)
442  {
443  maAutoTitle = aAxesSetConv.getAutomaticTitle();
444  mb3dChart = aAxesSetConv.is3dChart();
445  mbWall3dChart = aAxesSetConv.isWall3dChart();
446  mbPieChart = aAxesSetConv.isPieChart();
447  }
448  else
449  {
450  maAutoTitle.clear();
451  }
452  nAxesSetIdx = 1 - nAxesSetIdx;
453  }
454 
455  DataTableConverter dataTableConverter (*this, mrModel.mxDataTable.getOrCreate());
456  dataTableConverter.convertFromModel(xDiagram);
457  // plot area formatting
458  if( xDiagram.is() && !mb3dChart )
459  {
460  PropertySet aPropSet( xDiagram->getWall() );
462  }
463 }
464 
466 {
468  LayoutConverter aLayoutConv( *this, rLayout );
469  awt::Rectangle aDiagramRect;
470  if( !aLayoutConv.calcAbsRectangle( aDiagramRect ) )
471  return;
472 
473  try
474  {
475  namespace cssc = ::com::sun::star::chart;
476  Reference< cssc::XChartDocument > xChart1Doc( getChartDocument(), UNO_QUERY_THROW );
477  Reference< cssc::XDiagramPositioning > xPositioning( xChart1Doc->getDiagram(), UNO_QUERY_THROW );
478  // for pie charts, always set inner plot area size to exclude the data labels as Excel does
479  sal_Int32 nTarget = (mbPieChart && (rLayout.mnTarget == XML_outer)) ? XML_inner : rLayout.mnTarget;
480  switch( nTarget )
481  {
482  case XML_inner:
483  xPositioning->setDiagramPositionExcludingAxes( aDiagramRect );
484  break;
485  case XML_outer:
486  xPositioning->setDiagramPositionIncludingAxes( aDiagramRect );
487  break;
488  default:
489  OSL_FAIL( "PlotAreaConverter::convertPositionFromModel - unknown positioning target" );
490  }
491  }
492  catch( Exception& )
493  {
494  }
495 }
496 
497 } // namespace oox
498 
499 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
bool calcAbsRectangle(css::awt::Rectangle &orRect) const
Tries to calculate the absolute position and size from the contained OOXML layout model...
void convertPieRotation(PropertySet &rPropSet, sal_Int32 nOoxAngle) const
Sets the passed OOXML pie rotation at the passed property set.
PlotAreaConverter(const ConverterRoot &rParent, PlotAreaModel &rModel)
void convertPositionFromModel()
Converts the manual plot area position and size, if set.
OptValue< sal_Int32 > monRotationX
Height of the 3D view, relative to chart width.
TypeCategory meTypeCategory
Unique chart type identifier.
DataTableConverter(const ConverterRoot &rParent, DataTableModel &rModel)
const sal_Int32 API_Y_AXIS
Base class of all converter classes.
void convertFromModel(const css::uno::Reference< css::chart2::XDiagram > &rxDiagram, ObjectType eObjType)
Converts the OOXML wall/floor model to a chart2 diagram.
void setMaxSeriesIndex(sal_Int32 nMaxSeriesIdx)
Sets the maximum series index used for color cycling/fading.
PictureOptionsRef mxPicOptions
Wall/floor frame formatting.
sal_Int32 mnPerspective
Depth of the 3D view, relative to chart width.
void convertFromModel(const css::uno::Reference< css::chart2::XDiagram > &rxDiagram)
Converts the OOXML data table model to a chart2 diagram.
css::uno::Reference< css::uno::XInterface > createInstance(const OUString &rServiceName) const
Creates an instance for the passed service name, using the process service factory.
void convertFromModel(View3DModel &rView3DModel)
Converts the OOXML plot area model to a chart2 diagram.
OUString maAutoTitle
AxisMap maAxes
All type groups containing data series.
ObjectType
Enumerates different object types for specific automatic formatting behaviour.
bool mb3dChart
const Type & get() const
Definition: helper.hxx:185
bool mbShowVBorder
Show Horizontal Border.
void convertFrameFormatting(PropertySet &rPropSet, const ModelRef< Shape > &rxShapeProp, ObjectType eObjType, sal_Int32 nSeriesIdx=-1)
Sets frame formatting properties to the passed property set.
AxisVector maAxes
All chart type groups contained in the chart.
Plot area containing axes and data series in 3D charts.
const sal_Int32 API_X_AXIS
bool is() const
Returns true, if the contained XPropertySet interface is valid.
Definition: propertyset.hxx:80
A wrapper for a UNO property set.
Definition: propertyset.hxx:57
sal_Int32 mnTarget
Mode for height.
Definition: modelbase.hxx:115
const sal_Int32 API_Z_AXIS
A layout converter calculates positions and sizes for various chart objects.
OptValue< sal_Int32 > monRotationY
Horizontal rotation in degrees.
void convertFromModel(const css::uno::Reference< css::chart2::XDiagram > &rxDiagram, TypeGroupConverter const &rTypeGroup)
Converts the OOXML plot area model to a chart2 diagram.
WallFloorConverter(const ConverterRoot &rParent, WallFloorModel &rModel)
void set(const css::uno::Reference< css::beans::XPropertySet > &rxPropSet)
Sets the passed UNO property set and releases the old UNO property set.
DataTableRef mxDataTable
Layout/position of the plot area.
Radar charts (linear or filled).
ChartModel & mrModel
bool mbShowOutline
Show Vertical Border.
::oox::core::XmlFilterBase & getFilter() const
Returns the filter object of the imported/exported document.
bool mbRightAngled
Eye distance to the 3D objects.
bool mbWall3dChart
bool mbPieChart
std::enable_if< std::is_signed< T >::value, T >::type NormAngle180(T angle)
Background and side wall in 3D charts.
css::uno::Reference< css::chart2::XChartDocument > const & getChartDocument() const
Returns the API chart document model.
LayoutRef mxLayout
Plot area frame formatting.
TypeGroupVector maTypeGroups
bool setProperty(sal_Int32 nPropId, const Type &rValue)
Puts the passed value into the property set.
const TypeGroupInfo & getTypeInfo() const
Returns the type info struct that describes this chart type group.
ObjectFormatter & getFormatter() const
Returns the object formatter.
ShapeRef mxShapeProp
All axes contained in the chart.