| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_chart2.hxx" |
| |
| #include "ChartDebugTrace.hxx" |
| #include "macros.hxx" |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/chart2/AxisType.hpp> |
| #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp> |
| #include <com/sun/star/chart2/XChartTypeContainer.hpp> |
| #include <com/sun/star/chart2/XDataSeriesContainer.hpp> |
| #include <com/sun/star/chart2/StackingDirection.hpp> |
| #include <rtl/math.hxx> |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::chart2; |
| |
| using ::com::sun::star::uno::Reference; |
| using ::com::sun::star::uno::Sequence; |
| using ::rtl::OUString; |
| |
| #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL |
| |
| namespace |
| { |
| /* |
| const char lcl_aSpace=' '; |
| |
| void lcl_IndentedTrace( int nIndent, char* pStr ) |
| { |
| if( nIndent > 0 ) |
| { |
| OSL_TRACE( "%*c%s", nIndent, lcl_aSpace, pStr ); |
| } |
| else |
| { |
| OSL_TRACE( pStr ); |
| } |
| } |
| |
| void lcl_TraceException( const uno::Exception & aEx ) |
| { |
| OSL_TRACE( |
| U2C( C2U( "*** Exception caught during trace. Type: " ) + |
| OUString::createFromAscii( typeid( aEx ).name()) + |
| C2U( ", Message: " ) + |
| aEx.Message )); |
| } |
| |
| void lcl_TraceCategories( const Reference< data::XLabeledDataSequence > & xCat, int nIndent ) |
| { |
| if( ! xCat.is()) |
| return; |
| try |
| { |
| Reference< data::XDataSequence > xValues( xCat->getValues()); |
| if( xValues.is()) |
| { |
| OSL_TRACE( "%*ccategories: source: %s", nIndent, lcl_aSpace, |
| U2C( xValues->getSourceRangeRepresentation())); |
| } |
| Reference< data::XDataSequence > xLabel( xCat->getLabel()); |
| if( xLabel.is()) |
| { |
| OSL_TRACE( "%*ccategories' label: source: %s", nIndent, lcl_aSpace, |
| U2C( xLabel->getSourceRangeRepresentation())); |
| } |
| } |
| catch( uno::Exception & ex ) |
| { |
| lcl_TraceException( ex ); |
| } |
| } |
| |
| void lcl_TraceDataSeriesSeq( const Sequence< Reference< XDataSeries > > & aSeries, int nIndent ) |
| { |
| for( sal_Int32 j = 0; j < aSeries.getLength(); ++j ) |
| { |
| Reference< beans::XPropertySet > xProp( aSeries[j], uno::UNO_QUERY ); |
| OUString aId; |
| |
| OSL_TRACE( "%*cindex %ld", nIndent, lcl_aSpace, j ); |
| |
| StackingDirection aStDir; |
| if( xProp.is() && |
| ( xProp->getPropertyValue( C2U( "StackingDirection" )) >>= aStDir ) && |
| aStDir != StackingDirection_NO_STACKING ) |
| { |
| OSL_TRACE( "%*cstacking in %s", nIndent + 2, lcl_aSpace, |
| (aStDir == StackingDirection_Y_STACKING) |
| ? "y-direction" : "z-direction" ); |
| } |
| |
| Reference< data::XDataSource > xSource( aSeries[j], uno::UNO_QUERY ); |
| if( xSource.is()) |
| { |
| Sequence< Reference< data::XLabeledDataSequence > > aSequences( xSource->getDataSequences()); |
| const sal_Int32 nMax = aSequences.getLength(); |
| for( sal_Int32 k = 0; k < nMax; ++k ) |
| { |
| if( aSequences[k].is()) |
| { |
| OUString aSourceId(C2U("<none>")); |
| if( aSequences[k]->getValues().is()) |
| aSourceId = aSequences[k]->getValues()->getSourceRangeRepresentation(); |
| xProp.set( aSequences[k]->getValues(), uno::UNO_QUERY ); |
| if( xProp.is() && |
| ( xProp->getPropertyValue( C2U( "Role" )) >>= aId )) |
| { |
| OSL_TRACE( "%*cdata sequence %d: role: %s, source: %s", |
| nIndent + 2, lcl_aSpace, k, U2C( aId ), U2C( aSourceId )); |
| } |
| else |
| { |
| OSL_TRACE( "%*cdata sequence %d, unknown role, source: %s", |
| nIndent + 2, lcl_aSpace, k, U2C( aSourceId ) ); |
| } |
| |
| aSourceId = C2U("<none>"); |
| if( aSequences[k]->getLabel().is()) |
| aSourceId = OUString( aSequences[k]->getLabel()->getSourceRangeRepresentation()); |
| xProp.set( aSequences[k]->getLabel(), uno::UNO_QUERY ); |
| if( xProp.is() && |
| ( xProp->getPropertyValue( C2U( "Role" )) >>= aId )) |
| { |
| OSL_TRACE( "%*cdata sequence label %d: role: %s, source: %s", |
| nIndent + 2, lcl_aSpace, k, U2C( aId ), U2C( aSourceId )); |
| } |
| else |
| { |
| OSL_TRACE( "%*cdata sequence label %d: unknown role, source: %s", |
| nIndent + 2, lcl_aSpace, k, U2C( aSourceId ) ); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| void lcl_TraceChartType( const Reference< XChartType > & xChartType, int nIndent ) |
| { |
| if( xChartType.is()) |
| { |
| OSL_TRACE( "%*c* type: %s", nIndent, lcl_aSpace, U2C( xChartType->getChartType()) ); |
| |
| lcl_IndentedTrace( nIndent + 2, "Supported Roles" ); |
| sal_Int32 i=0; |
| Sequence< OUString > aMandRoles( xChartType->getSupportedMandatoryRoles()); |
| if( aMandRoles.getLength() > 0 ) |
| { |
| lcl_IndentedTrace( nIndent + 4, "mandatory" ); |
| for( i=0; i<aMandRoles.getLength(); ++i ) |
| { |
| OSL_TRACE( "%*c%s", nIndent + 6, lcl_aSpace, U2C( aMandRoles[i] )); |
| } |
| } |
| Sequence< OUString > aOptRoles( xChartType->getSupportedOptionalRoles()); |
| if( aOptRoles.getLength() > 0 ) |
| { |
| lcl_IndentedTrace( nIndent + 4, "optional" ); |
| for( i=0; i<aOptRoles.getLength(); ++i ) |
| { |
| OSL_TRACE( "%*c%s", nIndent + 6, lcl_aSpace, U2C( aOptRoles[i] )); |
| } |
| } |
| OSL_TRACE( "%*crole of sequence for label: %s", nIndent + 2, lcl_aSpace, |
| U2C( xChartType->getRoleOfSequenceForSeriesLabel())); |
| |
| Reference< XDataSeriesContainer > xDSCnt( xChartType, uno::UNO_QUERY ); |
| if( xDSCnt.is()) |
| { |
| lcl_IndentedTrace( nIndent + 2, "Data Series" ); |
| lcl_TraceDataSeriesSeq( xDSCnt->getDataSeries(), nIndent + 4 ); |
| } |
| } |
| } |
| |
| void lcl_TraceCoordinateSystem( const Reference< XCoordinateSystem > & xCooSys, int nIndent ) |
| { |
| if( xCooSys.is()) try |
| { |
| sal_Int32 nDim = xCooSys->getDimension(); |
| OSL_TRACE( "%*c* dim: %ld, type: %s", nIndent, lcl_aSpace, |
| nDim, U2C( xCooSys->getCoordinateSystemType() )); |
| nIndent += 2; |
| OSL_TRACE( "%*cview service-name: %s", nIndent, lcl_aSpace, |
| U2C( xCooSys->getViewServiceName() )); |
| |
| Reference< beans::XPropertySet > xProp( xCooSys, uno::UNO_QUERY ); |
| if( xProp.is()) |
| { |
| Reference< beans::XPropertySetInfo > xInfo( xProp->getPropertySetInfo(), uno::UNO_QUERY ); |
| sal_Bool bSwap; |
| if( xInfo.is() && |
| xInfo->hasPropertyByName( C2U("SwapXAndYAxis")) && |
| (xProp->getPropertyValue( C2U("SwapXAndYAxis")) >>= bSwap) && |
| bSwap ) |
| { |
| lcl_IndentedTrace( nIndent, "swap x-axis and y-axis" ); |
| } |
| } |
| |
| if( nDim >= 2 ) |
| { |
| const sal_Int32 nMaxIndex = xCooSys->getMaximumAxisIndexByDimension(1); |
| for(sal_Int32 nI=0; nI<=nMaxIndex; ++nI) |
| { |
| Reference< XScale > xScale( xCooSys->getAxisByDimension( 1, nI )); |
| if( xScale.is()) |
| { |
| ScaleData aData( xScale->getScaleData()); |
| if( aData.AxisType==AxisType::PERCENT ) |
| lcl_IndentedTrace( nIndent, "percent stacking at y-scale" ); |
| } |
| } |
| } |
| |
| Sequence< uno::Any > aOrigin( xCooSys->getOrigin()); |
| double x, y, z; |
| ::rtl::math::setNan( &x ), ::rtl::math::setNan( &y ), ::rtl::math::setNan( &z ); |
| if( aOrigin.getLength() > 0 && |
| aOrigin[0].hasValue() ) |
| aOrigin[0] >>= x; |
| if( aOrigin.getLength() > 1 && |
| aOrigin[1].hasValue() ) |
| aOrigin[1] >>= y; |
| if( aOrigin.getLength() > 2 && |
| aOrigin[2].hasValue() ) |
| aOrigin[2] >>= z; |
| OSL_TRACE( "%*corigin: (%f, %f, %f)", nIndent, lcl_aSpace, x, y, z ); |
| |
| Reference< XChartTypeContainer > xCTCnt( xCooSys, uno::UNO_QUERY ); |
| if( xCTCnt.is()) |
| { |
| Sequence< Reference< XChartType > > aChartTypes( xCTCnt->getChartTypes()); |
| if( aChartTypes.getLength() > 0 ) |
| { |
| lcl_IndentedTrace( nIndent, "Chart Types" ); |
| for( sal_Int32 i=0; i<aChartTypes.getLength(); ++i ) |
| { |
| lcl_TraceChartType( aChartTypes[i], nIndent + 2 ); |
| } |
| } |
| } |
| } |
| catch( uno::Exception & ex ) |
| { |
| lcl_TraceException( ex ); |
| } |
| } |
| |
| void lcl_TraceMeter( |
| const Reference< XMeter > & xMeter, |
| const Sequence< Reference< XCoordinateSystem > > & aCooSys, |
| bool bWithCategories, |
| int nIndent ) |
| { |
| try |
| { |
| Reference< XCoordinateSystem > xCooSys( xMeter->getCoordinateSystem()); |
| for( sal_Int32 i=0; i<aCooSys.getLength(); ++i ) |
| if( aCooSys[i] == xCooSys ) |
| { |
| OSL_TRACE( "%*cbelongs to Coordinate System %ld.", nIndent + 2, lcl_aSpace, i ); |
| } |
| OSL_TRACE( "%*crepresents Dimension %ld.", nIndent + 2, lcl_aSpace, xMeter->getRepresentedDimension()); |
| if( bWithCategories ) |
| { |
| Reference< XScale > xScale( xCooSys->getAxisByDimension( xMeter->getRepresentedDimension(), xMeter->getIndex() )); |
| if( xScale.is()) |
| { |
| ScaleData aData = xScale->getScaleData(); |
| if( aData.Categories.is()) |
| { |
| lcl_TraceCategories( aData.Categories, nIndent + 2 ); |
| } |
| } |
| } |
| } |
| catch( uno::Exception & ex ) |
| { |
| lcl_TraceException( ex ); |
| } |
| } |
| */ |
| } // anonymous namespace |
| #endif |
| |
| |
| namespace chart |
| { |
| namespace debug |
| { |
| |
| #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL |
| |
| void ChartDebugTraceDocument( |
| const Reference< XChartDocument > & /*xDoc*/, |
| int /*nIndent*/ ) |
| { |
| /* |
| #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL |
| try |
| { |
| OSL_TRACE( "%*cas %sternal data", nIndent, 'h', |
| xDoc->hasInternalDataProvider() ? "in": "ex" ); |
| |
| Reference< lang::XMultiServiceFactory > xCTManager( xDoc->getChartTypeManager(), uno::UNO_QUERY ); |
| if( xCTManager.is()) |
| { |
| Sequence< OUString > aServiceNames( xCTManager->getAvailableServiceNames()); |
| OSL_TRACE( "%*c ChartTypeManager has %ld entries", nIndent, '*', aServiceNames.getLength()); |
| # if OSL_DEBUG_LEVEL >= (CHART_TRACE_OSL_DEBUG_LEVEL + 1) |
| for( sal_Int32 i=0; i<aServiceNames.getLength(); ++i ) |
| { |
| OSL_TRACE( "%*c%s", nIndent + 2, lcl_aSpace, U2C( aServiceNames[i] )); |
| } |
| # endif |
| } |
| Reference< XDiagram > xDiagram( xDoc->getFirstDiagram()); |
| lcl_IndentedTrace( nIndent, "* Diagram" ); |
| ChartDebugTraceDiagram( xDiagram, nIndent + 2 ); |
| } |
| catch( uno::Exception & ex ) |
| { |
| lcl_TraceException( ex ); |
| } |
| #endif |
| */ |
| } |
| |
| void ChartDebugTraceDiagram( |
| const Reference< XDiagram > & /*xDiagram*/, |
| int /*nIndent*/ ) |
| { |
| /* |
| #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL |
| try |
| { |
| Reference< XCoordinateSystemContainer > xCooSysCnt( xDiagram, uno::UNO_QUERY_THROW ); |
| Sequence< Reference< XCoordinateSystem > > aCooSys( xCooSysCnt->getCoordinateSystems() ); |
| if( aCooSys.getLength() > 0 ) |
| { |
| lcl_IndentedTrace( nIndent, "CoordinateSystems" ); |
| for( sal_Int32 i=0; i<aCooSys.getLength(); ++i ) |
| lcl_TraceCoordinateSystem( aCooSys[i], nIndent + 2 ); |
| } |
| else |
| { |
| lcl_IndentedTrace( nIndent, "<No Coordinate Systems>" ); |
| } |
| |
| Reference< XAxisContainer > xAxisCnt( xDiagram, uno::UNO_QUERY_THROW ); |
| Sequence< Reference< XAxis > > aAxes( xAxisCnt->getAxes() ); |
| if( aAxes.getLength() > 0 ) |
| { |
| lcl_IndentedTrace( nIndent, "Axes" ); |
| for( sal_Int32 i=0; i<aAxes.getLength(); ++i ) |
| lcl_TraceMeter( Reference< XMeter >( aAxes[i], uno::UNO_QUERY ), aCooSys, true, nIndent + 2 ); |
| } |
| else |
| { |
| lcl_IndentedTrace( nIndent, "<No Axes>" ); |
| } |
| |
| Reference< XGridContainer > xGridCnt( xDiagram, uno::UNO_QUERY_THROW ); |
| Sequence< Reference< XGrid > > aGrids( xGridCnt->getGrids() ); |
| if( aGrids.getLength() > 0 ) |
| { |
| lcl_IndentedTrace( nIndent, "Grids" ); |
| for( sal_Int32 i=0; i<aGrids.getLength(); ++i ) |
| lcl_TraceMeter( Reference< XMeter >( aGrids[i], uno::UNO_QUERY ), aCooSys, false, nIndent + 2 ); |
| } |
| else |
| { |
| lcl_IndentedTrace( nIndent, "<No Grids>" ); |
| } |
| } |
| catch( uno::Exception & ex ) |
| { |
| lcl_TraceException( ex ); |
| } |
| |
| #endif |
| |
| */ |
| } |
| #endif |
| |
| } // namespace debug |
| } // namespace chart |
