chart2/source/tools/ChartDebugTrace.cxx

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