?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / xmloff / source / chart / SchXMLPlotAreaContext.cxx
blob3d8a8495f494e654841eff070611710eb1e00db7
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: SchXMLPlotAreaContext.cxx,v $
10 * $Revision: 1.47.38.1 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_xmloff.hxx"
33
34 #include "SchXMLPlotAreaContext.hxx"
35 #include "SchXMLImport.hxx"
36 #include "SchXMLSeries2Context.hxx"
37 #include "SchXMLTools.hxx"
38 #include <tools/debug.hxx>
39 #ifdef DBG_UTIL
40 #include <tools/string.hxx>
41 #endif
42
43 #include <comphelper/processfactory.hxx>
44 #include "xmlnmspe.hxx"
45 #include <xmloff/xmltoken.hxx>
46 #include <xmloff/xmlement.hxx>
47 #include <xmloff/nmspmap.hxx>
48 #include <xmloff/xmluconv.hxx>
49 #include <xmloff/prstylei.hxx>
50 #include <xmloff/xmlstyle.hxx>
51 #include "xexptran.hxx"
52 #include <cppuhelper/implbase1.hxx>
53
54 #include <com/sun/star/awt/Point.hpp>
55 #include <com/sun/star/awt/Size.hpp>
56
57 #include <com/sun/star/chart/ChartAxisLabelPosition.hpp>
58 #include <com/sun/star/chart/ChartAxisMarkPosition.hpp>
59 #include <com/sun/star/chart/ChartAxisPosition.hpp>
60 #include <com/sun/star/chart/XTwoAxisXSupplier.hpp>
61 #include <com/sun/star/chart/XTwoAxisYSupplier.hpp>
62 #include <com/sun/star/chart/XAxisZSupplier.hpp>
63 #include <com/sun/star/chart/XSecondAxisTitleSupplier.hpp>
64 #include <com/sun/star/chart/ChartDataRowSource.hpp>
65 #include <com/sun/star/chart/X3DDisplay.hpp>
66 #include <com/sun/star/chart/XStatisticDisplay.hpp>
67
68 #include <com/sun/star/chart2/XChartDocument.hpp>
69 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
70 #include <com/sun/star/chart2/data/XRangeXMLConversion.hpp>
71 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
72 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
73 #include <com/sun/star/chart2/AxisType.hpp>
74 #include <com/sun/star/chart2/RelativePosition.hpp>
75
76 #include <com/sun/star/drawing/CameraGeometry.hpp>
77 #include <com/sun/star/drawing/FillStyle.hpp>
78 #include <com/sun/star/drawing/LineStyle.hpp>
79 #include <com/sun/star/lang/XServiceInfo.hpp>
80 #include <com/sun/star/util/XStringMapping.hpp>
81 #include <com/sun/star/xml/sax/XAttributeList.hpp>
82
83 using namespace com::sun::star;
84 using namespace ::xmloff::token;
85
86 using ::rtl::OUString;
87 using com::sun::star::uno::Reference;
88
89 static __FAR_DATA SvXMLEnumMapEntry aXMLAxisClassMap[] =
90 {
91 { XML_X, SCH_XML_AXIS_X },
92 { XML_Y, SCH_XML_AXIS_Y },
93 { XML_Z, SCH_XML_AXIS_Z },
94 { XML_TOKEN_INVALID, 0 }
95 };
96
97 namespace
98 {
99
100 struct lcl_AxisHasCategories : public ::std::unary_function< SchXMLAxis, bool >
101 {
102 bool operator() ( const SchXMLAxis & rAxis )
103 {
104 return rAxis.bHasCategories;
105 }
106 };
107
108 OUString lcl_ConvertRange( const ::rtl::OUString & rRange, const uno::Reference< chart2::XChartDocument > & xDoc )
109 {
110 OUString aResult = rRange;
111 if(!xDoc.is())
112 return aResult;
113 uno::Reference< chart2::data::XRangeXMLConversion > xConversion(
114 xDoc->getDataProvider(), uno::UNO_QUERY );
115 if( xConversion.is())
116 aResult = xConversion->convertRangeFromXML( rRange );
117 return aResult;
118 }
119
120 Reference< chart2::XAxis > lcl_getAxis( const Reference< chart2::XCoordinateSystem > xCooSys, sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex )
121 {
122 Reference< chart2::XAxis > xAxis;
123 try
124 {
125 xAxis = xCooSys->getAxisByDimension( nDimensionIndex, nAxisIndex );
126 }
127 catch( uno::Exception & )
128 {
129 }
130 return xAxis;
131 }
132
133 } // anonymous namespace
134
135 SchXML3DSceneAttributesHelper::SchXML3DSceneAttributesHelper( SvXMLImport& rImporter )
136 : SdXML3DSceneAttributesHelper( rImporter )
137 {
138 }
139
140 void SchXML3DSceneAttributesHelper::getCameraDefaultFromDiagram( const uno::Reference< chart::XDiagram >& xDiagram )
141 {
142 //different defaults for camera geometry necessary to workaround wrong behaviour in old chart
143 //in future make this version dependent if we have versioning (metastream) for ole objects
144
145 try
146 {
147 uno::Reference< beans::XPropertySet > xProp( xDiagram, uno::UNO_QUERY );
148 if( xProp.is() )
149 {
150 drawing::CameraGeometry aCamGeo;
151 xProp->getPropertyValue( ::rtl::OUString::createFromAscii("D3DCameraGeometry")) >>= aCamGeo;
152 maVRP.setX( aCamGeo.vrp.PositionX );
153 maVRP.setY( aCamGeo.vrp.PositionY );
154 maVRP.setZ( aCamGeo.vrp.PositionZ );
155 maVPN.setX( aCamGeo.vpn.DirectionX );
156 maVPN.setY( aCamGeo.vpn.DirectionY );
157 maVPN.setZ( aCamGeo.vpn.DirectionZ );
158 maVUP.setX( aCamGeo.vup.DirectionX );
159 maVUP.setY( aCamGeo.vup.DirectionY );
160 maVUP.setZ( aCamGeo.vup.DirectionZ );
161 }
162 }
163 catch( uno::Exception & rEx )
164 {
165 #ifdef DBG_UTIL
166 String aStr( rEx.Message );
167 ByteString aBStr( aStr, RTL_TEXTENCODING_ASCII_US );
168 DBG_ERROR1( "Exception caught for property NumberOfLines: %s", aBStr.GetBuffer());
169 #else
170 (void)rEx; // avoid warning for pro build
171 #endif
172 }
173 }
174
175 SchXML3DSceneAttributesHelper::~SchXML3DSceneAttributesHelper()
176 {
177 }
178
179 SchXMLPlotAreaContext::SchXMLPlotAreaContext(
180 SchXMLImportHelper& rImpHelper,
181 SvXMLImport& rImport, const rtl::OUString& rLocalName,
182 const rtl::OUString& rXLinkHRefAttributeToIndicateDataProvider,
183 uno::Sequence< chart::ChartSeriesAddress >& rSeriesAddresses,
184 ::rtl::OUString& rCategoriesAddress,
185 ::rtl::OUString& rChartAddress,
186 bool& rbHasRangeAtPlotArea,
187 sal_Bool & rAllRangeAddressesAvailable,
188 sal_Bool & rColHasLabels,
189 sal_Bool & rRowHasLabels,
190 chart::ChartDataRowSource & rDataRowSource,
191 SeriesDefaultsAndStyles& rSeriesDefaultsAndStyles,
192 const ::rtl::OUString& aChartTypeServiceName,
193 tSchXMLLSequencesPerIndex & rLSequencesPerIndex,
194 const awt::Size & rChartSize ) :
195 SvXMLImportContext( rImport, XML_NAMESPACE_CHART, rLocalName ),
196 mrImportHelper( rImpHelper ),
197 mrSeriesAddresses( rSeriesAddresses ),
198 mrCategoriesAddress( rCategoriesAddress ),
199 mrSeriesDefaultsAndStyles( rSeriesDefaultsAndStyles ),
200 mnNumOfLinesProp( 0 ),
201 mbStockHasVolume( sal_False ),
202 mnSeries( 0 ),
203 m_aGlobalSeriesImportInfo( rAllRangeAddressesAvailable ),
204 maSceneImportHelper( rImport ),
205 mbHasSize(false),
206 mbHasPosition(false),
207 mbPercentStacked(false),
208 m_bAxisPositionAttributeImported(false),
209 m_rXLinkHRefAttributeToIndicateDataProvider(rXLinkHRefAttributeToIndicateDataProvider),
210 mrChartAddress( rChartAddress ),
211 m_rbHasRangeAtPlotArea( rbHasRangeAtPlotArea ),
212 mrColHasLabels( rColHasLabels ),
213 mrRowHasLabels( rRowHasLabels ),
214 mrDataRowSource( rDataRowSource ),
215 maChartTypeServiceName( aChartTypeServiceName ),
216 mrLSequencesPerIndex( rLSequencesPerIndex ),
217 mbGlobalChartTypeUsedBySeries( false ),
218 maChartSize( rChartSize )
219 {
220 m_rbHasRangeAtPlotArea = false;
221
222 // get Diagram
223 uno::Reference< chart::XChartDocument > xDoc( rImpHelper.GetChartDocument(), uno::UNO_QUERY );
224 if( xDoc.is())
225 {
226 mxDiagram = xDoc->getDiagram();
227 mxNewDoc.set( xDoc, uno::UNO_QUERY );
228
229 maSceneImportHelper.getCameraDefaultFromDiagram( mxDiagram );
230 }
231 DBG_ASSERT( mxDiagram.is(), "Couldn't get XDiagram" );
232
233 // turn off all axes initially
234 uno::Any aFalseBool;
235 aFalseBool <<= (sal_Bool)(sal_False);
236
237 uno::Reference< lang::XServiceInfo > xInfo( mxDiagram, uno::UNO_QUERY );
238 uno::Reference< beans::XPropertySet > xProp( mxDiagram, uno::UNO_QUERY );
239 if( xInfo.is() &&
240 xProp.is())
241 {
242 try
243 {
244 if( xInfo->supportsService( rtl::OUString::createFromAscii( "com.sun.star.chart.ChartAxisXSupplier" )))
245 {
246 xProp->setPropertyValue(
247 rtl::OUString::createFromAscii( "HasXAxis" ), aFalseBool );
248 xProp->setPropertyValue(
249 rtl::OUString::createFromAscii( "HasXAxisGrid" ), aFalseBool );
250 xProp->setPropertyValue(
251 rtl::OUString::createFromAscii( "HasXAxisDescription" ), aFalseBool );
252 }
253 if( xInfo->supportsService( rtl::OUString::createFromAscii( "com.sun.star.chart.ChartTwoAxisXSupplier" )))
254 {
255 xProp->setPropertyValue(
256 rtl::OUString::createFromAscii( "HasSecondaryXAxis" ), aFalseBool );
257 xProp->setPropertyValue(
258 rtl::OUString::createFromAscii( "HasSecondaryXAxisDescription" ), aFalseBool );
259 }
260
261 if( xInfo->supportsService( rtl::OUString::createFromAscii( "com.sun.star.chart.ChartAxisYSupplier" )))
262 {
263 xProp->setPropertyValue(
264 rtl::OUString::createFromAscii( "HasYAxis" ), aFalseBool );
265 xProp->setPropertyValue(
266 rtl::OUString::createFromAscii( "HasYAxisGrid" ), aFalseBool );
267 xProp->setPropertyValue(
268 rtl::OUString::createFromAscii( "HasYAxisDescription" ), aFalseBool );
269 }
270 if( xInfo->supportsService( rtl::OUString::createFromAscii( "com.sun.star.chart.ChartTwoAxisYSupplier" )))
271 {
272 xProp->setPropertyValue(
273 rtl::OUString::createFromAscii( "HasSecondaryYAxis" ), aFalseBool );
274 xProp->setPropertyValue(
275 rtl::OUString::createFromAscii( "HasSecondaryYAxisDescription" ), aFalseBool );
276 }
277
278 if( xInfo->supportsService( rtl::OUString::createFromAscii( "com.sun.star.chart.ChartAxisZSupplier" )))
279 {
280 xProp->setPropertyValue(
281 rtl::OUString::createFromAscii( "HasZAxis" ), aFalseBool );
282 xProp->setPropertyValue(
283 rtl::OUString::createFromAscii( "HasZAxisDescription" ), aFalseBool );
284 }
285 uno::Any aAny;
286 chart::ChartDataRowSource eSource = chart::ChartDataRowSource_COLUMNS;
287 aAny <<= eSource;
288 xProp->setPropertyValue( rtl::OUString::createFromAscii( "DataRowSource" ), aAny );
289 }
290 catch( beans::UnknownPropertyException & )
291 {
292 DBG_ERROR( "Property required by service not supported" );
293 }
294 }
295 }
296
297 SchXMLPlotAreaContext::~SchXMLPlotAreaContext()
298 {}
299
300 void SchXMLPlotAreaContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
301 {
302 uno::Any aTransMatrixAny;
303
304 // initialize size and position
305 uno::Reference< drawing::XShape > xDiaShape( mxDiagram, uno::UNO_QUERY );
306 bool bHasSizeWidth = false;
307 bool bHasSizeHeight = false;
308 bool bHasPositionX = false;
309 bool bHasPositionY = false;
310
311 // parse attributes
312 sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
313 const SvXMLTokenMap& rAttrTokenMap = mrImportHelper.GetPlotAreaAttrTokenMap();
314 uno::Reference< chart2::XChartDocument > xNewDoc( GetImport().GetModel(), uno::UNO_QUERY );
315
316 for( sal_Int16 i = 0; i < nAttrCount; i++ )
317 {
318 rtl::OUString sAttrName = xAttrList->getNameByIndex( i );
319 rtl::OUString aLocalName;
320 rtl::OUString aValue = xAttrList->getValueByIndex( i );
321 USHORT nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
322
323 switch( rAttrTokenMap.Get( nPrefix, aLocalName ))
324 {
325 case XML_TOK_PA_X:
326 GetImport().GetMM100UnitConverter().convertMeasure( maPosition.X, aValue );
327 bHasPositionX = true;
328 break;
329 case XML_TOK_PA_Y:
330 GetImport().GetMM100UnitConverter().convertMeasure( maPosition.Y, aValue );
331 bHasPositionY = true;
332 break;
333 case XML_TOK_PA_WIDTH:
334 GetImport().GetMM100UnitConverter().convertMeasure( maSize.Width, aValue );
335 bHasSizeWidth = true;
336 break;
337 case XML_TOK_PA_HEIGHT:
338 GetImport().GetMM100UnitConverter().convertMeasure( maSize.Height, aValue );
339 bHasSizeHeight = true;
340 break;
341 case XML_TOK_PA_STYLE_NAME:
342 msAutoStyleName = aValue;
343 break;
344 case XML_TOK_PA_CHART_ADDRESS:
345 mrChartAddress = lcl_ConvertRange( aValue, xNewDoc );
346 // indicator for getting data from the outside
347 m_rbHasRangeAtPlotArea = true;
348 break;
349 case XML_TOK_PA_DS_HAS_LABELS:
350 {
351 if( aValue.equals( ::xmloff::token::GetXMLToken( ::xmloff::token::XML_BOTH )))
352 mrColHasLabels = mrRowHasLabels = sal_True;
353 else if( aValue.equals( ::xmloff::token::GetXMLToken( ::xmloff::token::XML_ROW )))
354 mrRowHasLabels = sal_True;
355 else if( aValue.equals( ::xmloff::token::GetXMLToken( ::xmloff::token::XML_COLUMN )))
356 mrColHasLabels = sal_True;
357 }
358 break;
359 case XML_TOK_PA_TRANSFORM:
360 case XML_TOK_PA_VRP:
361 case XML_TOK_PA_VPN:
362 case XML_TOK_PA_VUP:
363 case XML_TOK_PA_PROJECTION:
364 case XML_TOK_PA_DISTANCE:
365 case XML_TOK_PA_FOCAL_LENGTH:
366 case XML_TOK_PA_SHADOW_SLANT:
367 case XML_TOK_PA_SHADE_MODE:
368 case XML_TOK_PA_AMBIENT_COLOR:
369 case XML_TOK_PA_LIGHTING_MODE:
370 maSceneImportHelper.processSceneAttribute( nPrefix, aLocalName, aValue );
371 break;
372 }
373 }
374
375 mbHasSize = bHasSizeWidth && bHasSizeHeight;
376 mbHasPosition = bHasPositionX && bHasPositionY;
377
378 if( ! mxNewDoc.is())
379 {
380 uno::Reference< beans::XPropertySet > xDocProp( mrImportHelper.GetChartDocument(), uno::UNO_QUERY );
381 if( xDocProp.is())
382 {
383 try
384 {
385 uno::Any aAny;
386 aAny <<= (sal_Bool)(mrColHasLabels);
387 xDocProp->setPropertyValue(
388 ::rtl::OUString::createFromAscii( "DataSourceLabelsInFirstColumn" ),
389 aAny );
390
391 aAny <<= (sal_Bool)(mrRowHasLabels);
392 xDocProp->setPropertyValue(
393 ::rtl::OUString::createFromAscii( "DataSourceLabelsInFirstRow" ),
394 aAny );
395 }
396 catch( beans::UnknownPropertyException & )
397 {
398 DBG_ERRORFILE( "Properties missing" );
399 }
400 }
401 }
402
403 // set properties
404 uno::Reference< beans::XPropertySet > xProp( mxDiagram, uno::UNO_QUERY );
405 if( msAutoStyleName.getLength())
406 {
407 if( xProp.is())
408 {
409 const SvXMLStylesContext* pStylesCtxt = mrImportHelper.GetAutoStylesContext();
410 if( pStylesCtxt )
411 {
412 const SvXMLStyleContext* pStyle = pStylesCtxt->FindStyleChildContext(
413 mrImportHelper.GetChartFamilyID(), msAutoStyleName );
414
415 XMLPropStyleContext* pPropStyleContext =
416 const_cast< XMLPropStyleContext * >(
417 dynamic_cast< const XMLPropStyleContext * >( pStyle ) );
418 if( pPropStyleContext )
419 {
420 pPropStyleContext->FillPropertySet( xProp );
421
422 // get the data row source that was set without having data
423 xProp->getPropertyValue( ::rtl::OUString::createFromAscii("DataRowSource"))
424 >>= mrDataRowSource;
425
426 //lines on/off
427 //this old property is not supported fully anymore with the new chart, so we need to get the information a little bit different from similar properties
428 mrSeriesDefaultsAndStyles.maLinesOnProperty = SchXMLTools::getPropertyFromContext(
429 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Lines")), pPropStyleContext, pStylesCtxt );
430
431 //handle automatic position and size
432 bool bAutoSize = false;
433 bool bAutoPosition = false;
434 SchXMLTools::getPropertyFromContext(
435 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AutomaticSize")), pPropStyleContext, pStylesCtxt ) >>= bAutoSize;
436 SchXMLTools::getPropertyFromContext(
437 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AutomaticPosition")), pPropStyleContext, pStylesCtxt ) >>= bAutoPosition;
438 mbHasSize = mbHasSize && !bAutoSize;
439 mbHasPosition = mbHasPosition && !bAutoPosition;
440
441 //correct default starting angle for old 3D pies
442 if( SchXMLTools::isDocumentGeneratedWithOpenOfficeOlderThan3_0( GetImport().GetModel() ) )
443 {
444 bool bIs3d = false;
445 if( xProp.is() && ( xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Dim3D"))) >>= bIs3d ) &&
446 bIs3d )
447 {
448 if( maChartTypeServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.chart2.PieChartType" ))
449 || maChartTypeServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.chart2.DonutChartType" )) )
450 {
451 ::rtl::OUString aPropName( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("StartingAngle")) );
452 uno::Any aAStartingAngle( SchXMLTools::getPropertyFromContext( aPropName, pPropStyleContext, pStylesCtxt ) );
453 if( !aAStartingAngle.hasValue() )
454 xProp->setPropertyValue( aPropName, uno::makeAny(sal_Int32(0)) ) ;
455 }
456 }
457 }
458 }
459 }
460 }
461 }
462
463 //remember default values for dataseries
464 if(xProp.is())
465 try
466 {
467 mrSeriesDefaultsAndStyles.maSymbolTypeDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SymbolType")));
468 mrSeriesDefaultsAndStyles.maDataCaptionDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataCaption")));
469
470 mrSeriesDefaultsAndStyles.maErrorIndicatorDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ErrorIndicator")));
471 mrSeriesDefaultsAndStyles.maErrorCategoryDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ErrorCategory")));
472 mrSeriesDefaultsAndStyles.maConstantErrorLowDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ConstantErrorLow")));
473 mrSeriesDefaultsAndStyles.maConstantErrorHighDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ConstantErrorHigh")));
474 mrSeriesDefaultsAndStyles.maPercentageErrorDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PercentageError")));
475 mrSeriesDefaultsAndStyles.maErrorMarginDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ErrorMargin")));
476
477 mrSeriesDefaultsAndStyles.maMeanValueDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MeanValue")));
478 mrSeriesDefaultsAndStyles.maRegressionCurvesDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RegressionCurves")));
479
480 bool bStacked = false;
481 mrSeriesDefaultsAndStyles.maStackedDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Stacked")));
482 mrSeriesDefaultsAndStyles.maStackedDefault >>= bStacked;
483 mrSeriesDefaultsAndStyles.maPercentDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Percent")));
484 mrSeriesDefaultsAndStyles.maPercentDefault >>= mbPercentStacked;
485 mrSeriesDefaultsAndStyles.maStackedBarsConnectedDefault = xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("StackedBarsConnected")));
486
487 // deep
488 uno::Any aDeepProperty( xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Deep"))));
489 // #124488# old versions store a 3d area and 3D line deep chart with Deep==false => workaround for this
490 if( ! (bStacked || mbPercentStacked ))
491 {
492 if( SchXMLTools::isDocumentGeneratedWithOpenOfficeOlderThan2_3( GetImport().GetModel() ) )
493 {
494 bool bIs3d = false;
495 if( ( xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Dim3D"))) >>= bIs3d ) &&
496 bIs3d )
497 {
498 if( maChartTypeServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.chart2.AreaChartType" )) ||
499 maChartTypeServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.chart2.LineChartType" )) )
500 {
501 aDeepProperty <<= uno::makeAny( true );
502 }
503 }
504 }
505 }
506 mrSeriesDefaultsAndStyles.maDeepDefault = aDeepProperty;
507
508 xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NumberOfLines"))) >>= mnNumOfLinesProp;
509 xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Volume"))) >>= mbStockHasVolume;
510 }
511 catch( uno::Exception & rEx )
512 {
513 #ifdef DBG_UTIL
514 String aStr( rEx.Message );
515 ByteString aBStr( aStr, RTL_TEXTENCODING_ASCII_US );
516 DBG_ERROR1( "PlotAreaContext:EndElement(): Exception caught: %s", aBStr.GetBuffer());
517 #else
518 (void)rEx; // avoid warning for pro build
519 #endif
520 }
521 //
522
523 bool bCreateInternalDataProvider = false;
524 if( m_rXLinkHRefAttributeToIndicateDataProvider.equalsAscii( "." ) ) //data comes from the chart itself
525 bCreateInternalDataProvider = true;
526 else if( m_rXLinkHRefAttributeToIndicateDataProvider.equalsAscii( ".." ) ) //data comes from the parent application
527 bCreateInternalDataProvider = false;
528 else if( m_rXLinkHRefAttributeToIndicateDataProvider.getLength() ) //not supported so far to get the data by sibling objects -> fall back to chart itself
529 bCreateInternalDataProvider = true;
530 else if( !m_rbHasRangeAtPlotArea )
531 bCreateInternalDataProvider = true;
532
533 if( bCreateInternalDataProvider && mxNewDoc.is() )
534 {
535 // we have no complete range => we have own data, so switch the data
536 // provider to internal. Clone is not necessary, as we don't have any
537 // data yet.
538 mxNewDoc->createInternalDataProvider( false /* bCloneExistingData */ );
539 if( xProp.is() && mrDataRowSource!=chart::ChartDataRowSource_COLUMNS )
540 xProp->setPropertyValue( rtl::OUString::createFromAscii( "DataRowSource" ), uno::makeAny(mrDataRowSource) );
541 }
542 }
543
544 SvXMLImportContext* SchXMLPlotAreaContext::CreateChildContext(
545 USHORT nPrefix,
546 const rtl::OUString& rLocalName,
547 const uno::Reference< xml::sax::XAttributeList >& xAttrList )
548 {
549 SvXMLImportContext* pContext = 0;
550 const SvXMLTokenMap& rTokenMap = mrImportHelper.GetPlotAreaElemTokenMap();
551
552 switch( rTokenMap.Get( nPrefix, rLocalName ))
553 {
554 case XML_TOK_PA_AXIS:
555 {
556 bool bAddMissingXAxisForNetCharts = false;
557 bool bAdaptWrongPercentScaleValues = false;
558 if( SchXMLTools::isDocumentGeneratedWithOpenOfficeOlderThan2_3( GetImport().GetModel() ) )
559 {
560 //correct errors from older versions
561
562 // for NetCharts there were no xAxis exported to older files
563 // so we need to add the x axis here for those old NetChart files
564 if( maChartTypeServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.chart2.NetChartType" )) )
565 bAddMissingXAxisForNetCharts = true;
566
567 //Issue 59288
568 if( mbPercentStacked )
569 bAdaptWrongPercentScaleValues = true;
570 }
571
572 bool bAdaptXAxisOrientationForOld2DBarCharts = false;
573 if( SchXMLTools::isDocumentGeneratedWithOpenOfficeOlderThan2_4( GetImport().GetModel() ) )
574 {
575 //issue74660
576 if( maChartTypeServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.chart2.ColumnChartType" )) )
577 bAdaptXAxisOrientationForOld2DBarCharts = true;
578 }
579
580 pContext = new SchXMLAxisContext( mrImportHelper, GetImport(), rLocalName, mxDiagram, maAxes, mrCategoriesAddress,
581 bAddMissingXAxisForNetCharts, bAdaptWrongPercentScaleValues, bAdaptXAxisOrientationForOld2DBarCharts, m_bAxisPositionAttributeImported );
582 }
583 break;
584
585 case XML_TOK_PA_SERIES:
586 {
587 if( mxNewDoc.is())
588 {
589 pContext = new SchXMLSeries2Context(
590 mrImportHelper, GetImport(), rLocalName,
591 mxNewDoc, maAxes,
592 mrSeriesDefaultsAndStyles.maSeriesStyleList,
593 mnSeries,
594 mbStockHasVolume,
595 m_aGlobalSeriesImportInfo,
596 maChartTypeServiceName,
597 mrLSequencesPerIndex,
598 mbGlobalChartTypeUsedBySeries, maChartSize );
599 }
600 mnSeries++;
601 }
602 break;
603
604 case XML_TOK_PA_WALL:
605 pContext = new SchXMLWallFloorContext( mrImportHelper, GetImport(), nPrefix, rLocalName, mxDiagram,
606 SchXMLWallFloorContext::CONTEXT_TYPE_WALL );
607 break;
608 case XML_TOK_PA_FLOOR:
609 pContext = new SchXMLWallFloorContext( mrImportHelper, GetImport(), nPrefix, rLocalName, mxDiagram,
610 SchXMLWallFloorContext::CONTEXT_TYPE_FLOOR );
611 break;
612
613 case XML_TOK_PA_LIGHT_SOURCE:
614 pContext = maSceneImportHelper.create3DLightContext( nPrefix, rLocalName, xAttrList );
615 break;
616
617 // elements for stock charts
618 case XML_TOK_PA_STOCK_GAIN:
619 pContext = new SchXMLStockContext( mrImportHelper, GetImport(), nPrefix, rLocalName, mxDiagram,
620 SchXMLStockContext::CONTEXT_TYPE_GAIN );
621 break;
622 case XML_TOK_PA_STOCK_LOSS:
623 pContext = new SchXMLStockContext( mrImportHelper, GetImport(), nPrefix, rLocalName, mxDiagram,
624 SchXMLStockContext::CONTEXT_TYPE_LOSS );
625 break;
626 case XML_TOK_PA_STOCK_RANGE:
627 pContext = new SchXMLStockContext( mrImportHelper, GetImport(), nPrefix, rLocalName, mxDiagram,
628 SchXMLStockContext::CONTEXT_TYPE_RANGE );
629 break;
630
631 default:
632 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
633 }
634
635 return pContext;
636 }
637
638 void SchXMLPlotAreaContext::EndElement()
639 {
640 // set categories
641 if( mrCategoriesAddress.getLength() && mxNewDoc.is())
642 {
643 uno::Reference< chart2::data::XDataProvider > xDataProvider(
644 mxNewDoc->getDataProvider() );
645 // @todo: correct coordinate system index
646 sal_Int32 nDimension( 0 );
647 ::std::vector< SchXMLAxis >::const_iterator aIt(
648 ::std::find_if( maAxes.begin(), maAxes.end(), lcl_AxisHasCategories()));
649 if( aIt != maAxes.end())
650 nDimension = static_cast< sal_Int32 >( (*aIt).eClass );
651 SchXMLTools::CreateCategories(
652 xDataProvider, mxNewDoc, mrCategoriesAddress,
653 0 /* nCooSysIndex */,
654 nDimension, &mrLSequencesPerIndex );
655 }
656
657 uno::Reference< beans::XPropertySet > xDiaProp( mxDiagram, uno::UNO_QUERY );
658 if( xDiaProp.is())
659 {
660 sal_Bool bIsThreeDim = sal_False;
661 uno::Any aAny = xDiaProp->getPropertyValue( ::rtl::OUString::createFromAscii( "Dim3D" ));
662 aAny >>= bIsThreeDim;
663
664 // set 3d scene attributes
665 if( bIsThreeDim )
666 {
667 // set scene attributes at diagram
668 maSceneImportHelper.setSceneAttributes( xDiaProp );
669 }
670
671 // set correct number of lines at series
672 if( ! m_aGlobalSeriesImportInfo.rbAllRangeAddressesAvailable &&
673 mnNumOfLinesProp > 0 &&
674 maChartTypeServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.chart2.ColumnChartType" )))
675 {
676 try
677 {
678 xDiaProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "NumberOfLines" )),
679 uno::makeAny( mnNumOfLinesProp ));
680 }
681 catch( uno::Exception & rEx )
682 {
683 #ifdef DBG_UTIL
684 String aStr( rEx.Message );
685 ByteString aBStr( aStr, RTL_TEXTENCODING_ASCII_US );
686 DBG_ERROR1( "Exception caught for property NumberOfLines: %s", aBStr.GetBuffer());
687 #else
688 (void)rEx; // avoid warning for pro build
689 #endif
690 }
691 }
692
693 // #i32366# stock has volume
694 if( ( 0 == mxDiagram->getDiagramType().reverseCompareToAsciiL(
695 RTL_CONSTASCII_STRINGPARAM( "com.sun.star.chart.StockDiagram" ))) &&
696 mbStockHasVolume )
697 {
698 try
699 {
700 xDiaProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Volume" )),
701 uno::makeAny( true ));
702 }
703 catch( uno::Exception & rEx )
704 {
705 #ifdef DBG_UTIL
706 String aStr( rEx.Message );
707 ByteString aBStr( aStr, RTL_TEXTENCODING_ASCII_US );
708 DBG_ERROR1( "Exception caught for property Volume: %s", aBStr.GetBuffer());
709 #else
710 (void)rEx; // avoid warning for pro build
711 #endif
712 }
713 }
714 }
715
716 // set changed size and position after properties (esp. 3d)
717 uno::Reference< drawing::XShape > xDiaShape( mxDiagram, uno::UNO_QUERY );
718 if( xDiaShape.is())
719 {
720 if( mbHasSize )
721 xDiaShape->setSize( maSize );
722 if( mbHasPosition )
723 xDiaShape->setPosition( maPosition );
724 }
725
726 CorrectAxisPositions();
727 }
728
729 void SchXMLPlotAreaContext::CorrectAxisPositions()
730 {
731 ::rtl::OUString aODFVersionOfFile( GetImport().GetODFVersion() );
732
733 if( ( !aODFVersionOfFile.getLength() || aODFVersionOfFile.equalsAscii("1.0")
734 || aODFVersionOfFile.equalsAscii("1.1")
735 || ( aODFVersionOfFile.equalsAscii("1.2") && !m_bAxisPositionAttributeImported ) ) )
736 {
737 uno::Reference< chart2::XChartDocument > xNewDoc( mrImportHelper.GetChartDocument(), uno::UNO_QUERY );
738
739 try
740 {
741 Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( xNewDoc->getFirstDiagram(), uno::UNO_QUERY_THROW );
742 uno::Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq( xCooSysCnt->getCoordinateSystems());
743 if( aCooSysSeq.getLength() )
744 {
745 Reference< chart2::XCoordinateSystem > xCooSys( aCooSysSeq[0] );
746 if( xCooSys.is() )
747 {
748 Reference< chart2::XAxis > xMainXAxis = lcl_getAxis( xCooSys, 0, 0 );
749 Reference< chart2::XAxis > xMainYAxis = lcl_getAxis( xCooSys, 1, 0 );
750 //Reference< chart2::XAxis > xMajorZAxis = lcl_getAxis( xCooSys, 2, 0 );
751 Reference< chart2::XAxis > xSecondaryXAxis = lcl_getAxis( xCooSys, 0, 1 );
752 Reference< chart2::XAxis > xSecondaryYAxis = lcl_getAxis( xCooSys, 1, 1 );
753
754 uno::Reference< beans::XPropertySet > xMainXAxisProp( xMainXAxis, uno::UNO_QUERY );
755 uno::Reference< beans::XPropertySet > xMainYAxisProp( xMainYAxis, uno::UNO_QUERY );
756 uno::Reference< beans::XPropertySet > xSecondaryXAxisProp( xSecondaryXAxis, uno::UNO_QUERY );
757 uno::Reference< beans::XPropertySet > xSecondaryYAxisProp( xSecondaryYAxis, uno::UNO_QUERY );
758
759 if( xMainXAxisProp.is() && xMainYAxisProp.is() )
760 {
761 chart2::ScaleData aMainXScale = xMainXAxis->getScaleData();
762 if( 0 == maChartTypeServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.chart2.ScatterChartType" ) ) )
763 {
764 xMainYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
765 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_VALUE) );
766 double fCrossoverValue = 0.0;
767 aMainXScale.Origin >>= fCrossoverValue;
768 xMainYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverValue")
769 , uno::makeAny( fCrossoverValue ) );
770
771 if( aMainXScale.Orientation == chart2::AxisOrientation_REVERSE )
772 {
773 xMainYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("LabelPosition")
774 , uno::makeAny( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END) );
775 xMainYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("MarkPosition")
776 , uno::makeAny( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS) );
777 if( xSecondaryYAxisProp.is() )
778 xSecondaryYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
779 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START) );
780 }
781 else
782 {
783 xMainYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("LabelPosition")
784 , uno::makeAny( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START) );
785 xMainYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("MarkPosition")
786 , uno::makeAny( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS) );
787 if( xSecondaryYAxisProp.is() )
788 xSecondaryYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
789 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_END) );
790 }
791 }
792 else
793 {
794 if( aMainXScale.Orientation == chart2::AxisOrientation_REVERSE )
795 {
796 xMainYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
797 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_END) );
798 if( xSecondaryYAxisProp.is() )
799 xSecondaryYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
800 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START) );
801 }
802 else
803 {
804 xMainYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
805 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START) );
806 if( xSecondaryYAxisProp.is() )
807 xSecondaryYAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
808 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_END) );
809 }
810 }
811
812 chart2::ScaleData aMainYScale = xMainYAxis->getScaleData();
813 xMainXAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
814 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_VALUE) );
815 double fCrossoverValue = 0.0;
816 aMainYScale.Origin >>= fCrossoverValue;
817 xMainXAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverValue")
818 , uno::makeAny( fCrossoverValue ) );
819
820 if( aMainYScale.Orientation == chart2::AxisOrientation_REVERSE )
821 {
822 xMainXAxisProp->setPropertyValue( rtl::OUString::createFromAscii("LabelPosition")
823 , uno::makeAny( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END) );
824 xMainXAxisProp->setPropertyValue( rtl::OUString::createFromAscii("MarkPosition")
825 , uno::makeAny( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS) );
826 if( xSecondaryXAxisProp.is() )
827 xSecondaryXAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
828 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START) );
829 }
830 else
831 {
832 xMainXAxisProp->setPropertyValue( rtl::OUString::createFromAscii("LabelPosition")
833 , uno::makeAny( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START) );
834 xMainXAxisProp->setPropertyValue( rtl::OUString::createFromAscii("MarkPosition")
835 , uno::makeAny( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS) );
836 if( xSecondaryXAxisProp.is() )
837 xSecondaryXAxisProp->setPropertyValue( rtl::OUString::createFromAscii("CrossoverPosition")
838 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_END) );
839 }
840 }
841 }
842 }
843 }
844 catch( uno::Exception & )
845 {
846 }
847 }
848 }
849
850 // ========================================
851
852 SchXMLAxisContext::SchXMLAxisContext( SchXMLImportHelper& rImpHelper,
853 SvXMLImport& rImport, const rtl::OUString& rLocalName,
854 uno::Reference< chart::XDiagram > xDiagram,
855 std::vector< SchXMLAxis >& aAxes,
856 ::rtl::OUString & rCategoriesAddress,
857 bool bAddMissingXAxisForNetCharts,
858 bool bAdaptWrongPercentScaleValues,
859 bool bAdaptXAxisOrientationForOld2DBarCharts,
860 bool& rbAxisPositionAttributeImported ) :
861 SvXMLImportContext( rImport, XML_NAMESPACE_CHART, rLocalName ),
862 mrImportHelper( rImpHelper ),
863 mxDiagram( xDiagram ),
864 maAxes( aAxes ),
865 mrCategoriesAddress( rCategoriesAddress ),
866 mbAddMissingXAxisForNetCharts( bAddMissingXAxisForNetCharts ),
867 mbAdaptWrongPercentScaleValues( bAdaptWrongPercentScaleValues ),
868 mbAdaptXAxisOrientationForOld2DBarCharts( bAdaptXAxisOrientationForOld2DBarCharts ),
869 m_rbAxisPositionAttributeImported( rbAxisPositionAttributeImported )
870 {
871 }
872
873 SchXMLAxisContext::~SchXMLAxisContext()
874 {}
875
876 /* returns a shape for the current axis's title. The property
877 "Has...AxisTitle" is set to "True" to get the shape
878 */
879 uno::Reference< drawing::XShape > SchXMLAxisContext::getTitleShape()
880 {
881 uno::Reference< drawing::XShape > xResult;
882 uno::Any aTrueBool;
883 aTrueBool <<= (sal_Bool)(sal_True);
884 uno::Reference< beans::XPropertySet > xDiaProp( mxDiagram, uno::UNO_QUERY );
885
886 switch( maCurrentAxis.eClass )
887 {
888 case SCH_XML_AXIS_X:
889 if( maCurrentAxis.nIndexInCategory == 0 )
890 {
891 uno::Reference< chart::XAxisXSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
892 if( xSuppl.is())
893 {
894 if( xDiaProp.is())
895 xDiaProp->setPropertyValue( rtl::OUString::createFromAscii( "HasXAxisTitle" ), aTrueBool );
896 xResult = uno::Reference< drawing::XShape >( xSuppl->getXAxisTitle(), uno::UNO_QUERY );
897 }
898 }
899 else
900 {
901 uno::Reference< chart::XSecondAxisTitleSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
902 if( xSuppl.is() )
903 {
904 if( xDiaProp.is() )
905 xDiaProp->setPropertyValue( rtl::OUString::createFromAscii( "HasSecondaryXAxisTitle" ), aTrueBool );
906 xResult = uno::Reference< drawing::XShape >( xSuppl->getSecondXAxisTitle(), uno::UNO_QUERY );
907 }
908 }
909 break;
910 case SCH_XML_AXIS_Y:
911 if( maCurrentAxis.nIndexInCategory == 0 )
912 {
913 uno::Reference< chart::XAxisYSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
914 if( xSuppl.is())
915 {
916 if( xDiaProp.is())
917 xDiaProp->setPropertyValue( rtl::OUString::createFromAscii( "HasYAxisTitle" ), aTrueBool );
918 xResult = uno::Reference< drawing::XShape >( xSuppl->getYAxisTitle(), uno::UNO_QUERY );
919 }
920 }
921 else
922 {
923 uno::Reference< chart::XSecondAxisTitleSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
924 if( xSuppl.is() )
925 {
926 if( xDiaProp.is() )
927 xDiaProp->setPropertyValue( rtl::OUString::createFromAscii( "HasSecondaryYAxisTitle" ), aTrueBool );
928 xResult = uno::Reference< drawing::XShape >( xSuppl->getSecondYAxisTitle(), uno::UNO_QUERY );
929 }
930 }
931 break;
932 case SCH_XML_AXIS_Z:
933 {
934 uno::Reference< chart::XAxisZSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
935 if( xSuppl.is())
936 {
937 if( xDiaProp.is())
938 xDiaProp->setPropertyValue( rtl::OUString::createFromAscii( "HasZAxisTitle" ), aTrueBool );
939 xResult = uno::Reference< drawing::XShape >( xSuppl->getZAxisTitle(), uno::UNO_QUERY );
940 }
941 break;
942 }
943 case SCH_XML_AXIS_UNDEF:
944 DBG_ERROR( "Invalid axis" );
945 break;
946 }
947
948 return xResult;
949 }
950
951 void SchXMLAxisContext::CreateGrid( ::rtl::OUString sAutoStyleName,
952 sal_Bool bIsMajor )
953 {
954 uno::Reference< chart::XDiagram > xDia = mrImportHelper.GetChartDocument()->getDiagram();
955 uno::Reference< beans::XPropertySet > xGridProp;
956 ::rtl::OUString sPropertyName;
957 DBG_ASSERT( xDia.is(), "diagram object is invalid!" );
958
959 uno::Reference< beans::XPropertySet > xDiaProp( xDia, uno::UNO_QUERY );
960 uno::Any aTrueBool( uno::makeAny( true ));
961
962 switch( maCurrentAxis.eClass )
963 {
964 case SCH_XML_AXIS_X:
965 {
966 uno::Reference< chart::XAxisXSupplier > xSuppl( xDia, uno::UNO_QUERY );
967 if( xSuppl.is())
968 {
969 if( bIsMajor )
970 {
971 if( xDiaProp.is())
972 xDiaProp->setPropertyValue( ::rtl::OUString::createFromAscii("HasXAxisGrid"), aTrueBool );
973 xGridProp = xSuppl->getXMainGrid();
974 }
975 else
976 {
977 if( xDiaProp.is())
978 xDiaProp->setPropertyValue( ::rtl::OUString::createFromAscii("HasXAxisHelpGrid"), aTrueBool );
979 xGridProp = xSuppl->getXHelpGrid();
980 }
981 }
982 }
983 break;
984 case SCH_XML_AXIS_Y:
985 {
986 uno::Reference< chart::XAxisYSupplier > xSuppl( xDia, uno::UNO_QUERY );
987 if( xSuppl.is())
988 {
989 if( bIsMajor )
990 {
991 if( xDiaProp.is())
992 xDiaProp->setPropertyValue( ::rtl::OUString::createFromAscii("HasYAxisGrid"), aTrueBool );
993 xGridProp = xSuppl->getYMainGrid();
994 }
995 else
996 {
997 if( xDiaProp.is())
998 xDiaProp->setPropertyValue( ::rtl::OUString::createFromAscii("HasYAxisHelpGrid"), aTrueBool );
999 xGridProp = xSuppl->getYHelpGrid();
1000 }
1001 }
1002 }
1003 break;
1004 case SCH_XML_AXIS_Z:
1005 {
1006 uno::Reference< chart::XAxisZSupplier > xSuppl( xDia, uno::UNO_QUERY );
1007 if( xSuppl.is())
1008 {
1009 if( bIsMajor )
1010 {
1011 if( xDiaProp.is())
1012 xDiaProp->setPropertyValue( ::rtl::OUString::createFromAscii("HasZAxisGrid"), aTrueBool );
1013 xGridProp = xSuppl->getZMainGrid();
1014 }
1015 else
1016 {
1017 if( xDiaProp.is())
1018 xDiaProp->setPropertyValue( ::rtl::OUString::createFromAscii("HasZAxisHelpGrid"), aTrueBool );
1019 xGridProp = xSuppl->getZHelpGrid();
1020 }
1021 }
1022 }
1023 break;
1024 case SCH_XML_AXIS_UNDEF:
1025 DBG_ERROR( "Invalid axis" );
1026 break;
1027 }
1028
1029 // set properties
1030 if( xGridProp.is())
1031 {
1032 // the line color is black as default, in the model it is a light gray
1033 xGridProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LineColor" )),
1034 uno::makeAny( COL_BLACK ));
1035 if( sAutoStyleName.getLength())
1036 {
1037 const SvXMLStylesContext* pStylesCtxt = mrImportHelper.GetAutoStylesContext();
1038 if( pStylesCtxt )
1039 {
1040 const SvXMLStyleContext* pStyle = pStylesCtxt->FindStyleChildContext(
1041 mrImportHelper.GetChartFamilyID(), sAutoStyleName );
1042
1043 if( pStyle && pStyle->ISA( XMLPropStyleContext ))
1044 (( XMLPropStyleContext* )pStyle )->FillPropertySet( xGridProp );
1045 }
1046 }
1047 }
1048 }
1049
1050 void SchXMLAxisContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1051 {
1052 // parse attributes
1053 sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
1054 SchXMLImport& rImport = ( SchXMLImport& )GetImport();
1055 const SvXMLTokenMap& rAttrTokenMap = mrImportHelper.GetAxisAttrTokenMap();
1056
1057 for( sal_Int16 i = 0; i < nAttrCount; i++ )
1058 {
1059 rtl::OUString sAttrName = xAttrList->getNameByIndex( i );
1060 rtl::OUString aLocalName;
1061 rtl::OUString aValue = xAttrList->getValueByIndex( i );
1062 USHORT nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
1063
1064 switch( rAttrTokenMap.Get( nPrefix, aLocalName ))
1065 {
1066 case XML_TOK_AXIS_DIMENSION:
1067 {
1068 USHORT nEnumVal;
1069 if( rImport.GetMM100UnitConverter().convertEnum( nEnumVal, aValue, aXMLAxisClassMap ))
1070 maCurrentAxis.eClass = ( SchXMLAxisClass )nEnumVal;
1071 }
1072 break;
1073 case XML_TOK_AXIS_NAME:
1074 maCurrentAxis.aName = aValue;
1075 break;
1076 case XML_TOK_AXIS_STYLE_NAME:
1077 msAutoStyleName = aValue;
1078 break;
1079 }
1080 }
1081
1082 // check for number of axes with same category
1083 maCurrentAxis.nIndexInCategory = 0;
1084 sal_Int32 nNumOfAxes = maAxes.size();
1085 for( sal_Int32 nCurrent = 0; nCurrent < nNumOfAxes; nCurrent++ )
1086 {
1087 if( maAxes[ nCurrent ].eClass == maCurrentAxis.eClass )
1088 maCurrentAxis.nIndexInCategory++;
1089 }
1090 CreateAxis();
1091 }
1092 namespace
1093 {
1094
1095 uno::Reference< chart2::XAxis > lcl_getAxis( const uno::Reference< frame::XModel >& xChartModel,
1096 sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex )
1097 {
1098 uno::Reference< chart2::XAxis > xAxis;
1099
1100 try
1101 {
1102 uno::Reference< chart2::XChartDocument > xChart2Document( xChartModel, uno::UNO_QUERY );
1103 if( xChart2Document.is() )
1104 {
1105 uno::Reference< chart2::XDiagram > xDiagram( xChart2Document->getFirstDiagram());
1106 uno::Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( xDiagram, uno::UNO_QUERY_THROW );
1107 uno::Sequence< uno::Reference< chart2::XCoordinateSystem > >
1108 aCooSysSeq( xCooSysCnt->getCoordinateSystems());
1109 sal_Int32 nCooSysIndex = 0;
1110 if( nCooSysIndex < aCooSysSeq.getLength() )
1111 {
1112 uno::Reference< chart2::XCoordinateSystem > xCooSys( aCooSysSeq[nCooSysIndex] );
1113 if( xCooSys.is() && nDimensionIndex < xCooSys->getDimension() )
1114 {
1115 const sal_Int32 nMaxAxisIndex = xCooSys->getMaximumAxisIndexByDimension(nDimensionIndex);
1116 if( nAxisIndex <= nMaxAxisIndex )
1117 xAxis = xCooSys->getAxisByDimension( nDimensionIndex, nAxisIndex );
1118 }
1119 }
1120 }
1121 }
1122 catch( uno::Exception & )
1123 {
1124 DBG_ERROR( "Couldn't get axis" );
1125 }
1126
1127 return xAxis;
1128 }
1129
1130 bool lcl_divideBy100( uno::Any& rDoubleAny )
1131 {
1132 bool bChanged = false;
1133 double fValue=0.0;
1134 if( (rDoubleAny>>=fValue) && (fValue!=0.0) )
1135 {
1136 fValue/=100.0;
1137 rDoubleAny = uno::makeAny(fValue);
1138 bChanged = true;
1139 }
1140 return bChanged;
1141 }
1142
1143 bool lcl_AdaptWrongPercentScaleValues(chart2::ScaleData& rScaleData)
1144 {
1145 bool bChanged = lcl_divideBy100( rScaleData.Minimum );
1146 bChanged = lcl_divideBy100( rScaleData.Maximum ) || bChanged;
1147 bChanged = lcl_divideBy100( rScaleData.Origin ) || bChanged;
1148 bChanged = lcl_divideBy100( rScaleData.IncrementData.Distance ) || bChanged;
1149 return bChanged;
1150 }
1151
1152 }//end anonymous namespace
1153
1154 void SchXMLAxisContext::CreateAxis()
1155 {
1156 // add new Axis to list
1157 maAxes.push_back( maCurrentAxis );
1158
1159 // set axis at chart
1160 uno::Reference< beans::XPropertySet > xDiaProp( mxDiagram, uno::UNO_QUERY );
1161 uno::Reference< beans::XPropertySet > xProp;
1162 uno::Any aTrueBool;
1163 aTrueBool <<= (sal_Bool)(sal_True);
1164 uno::Any aFalseBool;
1165 aFalseBool <<= (sal_Bool)(sal_False);
1166 uno::Reference< frame::XModel > xDoc( mrImportHelper.GetChartDocument(), uno::UNO_QUERY );
1167
1168 switch( maCurrentAxis.eClass )
1169 {
1170 case SCH_XML_AXIS_X:
1171 if( maCurrentAxis.nIndexInCategory == 0 )
1172 {
1173 try
1174 {
1175 xDiaProp->setPropertyValue(
1176 rtl::OUString::createFromAscii( "HasXAxis" ), aTrueBool );
1177 }
1178 catch( beans::UnknownPropertyException & )
1179 {
1180 DBG_ERROR( "Couldn't turn on x axis" );
1181 }
1182 uno::Reference< chart::XAxisXSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1183 if( xSuppl.is())
1184 xProp = xSuppl->getXAxis();
1185 }
1186 else
1187 {
1188 try
1189 {
1190 xDiaProp->setPropertyValue(
1191 rtl::OUString::createFromAscii( "HasSecondaryXAxis" ), aTrueBool );
1192 }
1193 catch( beans::UnknownPropertyException & )
1194 {
1195 DBG_ERROR( "Couldn't turn on second x axis" );
1196 }
1197 uno::Reference< chart::XTwoAxisXSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1198 if( xSuppl.is())
1199 xProp = xSuppl->getSecondaryXAxis();
1200 }
1201 break;
1202
1203 case SCH_XML_AXIS_Y:
1204 if( maCurrentAxis.nIndexInCategory == 0 )
1205 {
1206 try
1207 {
1208 xDiaProp->setPropertyValue(
1209 rtl::OUString::createFromAscii( "HasYAxis" ), aTrueBool );
1210 }
1211 catch( beans::UnknownPropertyException & )
1212 {
1213 DBG_ERROR( "Couldn't turn on y axis" );
1214 }
1215 uno::Reference< chart::XAxisYSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1216 if( xSuppl.is())
1217 xProp = xSuppl->getYAxis();
1218
1219
1220 if( mbAddMissingXAxisForNetCharts )
1221 {
1222 if( xDiaProp.is() )
1223 {
1224 try
1225 {
1226 xDiaProp->setPropertyValue(
1227 rtl::OUString::createFromAscii( "HasXAxis" ), uno::makeAny(sal_True) );
1228 }
1229 catch( beans::UnknownPropertyException & )
1230 {
1231 DBG_ERROR( "Couldn't turn on x axis" );
1232 }
1233 }
1234 }
1235 }
1236 else
1237 {
1238 try
1239 {
1240 xDiaProp->setPropertyValue(
1241 rtl::OUString::createFromAscii( "HasSecondaryYAxis" ), aTrueBool );
1242 }
1243 catch( beans::UnknownPropertyException & )
1244 {
1245 DBG_ERROR( "Couldn't turn on second y axis" );
1246 }
1247 uno::Reference< chart::XTwoAxisYSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1248 if( xSuppl.is())
1249 xProp = xSuppl->getSecondaryYAxis();
1250 }
1251 break;
1252
1253 case SCH_XML_AXIS_Z:
1254 {
1255 try
1256 {
1257 xDiaProp->setPropertyValue(
1258 rtl::OUString::createFromAscii( "HasZAxis" ), aTrueBool );
1259 }
1260 catch( beans::UnknownPropertyException & )
1261 {
1262 DBG_ERROR( "Couldn't turn on z axis" );
1263 }
1264 uno::Reference< chart::XAxisZSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1265 if( xSuppl.is())
1266 xProp = xSuppl->getZAxis();
1267 }
1268 break;
1269 case SCH_XML_AXIS_UNDEF:
1270 // nothing
1271 break;
1272 }
1273
1274 // set properties
1275 if( xProp.is())
1276 {
1277 xProp->setPropertyValue( rtl::OUString::createFromAscii( "DisplayLabels" ), aFalseBool );
1278
1279 // #88077# AutoOrigin 'on' is default
1280 xProp->setPropertyValue( rtl::OUString::createFromAscii( "AutoOrigin" ), aTrueBool );
1281
1282 if( msAutoStyleName.getLength())
1283 {
1284 const SvXMLStylesContext* pStylesCtxt = mrImportHelper.GetAutoStylesContext();
1285 if( pStylesCtxt )
1286 {
1287 const SvXMLStyleContext* pStyle = pStylesCtxt->FindStyleChildContext(
1288 mrImportHelper.GetChartFamilyID(), msAutoStyleName );
1289
1290 if( pStyle && pStyle->ISA( XMLPropStyleContext ))
1291 {
1292 // note: SvXMLStyleContext::FillPropertySet is not const
1293 XMLPropStyleContext * pPropStyleContext = const_cast< XMLPropStyleContext * >( dynamic_cast< const XMLPropStyleContext * >( pStyle ));
1294 if( pPropStyleContext )
1295 pPropStyleContext->FillPropertySet( xProp );
1296
1297 if( mbAdaptWrongPercentScaleValues && maCurrentAxis.eClass==SCH_XML_AXIS_Y )
1298 {
1299 //set scale data of added x axis back to default
1300 uno::Reference< chart2::XAxis > xAxis( lcl_getAxis( GetImport().GetModel(),
1301 1 /*nDimensionIndex*/, maCurrentAxis.nIndexInCategory /*nAxisIndex*/ ) );
1302 if( xAxis.is() )
1303 {
1304 chart2::ScaleData aScaleData( xAxis->getScaleData());
1305 if( lcl_AdaptWrongPercentScaleValues(aScaleData) )
1306 xAxis->setScaleData( aScaleData );
1307 }
1308 }
1309
1310 if( mbAddMissingXAxisForNetCharts )
1311 {
1312 //copy style from y axis to added x axis:
1313
1314 uno::Reference< chart::XAxisXSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1315 if( xSuppl.is() )
1316 {
1317 uno::Reference< beans::XPropertySet > xXAxisProp( xSuppl->getXAxis() );
1318 (( XMLPropStyleContext* )pStyle )->FillPropertySet( xXAxisProp );
1319 }
1320
1321 //set scale data of added x axis back to default
1322 uno::Reference< chart2::XAxis > xAxis( lcl_getAxis( GetImport().GetModel(),
1323 0 /*nDimensionIndex*/, 0 /*nAxisIndex*/ ) );
1324 if( xAxis.is() )
1325 {
1326 chart2::ScaleData aScaleData;
1327 aScaleData.AxisType = chart2::AxisType::CATEGORY;
1328 aScaleData.Orientation = chart2::AxisOrientation_MATHEMATICAL;
1329 xAxis->setScaleData( aScaleData );
1330 }
1331
1332 //set line style of added x axis to invisible
1333 uno::Reference< beans::XPropertySet > xNewAxisProp( xAxis, uno::UNO_QUERY );
1334 if( xNewAxisProp.is() )
1335 {
1336 xNewAxisProp->setPropertyValue( rtl::OUString::createFromAscii("LineStyle")
1337 , uno::makeAny(drawing::LineStyle_NONE));
1338 }
1339 }
1340
1341 if( mbAdaptXAxisOrientationForOld2DBarCharts && maCurrentAxis.eClass == SCH_XML_AXIS_X )
1342 {
1343 bool bIs3DChart = false;
1344 if( xDiaProp.is() && ( xDiaProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Dim3D"))) >>= bIs3DChart )
1345 && !bIs3DChart )
1346 {
1347 uno::Reference< chart2::XChartDocument > xChart2Document( GetImport().GetModel(), uno::UNO_QUERY );
1348 if( xChart2Document.is() )
1349 {
1350 uno::Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( xChart2Document->getFirstDiagram(), uno::UNO_QUERY );
1351 if( xCooSysCnt.is() )
1352 {
1353 uno::Sequence< uno::Reference< chart2::XCoordinateSystem > > aCooSysSeq( xCooSysCnt->getCoordinateSystems() );
1354 if( aCooSysSeq.getLength() )
1355 {
1356 bool bSwapXandYAxis = false;
1357 uno::Reference< chart2::XCoordinateSystem > xCooSys( aCooSysSeq[0] );
1358 uno::Reference< beans::XPropertySet > xCooSysProp( xCooSys, uno::UNO_QUERY );
1359 if( xCooSysProp.is() && ( xCooSysProp->getPropertyValue( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SwapXAndYAxis"))) >>= bSwapXandYAxis )
1360 && bSwapXandYAxis )
1361 {
1362 uno::Reference< chart2::XAxis > xAxis = xCooSys->getAxisByDimension( 0, maCurrentAxis.nIndexInCategory );
1363 if( xAxis.is() )
1364 {
1365 chart2::ScaleData aScaleData = xAxis->getScaleData();
1366 aScaleData.Orientation = chart2::AxisOrientation_REVERSE;
1367 xAxis->setScaleData( aScaleData );
1368 }
1369 }
1370 }
1371 }
1372 }
1373 }
1374 }
1375
1376 m_rbAxisPositionAttributeImported = m_rbAxisPositionAttributeImported || SchXMLTools::getPropertyFromContext(
1377 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CrossoverPosition")), pPropStyleContext, pStylesCtxt ).hasValue();
1378 }
1379 }
1380 }
1381 }
1382 }
1383
1384 void SchXMLAxisContext::SetAxisTitle()
1385 {
1386 // add new Axis to list
1387 maAxes.push_back( maCurrentAxis );
1388
1389 // set axis at chart
1390 sal_Bool bHasTitle = ( maCurrentAxis.aTitle.getLength() > 0 );
1391 uno::Reference< frame::XModel > xDoc( mrImportHelper.GetChartDocument(), uno::UNO_QUERY );
1392
1393 switch( maCurrentAxis.eClass )
1394 {
1395 case SCH_XML_AXIS_X:
1396 if( maCurrentAxis.nIndexInCategory == 0 )
1397 {
1398 uno::Reference< chart::XAxisXSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1399 if( xSuppl.is() &&
1400 bHasTitle )
1401 {
1402 uno::Reference< beans::XPropertySet > xTitleProp( xSuppl->getXAxisTitle(), uno::UNO_QUERY );
1403 if( xTitleProp.is())
1404 {
1405 try
1406 {
1407 uno::Any aAny;
1408 aAny <<= maCurrentAxis.aTitle;
1409 xTitleProp->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "String" )), aAny );
1410 }
1411 catch( beans::UnknownPropertyException & )
1412 {
1413 DBG_ERROR( "Property String for Title not available" );
1414 }
1415 }
1416 }
1417 }
1418 else
1419 {
1420 uno::Reference< chart::XSecondAxisTitleSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1421 if( xSuppl.is() &&
1422 bHasTitle )
1423 {
1424 uno::Reference< beans::XPropertySet > xTitleProp( xSuppl->getSecondXAxisTitle(), uno::UNO_QUERY );
1425 if( xTitleProp.is())
1426 {
1427 try
1428 {
1429 uno::Any aAny;
1430 aAny <<= maCurrentAxis.aTitle;
1431 xTitleProp->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "String" )), aAny );
1432 }
1433 catch( beans::UnknownPropertyException & )
1434 {
1435 DBG_ERROR( "Property String for Title not available" );
1436 }
1437 }
1438 }
1439 }
1440 break;
1441
1442 case SCH_XML_AXIS_Y:
1443 if( maCurrentAxis.nIndexInCategory == 0 )
1444 {
1445 uno::Reference< chart::XAxisYSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1446 if( xSuppl.is() &&
1447 bHasTitle )
1448 {
1449 uno::Reference< beans::XPropertySet > xTitleProp( xSuppl->getYAxisTitle(), uno::UNO_QUERY );
1450 if( xTitleProp.is())
1451 {
1452 try
1453 {
1454 uno::Any aAny;
1455 aAny <<= maCurrentAxis.aTitle;
1456 xTitleProp->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "String" )), aAny );
1457 }
1458 catch( beans::UnknownPropertyException & )
1459 {
1460 DBG_ERROR( "Property String for Title not available" );
1461 }
1462 }
1463 }
1464 }
1465 else
1466 {
1467 uno::Reference< chart::XSecondAxisTitleSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1468 if( xSuppl.is() &&
1469 bHasTitle )
1470 {
1471 uno::Reference< beans::XPropertySet > xTitleProp( xSuppl->getSecondYAxisTitle(), uno::UNO_QUERY );
1472 if( xTitleProp.is())
1473 {
1474 try
1475 {
1476 uno::Any aAny;
1477 aAny <<= maCurrentAxis.aTitle;
1478 xTitleProp->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "String" )), aAny );
1479 }
1480 catch( beans::UnknownPropertyException & )
1481 {
1482 DBG_ERROR( "Property String for Title not available" );
1483 }
1484 }
1485 }
1486 }
1487 break;
1488
1489 case SCH_XML_AXIS_Z:
1490 {
1491 uno::Reference< chart::XAxisZSupplier > xSuppl( mxDiagram, uno::UNO_QUERY );
1492 if( xSuppl.is() &&
1493 bHasTitle )
1494 {
1495 uno::Reference< beans::XPropertySet > xTitleProp( xSuppl->getZAxisTitle(), uno::UNO_QUERY );
1496 if( xTitleProp.is())
1497 {
1498 try
1499 {
1500 uno::Any aAny;
1501 aAny <<= maCurrentAxis.aTitle;
1502 xTitleProp->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "String" )), aAny );
1503 }
1504 catch( beans::UnknownPropertyException & )
1505 {
1506 DBG_ERROR( "Property String for Title not available" );
1507 }
1508 }
1509 }
1510 }
1511 break;
1512 case SCH_XML_AXIS_UNDEF:
1513 // nothing
1514 break;
1515 }
1516 }
1517
1518 SvXMLImportContext* SchXMLAxisContext::CreateChildContext(
1519 USHORT p_nPrefix,
1520 const rtl::OUString& rLocalName,
1521 const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1522 {
1523 SvXMLImportContext* pContext = 0;
1524 const SvXMLTokenMap& rTokenMap = mrImportHelper.GetAxisElemTokenMap();
1525
1526 switch( rTokenMap.Get( p_nPrefix, rLocalName ))
1527 {
1528 case XML_TOK_AXIS_TITLE:
1529 {
1530 uno::Reference< drawing::XShape > xTitleShape = getTitleShape();
1531 pContext = new SchXMLTitleContext( mrImportHelper, GetImport(), rLocalName,
1532 maCurrentAxis.aTitle,
1533 xTitleShape );
1534 }
1535 break;
1536
1537 case XML_TOK_AXIS_CATEGORIES:
1538 pContext = new SchXMLCategoriesContext( mrImportHelper, GetImport(),
1539 p_nPrefix, rLocalName,
1540 mrCategoriesAddress );
1541 maCurrentAxis.bHasCategories = true;
1542 break;
1543
1544 case XML_TOK_AXIS_GRID:
1545 {
1546 sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
1547 sal_Bool bIsMajor = sal_True; // default value for class is "major"
1548 rtl::OUString sAutoStyleName;
1549
1550 for( sal_Int16 i = 0; i < nAttrCount; i++ )
1551 {
1552 rtl::OUString sAttrName = xAttrList->getNameByIndex( i );
1553 rtl::OUString aLocalName;
1554 USHORT nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
1555
1556 if( nPrefix == XML_NAMESPACE_CHART )
1557 {
1558 if( IsXMLToken( aLocalName, XML_CLASS ) )
1559 {
1560 if( IsXMLToken( xAttrList->getValueByIndex( i ), XML_MINOR ) )
1561 bIsMajor = sal_False;
1562 }
1563 else if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
1564 sAutoStyleName = xAttrList->getValueByIndex( i );
1565 }
1566 }
1567
1568 CreateGrid( sAutoStyleName, bIsMajor );
1569
1570 // don't create a context => use default context. grid elements are empty
1571 pContext = new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName );
1572 }
1573 break;
1574
1575 default:
1576 pContext = new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName );
1577 break;
1578 }
1579
1580 return pContext;
1581 }
1582
1583 void SchXMLAxisContext::EndElement()
1584 {
1585 SetAxisTitle();
1586 }
1587
1588 // ========================================
1589
1590 SchXMLDataPointContext::SchXMLDataPointContext( SchXMLImportHelper& rImpHelper,
1591 SvXMLImport& rImport, const rtl::OUString& rLocalName,
1592 ::std::list< DataRowPointStyle >& rStyleList,
1593 const ::com::sun::star::uno::Reference<
1594 ::com::sun::star::chart2::XDataSeries >& xSeries,
1595 sal_Int32& rIndex,
1596 bool bSymbolSizeForSeriesIsMissingInFile ) :
1597 SvXMLImportContext( rImport, XML_NAMESPACE_CHART, rLocalName ),
1598 mrImportHelper( rImpHelper ),
1599 mrStyleList( rStyleList ),
1600 m_xSeries( xSeries ),
1601 mrIndex( rIndex ),
1602 mbSymbolSizeForSeriesIsMissingInFile( bSymbolSizeForSeriesIsMissingInFile )
1603 {
1604 }
1605
1606 SchXMLDataPointContext::~SchXMLDataPointContext()
1607 {
1608 }
1609
1610 void SchXMLDataPointContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1611 {
1612 sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
1613 ::rtl::OUString aValue;
1614 ::rtl::OUString sAutoStyleName;
1615 sal_Int32 nRepeat = 1;
1616
1617 for( sal_Int16 i = 0; i < nAttrCount; i++ )
1618 {
1619 rtl::OUString sAttrName = xAttrList->getNameByIndex( i );
1620 rtl::OUString aLocalName;
1621 USHORT nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
1622
1623 if( nPrefix == XML_NAMESPACE_CHART )
1624 {
1625 if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
1626 sAutoStyleName = xAttrList->getValueByIndex( i );
1627 else if( IsXMLToken( aLocalName, XML_REPEATED ) )
1628 nRepeat = xAttrList->getValueByIndex( i ).toInt32();
1629 }
1630 }
1631
1632 if( sAutoStyleName.getLength())
1633 {
1634 DataRowPointStyle aStyle(
1635 DataRowPointStyle::DATA_POINT,
1636 m_xSeries, mrIndex, nRepeat, sAutoStyleName );
1637 aStyle.mbSymbolSizeForSeriesIsMissingInFile = mbSymbolSizeForSeriesIsMissingInFile;
1638 mrStyleList.push_back( aStyle );
1639 }
1640 mrIndex += nRepeat;
1641 }
1642
1643 // ========================================
1644
1645 SchXMLCategoriesContext::SchXMLCategoriesContext(
1646 SchXMLImportHelper& rImpHelper,
1647 SvXMLImport& rImport,
1648 sal_uInt16 nPrefix,
1649 const rtl::OUString& rLocalName,
1650 rtl::OUString& rAddress ) :
1651 SvXMLImportContext( rImport, nPrefix, rLocalName ),
1652 mrImportHelper( rImpHelper ),
1653 mrAddress( rAddress )
1654 {
1655 }
1656
1657 SchXMLCategoriesContext::~SchXMLCategoriesContext()
1658 {
1659 }
1660
1661 void SchXMLCategoriesContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1662 {
1663 sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
1664
1665 for( sal_Int16 i = 0; i < nAttrCount; i++ )
1666 {
1667 rtl::OUString sAttrName = xAttrList->getNameByIndex( i );
1668 rtl::OUString aLocalName;
1669 USHORT nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
1670
1671 if( nPrefix == XML_NAMESPACE_TABLE &&
1672 IsXMLToken( aLocalName, XML_CELL_RANGE_ADDRESS ) )
1673 {
1674 uno::Reference< chart2::XChartDocument > xNewDoc( GetImport().GetModel(), uno::UNO_QUERY );
1675 mrAddress = xAttrList->getValueByIndex( i );
1676 // lcl_ConvertRange( xAttrList->getValueByIndex( i ), xNewDoc );
1677 }
1678 }
1679 }
1680
1681 // ========================================
1682
1683 SchXMLWallFloorContext::SchXMLWallFloorContext(
1684 SchXMLImportHelper& rImpHelper,
1685 SvXMLImport& rImport,
1686 sal_uInt16 nPrefix,
1687 const rtl::OUString& rLocalName,
1688 uno::Reference< chart::XDiagram >& xDiagram,
1689 ContextType eContextType ) :
1690 SvXMLImportContext( rImport, nPrefix, rLocalName ),
1691 mrImportHelper( rImpHelper ),
1692 mxWallFloorSupplier( xDiagram, uno::UNO_QUERY ),
1693 meContextType( eContextType )
1694 {
1695 }
1696
1697 SchXMLWallFloorContext::~SchXMLWallFloorContext()
1698 {
1699 }
1700
1701 void SchXMLWallFloorContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1702 {
1703 if( mxWallFloorSupplier.is())
1704 {
1705 sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
1706 rtl::OUString sAutoStyleName;
1707
1708 for( sal_Int16 i = 0; i < nAttrCount; i++ )
1709 {
1710 rtl::OUString sAttrName = xAttrList->getNameByIndex( i );
1711 rtl::OUString aLocalName;
1712 USHORT nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
1713
1714 if( nPrefix == XML_NAMESPACE_CHART &&
1715 IsXMLToken( aLocalName, XML_STYLE_NAME ) )
1716 {
1717 sAutoStyleName = xAttrList->getValueByIndex( i );
1718 }
1719 }
1720
1721 // set properties
1722 uno::Reference< beans::XPropertySet > xProp( ( meContextType == CONTEXT_TYPE_WALL )
1723 ? mxWallFloorSupplier->getWall()
1724 : mxWallFloorSupplier->getFloor(),
1725 uno::UNO_QUERY );
1726 if( xProp.is())
1727 {
1728 if( sAutoStyleName.getLength())
1729 {
1730 const SvXMLStylesContext* pStylesCtxt = mrImportHelper.GetAutoStylesContext();
1731 if( pStylesCtxt )
1732 {
1733 const SvXMLStyleContext* pStyle = pStylesCtxt->FindStyleChildContext(
1734 mrImportHelper.GetChartFamilyID(), sAutoStyleName );
1735
1736 if( pStyle && pStyle->ISA( XMLPropStyleContext ))
1737 (( XMLPropStyleContext* )pStyle )->FillPropertySet( xProp );
1738 }
1739 }
1740 }
1741 }
1742 }
1743
1744 // ========================================
1745
1746 SchXMLStockContext::SchXMLStockContext(
1747 SchXMLImportHelper& rImpHelper,
1748 SvXMLImport& rImport,
1749 sal_uInt16 nPrefix,
1750 const rtl::OUString& rLocalName,
1751 uno::Reference< chart::XDiagram >& xDiagram,
1752 ContextType eContextType ) :
1753 SvXMLImportContext( rImport, nPrefix, rLocalName ),
1754 mrImportHelper( rImpHelper ),
1755 mxStockPropProvider( xDiagram, uno::UNO_QUERY ),
1756 meContextType( eContextType )
1757 {
1758 }
1759
1760 SchXMLStockContext::~SchXMLStockContext()
1761 {
1762 }
1763
1764 void SchXMLStockContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1765 {
1766 if( mxStockPropProvider.is())
1767 {
1768 sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
1769 rtl::OUString sAutoStyleName;
1770
1771 for( sal_Int16 i = 0; i < nAttrCount; i++ )
1772 {
1773 rtl::OUString sAttrName = xAttrList->getNameByIndex( i );
1774 rtl::OUString aLocalName;
1775 USHORT nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
1776
1777 if( nPrefix == XML_NAMESPACE_CHART &&
1778 IsXMLToken( aLocalName, XML_STYLE_NAME ) )
1779 {
1780 sAutoStyleName = xAttrList->getValueByIndex( i );
1781 }
1782 }
1783
1784 if( sAutoStyleName.getLength())
1785 {
1786 // set properties
1787 uno::Reference< beans::XPropertySet > xProp;
1788 switch( meContextType )
1789 {
1790 case CONTEXT_TYPE_GAIN:
1791 xProp = mxStockPropProvider->getUpBar();
1792 break;
1793 case CONTEXT_TYPE_LOSS:
1794 xProp = mxStockPropProvider->getDownBar();
1795 break;
1796 case CONTEXT_TYPE_RANGE:
1797 xProp = mxStockPropProvider->getMinMaxLine();
1798 break;
1799 }
1800 if( xProp.is())
1801 {
1802 const SvXMLStylesContext* pStylesCtxt = mrImportHelper.GetAutoStylesContext();
1803 if( pStylesCtxt )
1804 {
1805 const SvXMLStyleContext* pStyle = pStylesCtxt->FindStyleChildContext(
1806 mrImportHelper.GetChartFamilyID(), sAutoStyleName );
1807
1808 if( pStyle && pStyle->ISA( XMLPropStyleContext ))
1809 (( XMLPropStyleContext* )pStyle )->FillPropertySet( xProp );
1810 }
1811 }
1812 }
1813 }
1814 }
1815
1816 // ========================================
1817
1818 SchXMLStatisticsObjectContext::SchXMLStatisticsObjectContext(
1819
1820 SchXMLImportHelper& rImpHelper,
1821 SvXMLImport& rImport,
1822 sal_uInt16 nPrefix,
1823 const rtl::OUString& rLocalName,
1824 ::std::list< DataRowPointStyle >& rStyleList,
1825 const ::com::sun::star::uno::Reference<
1826 ::com::sun::star::chart2::XDataSeries >& xSeries,
1827 ContextType eContextType,
1828 const awt::Size & rChartSize ) :
1829
1830 SvXMLImportContext( rImport, nPrefix, rLocalName ),
1831 mrImportHelper( rImpHelper ),
1832 mrStyleList( rStyleList ),
1833 m_xSeries( xSeries ),
1834 meContextType( eContextType ),
1835 maChartSize( rChartSize )
1836 {}
1837
1838 SchXMLStatisticsObjectContext::~SchXMLStatisticsObjectContext()
1839 {
1840 }
1841
1842 void SchXMLStatisticsObjectContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1843 {
1844 sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
1845 ::rtl::OUString aValue;
1846 ::rtl::OUString sAutoStyleName;
1847
1848 for( sal_Int16 i = 0; i < nAttrCount; i++ )
1849 {
1850 rtl::OUString sAttrName = xAttrList->getNameByIndex( i );
1851 rtl::OUString aLocalName;
1852 USHORT nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
1853
1854 if( nPrefix == XML_NAMESPACE_CHART )
1855 {
1856 if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
1857 sAutoStyleName = xAttrList->getValueByIndex( i );
1858 }
1859 }
1860
1861 // note: regression-curves must get a style-object even if there is no
1862 // auto-style set, because they can contain an equation
1863 if( sAutoStyleName.getLength() || meContextType == CONTEXT_TYPE_REGRESSION_CURVE )
1864 {
1865 DataRowPointStyle::StyleType eType = DataRowPointStyle::MEAN_VALUE;
1866 switch( meContextType )
1867 {
1868 case CONTEXT_TYPE_MEAN_VALUE_LINE:
1869 eType = DataRowPointStyle::MEAN_VALUE;
1870 break;
1871 case CONTEXT_TYPE_REGRESSION_CURVE:
1872 eType = DataRowPointStyle::REGRESSION;
1873 break;
1874 case CONTEXT_TYPE_ERROR_INDICATOR:
1875 eType = DataRowPointStyle::ERROR_INDICATOR;
1876 break;
1877 }
1878 DataRowPointStyle aStyle(
1879 eType, m_xSeries, -1, 1, sAutoStyleName );
1880 mrStyleList.push_back( aStyle );
1881 }
1882 }
1883
1884 SvXMLImportContext* SchXMLStatisticsObjectContext::CreateChildContext(
1885 USHORT nPrefix,
1886 const rtl::OUString& rLocalName,
1887 const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1888 {
1889 SvXMLImportContext* pContext = 0;
1890
1891 if( nPrefix == XML_NAMESPACE_CHART &&
1892 IsXMLToken( rLocalName, XML_EQUATION ) )
1893 {
1894 pContext = new SchXMLEquationContext(
1895 mrImportHelper, GetImport(), nPrefix, rLocalName, m_xSeries, maChartSize, mrStyleList.back());
1896 }
1897 else
1898 {
1899 pContext = SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
1900 }
1901
1902 return pContext;
1903 }
1904
1905 // ========================================
1906
1907 SchXMLEquationContext::SchXMLEquationContext(
1908 SchXMLImportHelper& rImpHelper,
1909 SvXMLImport& rImport,
1910 sal_uInt16 nPrefix,
1911 const rtl::OUString& rLocalName,
1912 const ::com::sun::star::uno::Reference<
1913 ::com::sun::star::chart2::XDataSeries >& xSeries,
1914 const awt::Size & rChartSize,
1915 DataRowPointStyle & rRegressionStyle ) :
1916 SvXMLImportContext( rImport, nPrefix, rLocalName ),
1917 mrImportHelper( rImpHelper ),
1918 mrRegressionStyle( rRegressionStyle ),
1919 m_xSeries( xSeries ),
1920 maChartSize( rChartSize )
1921 {}
1922
1923 SchXMLEquationContext::~SchXMLEquationContext()
1924 {}
1925
1926 void SchXMLEquationContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1927 {
1928 // parse attributes
1929 sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
1930 SchXMLImport& rImport = ( SchXMLImport& )GetImport();
1931 const SvXMLTokenMap& rAttrTokenMap = mrImportHelper.GetRegEquationAttrTokenMap();
1932 OUString sAutoStyleName;
1933
1934 sal_Bool bShowEquation = sal_True;
1935 sal_Bool bShowRSquare = sal_False;
1936 awt::Point aPosition;
1937 bool bHasXPos = false;
1938 bool bHasYPos = false;
1939
1940 for( sal_Int16 i = 0; i < nAttrCount; i++ )
1941 {
1942 rtl::OUString sAttrName = xAttrList->getNameByIndex( i );
1943 rtl::OUString aLocalName;
1944 rtl::OUString aValue = xAttrList->getValueByIndex( i );
1945 USHORT nPrefix = rImport.GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
1946
1947 switch( rAttrTokenMap.Get( nPrefix, aLocalName ))
1948 {
1949 case XML_TOK_REGEQ_POS_X:
1950 rImport.GetMM100UnitConverter().convertMeasure( aPosition.X, aValue );
1951 bHasXPos = true;
1952 break;
1953 case XML_TOK_REGEQ_POS_Y:
1954 rImport.GetMM100UnitConverter().convertMeasure( aPosition.Y, aValue );
1955 bHasYPos = true;
1956 break;
1957 case XML_TOK_REGEQ_DISPLAY_EQUATION:
1958 rImport.GetMM100UnitConverter().convertBool( bShowEquation, aValue );
1959 break;
1960 case XML_TOK_REGEQ_DISPLAY_R_SQUARE:
1961 rImport.GetMM100UnitConverter().convertBool( bShowRSquare, aValue );
1962 break;
1963 case XML_TOK_REGEQ_STYLE_NAME:
1964 sAutoStyleName = aValue;
1965 break;
1966 }
1967 }
1968
1969 if( sAutoStyleName.getLength() || bShowEquation || bShowRSquare )
1970 {
1971 uno::Reference< beans::XPropertySet > xEqProp;
1972 uno::Reference< lang::XMultiServiceFactory > xFact( comphelper::getProcessServiceFactory(), uno::UNO_QUERY );
1973 if( xFact.is())
1974 xEqProp.set( xFact->createInstance(
1975 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.chart2.RegressionEquation" ))), uno::UNO_QUERY );
1976 if( xEqProp.is())
1977 {
1978 if( sAutoStyleName.getLength() )
1979 {
1980 const SvXMLStylesContext* pStylesCtxt = mrImportHelper.GetAutoStylesContext();
1981 if( pStylesCtxt )
1982 {
1983 const SvXMLStyleContext* pStyle = pStylesCtxt->FindStyleChildContext(
1984 mrImportHelper.GetChartFamilyID(), sAutoStyleName );
1985 // note: SvXMLStyleContext::FillPropertySet is not const
1986 XMLPropStyleContext * pPropStyleContext =
1987 const_cast< XMLPropStyleContext * >( dynamic_cast< const XMLPropStyleContext * >( pStyle ));
1988
1989 if( pPropStyleContext )
1990 pPropStyleContext->FillPropertySet( xEqProp );
1991 }
1992 }
1993 xEqProp->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM("ShowEquation")), uno::makeAny( bShowEquation ));
1994 xEqProp->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM("ShowCorrelationCoefficient")), uno::makeAny( bShowRSquare ));
1995
1996 if( bHasXPos && bHasYPos )
1997 {
1998 chart2::RelativePosition aRelPos;
1999 aRelPos.Primary = static_cast< double >( aPosition.X ) / static_cast< double >( maChartSize.Width );
2000 aRelPos.Secondary = static_cast< double >( aPosition.Y ) / static_cast< double >( maChartSize.Height );
2001 xEqProp->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "RelativePosition" )),
2002 uno::makeAny( aRelPos ));
2003 }
2004 OSL_ASSERT( mrRegressionStyle.meType == DataRowPointStyle::REGRESSION );
2005 mrRegressionStyle.m_xEquationProperties.set( xEqProp );
2006 }
2007 }
2008 }
vba interoperability for OOo