1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_chart2.hxx" 26 27 #include "ChartDebugTrace.hxx" 28 #include "macros.hxx" 29 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 30 #include <com/sun/star/chart2/AxisType.hpp> 31 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp> 32 #include <com/sun/star/chart2/XChartTypeContainer.hpp> 33 #include <com/sun/star/chart2/XDataSeriesContainer.hpp> 34 #include <com/sun/star/chart2/StackingDirection.hpp> 35 #include <rtl/math.hxx> 36 37 using namespace ::com::sun::star; 38 using namespace ::com::sun::star::chart2; 39 40 using ::com::sun::star::uno::Reference; 41 using ::com::sun::star::uno::Sequence; 42 using ::rtl::OUString; 43 44 #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL 45 46 namespace 47 { 48 /* 49 const char lcl_aSpace=' '; 50 51 void lcl_IndentedTrace( int nIndent, char* pStr ) 52 { 53 if( nIndent > 0 ) 54 { 55 OSL_TRACE( "%*c%s", nIndent, lcl_aSpace, pStr ); 56 } 57 else 58 { 59 OSL_TRACE( pStr ); 60 } 61 } 62 63 void lcl_TraceException( const uno::Exception & aEx ) 64 { 65 OSL_TRACE( 66 U2C( C2U( "*** Exception caught during trace. Type: " ) + 67 OUString::createFromAscii( typeid( aEx ).name()) + 68 C2U( ", Message: " ) + 69 aEx.Message )); 70 } 71 72 void lcl_TraceCategories( const Reference< data::XLabeledDataSequence > & xCat, int nIndent ) 73 { 74 if( ! xCat.is()) 75 return; 76 try 77 { 78 Reference< data::XDataSequence > xValues( xCat->getValues()); 79 if( xValues.is()) 80 { 81 OSL_TRACE( "%*ccategories: source: %s", nIndent, lcl_aSpace, 82 U2C( xValues->getSourceRangeRepresentation())); 83 } 84 Reference< data::XDataSequence > xLabel( xCat->getLabel()); 85 if( xLabel.is()) 86 { 87 OSL_TRACE( "%*ccategories' label: source: %s", nIndent, lcl_aSpace, 88 U2C( xLabel->getSourceRangeRepresentation())); 89 } 90 } 91 catch( uno::Exception & ex ) 92 { 93 lcl_TraceException( ex ); 94 } 95 } 96 97 void lcl_TraceDataSeriesSeq( const Sequence< Reference< XDataSeries > > & aSeries, int nIndent ) 98 { 99 for( sal_Int32 j = 0; j < aSeries.getLength(); ++j ) 100 { 101 Reference< beans::XPropertySet > xProp( aSeries[j], uno::UNO_QUERY ); 102 OUString aId; 103 104 OSL_TRACE( "%*cindex %ld", nIndent, lcl_aSpace, j ); 105 106 StackingDirection aStDir; 107 if( xProp.is() && 108 ( xProp->getPropertyValue( C2U( "StackingDirection" )) >>= aStDir ) && 109 aStDir != StackingDirection_NO_STACKING ) 110 { 111 OSL_TRACE( "%*cstacking in %s", nIndent + 2, lcl_aSpace, 112 (aStDir == StackingDirection_Y_STACKING) 113 ? "y-direction" : "z-direction" ); 114 } 115 116 Reference< data::XDataSource > xSource( aSeries[j], uno::UNO_QUERY ); 117 if( xSource.is()) 118 { 119 Sequence< Reference< data::XLabeledDataSequence > > aSequences( xSource->getDataSequences()); 120 const sal_Int32 nMax = aSequences.getLength(); 121 for( sal_Int32 k = 0; k < nMax; ++k ) 122 { 123 if( aSequences[k].is()) 124 { 125 OUString aSourceId(C2U("<none>")); 126 if( aSequences[k]->getValues().is()) 127 aSourceId = aSequences[k]->getValues()->getSourceRangeRepresentation(); 128 xProp.set( aSequences[k]->getValues(), uno::UNO_QUERY ); 129 if( xProp.is() && 130 ( xProp->getPropertyValue( C2U( "Role" )) >>= aId )) 131 { 132 OSL_TRACE( "%*cdata sequence %d: role: %s, source: %s", 133 nIndent + 2, lcl_aSpace, k, U2C( aId ), U2C( aSourceId )); 134 } 135 else 136 { 137 OSL_TRACE( "%*cdata sequence %d, unknown role, source: %s", 138 nIndent + 2, lcl_aSpace, k, U2C( aSourceId ) ); 139 } 140 141 aSourceId = C2U("<none>"); 142 if( aSequences[k]->getLabel().is()) 143 aSourceId = OUString( aSequences[k]->getLabel()->getSourceRangeRepresentation()); 144 xProp.set( aSequences[k]->getLabel(), uno::UNO_QUERY ); 145 if( xProp.is() && 146 ( xProp->getPropertyValue( C2U( "Role" )) >>= aId )) 147 { 148 OSL_TRACE( "%*cdata sequence label %d: role: %s, source: %s", 149 nIndent + 2, lcl_aSpace, k, U2C( aId ), U2C( aSourceId )); 150 } 151 else 152 { 153 OSL_TRACE( "%*cdata sequence label %d: unknown role, source: %s", 154 nIndent + 2, lcl_aSpace, k, U2C( aSourceId ) ); 155 } 156 } 157 } 158 } 159 } 160 } 161 162 void lcl_TraceChartType( const Reference< XChartType > & xChartType, int nIndent ) 163 { 164 if( xChartType.is()) 165 { 166 OSL_TRACE( "%*c* type: %s", nIndent, lcl_aSpace, U2C( xChartType->getChartType()) ); 167 168 lcl_IndentedTrace( nIndent + 2, "Supported Roles" ); 169 sal_Int32 i=0; 170 Sequence< OUString > aMandRoles( xChartType->getSupportedMandatoryRoles()); 171 if( aMandRoles.getLength() > 0 ) 172 { 173 lcl_IndentedTrace( nIndent + 4, "mandatory" ); 174 for( i=0; i<aMandRoles.getLength(); ++i ) 175 { 176 OSL_TRACE( "%*c%s", nIndent + 6, lcl_aSpace, U2C( aMandRoles[i] )); 177 } 178 } 179 Sequence< OUString > aOptRoles( xChartType->getSupportedOptionalRoles()); 180 if( aOptRoles.getLength() > 0 ) 181 { 182 lcl_IndentedTrace( nIndent + 4, "optional" ); 183 for( i=0; i<aOptRoles.getLength(); ++i ) 184 { 185 OSL_TRACE( "%*c%s", nIndent + 6, lcl_aSpace, U2C( aOptRoles[i] )); 186 } 187 } 188 OSL_TRACE( "%*crole of sequence for label: %s", nIndent + 2, lcl_aSpace, 189 U2C( xChartType->getRoleOfSequenceForSeriesLabel())); 190 191 Reference< XDataSeriesContainer > xDSCnt( xChartType, uno::UNO_QUERY ); 192 if( xDSCnt.is()) 193 { 194 lcl_IndentedTrace( nIndent + 2, "Data Series" ); 195 lcl_TraceDataSeriesSeq( xDSCnt->getDataSeries(), nIndent + 4 ); 196 } 197 } 198 } 199 200 void lcl_TraceCoordinateSystem( const Reference< XCoordinateSystem > & xCooSys, int nIndent ) 201 { 202 if( xCooSys.is()) try 203 { 204 sal_Int32 nDim = xCooSys->getDimension(); 205 OSL_TRACE( "%*c* dim: %ld, type: %s", nIndent, lcl_aSpace, 206 nDim, U2C( xCooSys->getCoordinateSystemType() )); 207 nIndent += 2; 208 OSL_TRACE( "%*cview service-name: %s", nIndent, lcl_aSpace, 209 U2C( xCooSys->getViewServiceName() )); 210 211 Reference< beans::XPropertySet > xProp( xCooSys, uno::UNO_QUERY ); 212 if( xProp.is()) 213 { 214 Reference< beans::XPropertySetInfo > xInfo( xProp->getPropertySetInfo(), uno::UNO_QUERY ); 215 sal_Bool bSwap; 216 if( xInfo.is() && 217 xInfo->hasPropertyByName( C2U("SwapXAndYAxis")) && 218 (xProp->getPropertyValue( C2U("SwapXAndYAxis")) >>= bSwap) && 219 bSwap ) 220 { 221 lcl_IndentedTrace( nIndent, "swap x-axis and y-axis" ); 222 } 223 } 224 225 if( nDim >= 2 ) 226 { 227 const sal_Int32 nMaxIndex = xCooSys->getMaximumAxisIndexByDimension(1); 228 for(sal_Int32 nI=0; nI<=nMaxIndex; ++nI) 229 { 230 Reference< XScale > xScale( xCooSys->getAxisByDimension( 1, nI )); 231 if( xScale.is()) 232 { 233 ScaleData aData( xScale->getScaleData()); 234 if( aData.AxisType==AxisType::PERCENT ) 235 lcl_IndentedTrace( nIndent, "percent stacking at y-scale" ); 236 } 237 } 238 } 239 240 Sequence< uno::Any > aOrigin( xCooSys->getOrigin()); 241 double x, y, z; 242 ::rtl::math::setNan( &x ), ::rtl::math::setNan( &y ), ::rtl::math::setNan( &z ); 243 if( aOrigin.getLength() > 0 && 244 aOrigin[0].hasValue() ) 245 aOrigin[0] >>= x; 246 if( aOrigin.getLength() > 1 && 247 aOrigin[1].hasValue() ) 248 aOrigin[1] >>= y; 249 if( aOrigin.getLength() > 2 && 250 aOrigin[2].hasValue() ) 251 aOrigin[2] >>= z; 252 OSL_TRACE( "%*corigin: (%f, %f, %f)", nIndent, lcl_aSpace, x, y, z ); 253 254 Reference< XChartTypeContainer > xCTCnt( xCooSys, uno::UNO_QUERY ); 255 if( xCTCnt.is()) 256 { 257 Sequence< Reference< XChartType > > aChartTypes( xCTCnt->getChartTypes()); 258 if( aChartTypes.getLength() > 0 ) 259 { 260 lcl_IndentedTrace( nIndent, "Chart Types" ); 261 for( sal_Int32 i=0; i<aChartTypes.getLength(); ++i ) 262 { 263 lcl_TraceChartType( aChartTypes[i], nIndent + 2 ); 264 } 265 } 266 } 267 } 268 catch( uno::Exception & ex ) 269 { 270 lcl_TraceException( ex ); 271 } 272 } 273 274 void lcl_TraceMeter( 275 const Reference< XMeter > & xMeter, 276 const Sequence< Reference< XCoordinateSystem > > & aCooSys, 277 bool bWithCategories, 278 int nIndent ) 279 { 280 try 281 { 282 Reference< XCoordinateSystem > xCooSys( xMeter->getCoordinateSystem()); 283 for( sal_Int32 i=0; i<aCooSys.getLength(); ++i ) 284 if( aCooSys[i] == xCooSys ) 285 { 286 OSL_TRACE( "%*cbelongs to Coordinate System %ld.", nIndent + 2, lcl_aSpace, i ); 287 } 288 OSL_TRACE( "%*crepresents Dimension %ld.", nIndent + 2, lcl_aSpace, xMeter->getRepresentedDimension()); 289 if( bWithCategories ) 290 { 291 Reference< XScale > xScale( xCooSys->getAxisByDimension( xMeter->getRepresentedDimension(), xMeter->getIndex() )); 292 if( xScale.is()) 293 { 294 ScaleData aData = xScale->getScaleData(); 295 if( aData.Categories.is()) 296 { 297 lcl_TraceCategories( aData.Categories, nIndent + 2 ); 298 } 299 } 300 } 301 } 302 catch( uno::Exception & ex ) 303 { 304 lcl_TraceException( ex ); 305 } 306 } 307 */ 308 } // anonymous namespace 309 #endif 310 311 312 namespace chart 313 { 314 namespace debug 315 { 316 317 #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL 318 319 void ChartDebugTraceDocument( 320 const Reference< XChartDocument > & /*xDoc*/, 321 int /*nIndent*/ ) 322 { 323 /* 324 #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL 325 try 326 { 327 OSL_TRACE( "%*cas %sternal data", nIndent, 'h', 328 xDoc->hasInternalDataProvider() ? "in": "ex" ); 329 330 Reference< lang::XMultiServiceFactory > xCTManager( xDoc->getChartTypeManager(), uno::UNO_QUERY ); 331 if( xCTManager.is()) 332 { 333 Sequence< OUString > aServiceNames( xCTManager->getAvailableServiceNames()); 334 OSL_TRACE( "%*c ChartTypeManager has %ld entries", nIndent, '*', aServiceNames.getLength()); 335 # if OSL_DEBUG_LEVEL >= (CHART_TRACE_OSL_DEBUG_LEVEL + 1) 336 for( sal_Int32 i=0; i<aServiceNames.getLength(); ++i ) 337 { 338 OSL_TRACE( "%*c%s", nIndent + 2, lcl_aSpace, U2C( aServiceNames[i] )); 339 } 340 # endif 341 } 342 Reference< XDiagram > xDiagram( xDoc->getFirstDiagram()); 343 lcl_IndentedTrace( nIndent, "* Diagram" ); 344 ChartDebugTraceDiagram( xDiagram, nIndent + 2 ); 345 } 346 catch( uno::Exception & ex ) 347 { 348 lcl_TraceException( ex ); 349 } 350 #endif 351 */ 352 } 353 354 void ChartDebugTraceDiagram( 355 const Reference< XDiagram > & /*xDiagram*/, 356 int /*nIndent*/ ) 357 { 358 /* 359 #if OSL_DEBUG_LEVEL >= CHART_TRACE_OSL_DEBUG_LEVEL 360 try 361 { 362 Reference< XCoordinateSystemContainer > xCooSysCnt( xDiagram, uno::UNO_QUERY_THROW ); 363 Sequence< Reference< XCoordinateSystem > > aCooSys( xCooSysCnt->getCoordinateSystems() ); 364 if( aCooSys.getLength() > 0 ) 365 { 366 lcl_IndentedTrace( nIndent, "CoordinateSystems" ); 367 for( sal_Int32 i=0; i<aCooSys.getLength(); ++i ) 368 lcl_TraceCoordinateSystem( aCooSys[i], nIndent + 2 ); 369 } 370 else 371 { 372 lcl_IndentedTrace( nIndent, "<No Coordinate Systems>" ); 373 } 374 375 Reference< XAxisContainer > xAxisCnt( xDiagram, uno::UNO_QUERY_THROW ); 376 Sequence< Reference< XAxis > > aAxes( xAxisCnt->getAxes() ); 377 if( aAxes.getLength() > 0 ) 378 { 379 lcl_IndentedTrace( nIndent, "Axes" ); 380 for( sal_Int32 i=0; i<aAxes.getLength(); ++i ) 381 lcl_TraceMeter( Reference< XMeter >( aAxes[i], uno::UNO_QUERY ), aCooSys, true, nIndent + 2 ); 382 } 383 else 384 { 385 lcl_IndentedTrace( nIndent, "<No Axes>" ); 386 } 387 388 Reference< XGridContainer > xGridCnt( xDiagram, uno::UNO_QUERY_THROW ); 389 Sequence< Reference< XGrid > > aGrids( xGridCnt->getGrids() ); 390 if( aGrids.getLength() > 0 ) 391 { 392 lcl_IndentedTrace( nIndent, "Grids" ); 393 for( sal_Int32 i=0; i<aGrids.getLength(); ++i ) 394 lcl_TraceMeter( Reference< XMeter >( aGrids[i], uno::UNO_QUERY ), aCooSys, false, nIndent + 2 ); 395 } 396 else 397 { 398 lcl_IndentedTrace( nIndent, "<No Grids>" ); 399 } 400 } 401 catch( uno::Exception & ex ) 402 { 403 lcl_TraceException( ex ); 404 } 405 406 #endif 407 408 */ 409 } 410 #endif 411 412 } // namespace debug 413 } // namespace chart 414