chart2/source/tools/ReferenceSizeProvider.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: ReferenceSizeProvider.cxx,v $
  10  * $Revision: 1.5.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 "ReferenceSizeProvider.hxx"
  35 #include "RelativeSizeHelper.hxx"
  36 #include "ChartModelHelper.hxx"
  37 #include "DiagramHelper.hxx"
  38 #include "macros.hxx"
  39 #include "AxisHelper.hxx"
  40 #include "DataSeriesHelper.hxx"
  41
  42 #include <com/sun/star/chart2/XTitled.hpp>
  43 #include <com/sun/star/chart2/XTitle.hpp>
  44 #include <com/sun/star/chart2/XDataSeries.hpp>
  45
  46 #include <vector>
  47
  48 using namespace ::com::sun::star;
  49 using namespace ::com::sun::star::chart2;
  50
  51 using ::com::sun::star::uno::Reference;
  52 using ::com::sun::star::uno::Sequence;
  53 using ::rtl::OUString;
  54
  55 // ================================================================================
  56
  57 namespace chart
  58 {
  59
  60 ReferenceSizeProvider::ReferenceSizeProvider(
  61     awt::Size aPageSize,
  62     const Reference< XChartDocument > & xChartDoc ) :
  63         m_aPageSize( aPageSize ),
  64         m_xChartDoc( xChartDoc ),
  65         m_bUseAutoScale( getAutoResizeState( xChartDoc ) == AUTO_RESIZE_YES )
  66 {}
  67
  68 awt::Size ReferenceSizeProvider::getPageSize() const
  69 {
  70     return m_aPageSize;
  71 }
  72
  73 bool ReferenceSizeProvider::useAutoScale() const
  74 {
  75     return m_bUseAutoScale;
  76 }
  77
  78 void ReferenceSizeProvider::impl_setValuesAtTitled(
  79     const Reference< XTitled > & xTitled )
  80 {
  81     if( xTitled.is())
  82     {
  83         Reference< XTitle > xTitle( xTitled->getTitleObject());
  84         if( xTitle.is())
  85             setValuesAtTitle( xTitle );
  86     }
  87 }
  88
  89 void ReferenceSizeProvider::setValuesAtTitle(
  90     const Reference< XTitle > & xTitle )
  91 {
  92     try
  93     {
  94         Reference< beans::XPropertySet > xTitleProp( xTitle, uno::UNO_QUERY_THROW );
  95         awt::Size aOldRefSize;
  96         bool bHasOldRefSize(
  97             xTitleProp->getPropertyValue( C2U("ReferencePageSize")) >>= aOldRefSize );
  98
  99         // set from auto-resize on to off -> adapt font sizes at XFormattedStrings
 100         if( bHasOldRefSize && ! useAutoScale())
 101         {
 102             uno::Sequence< uno::Reference< XFormattedString > > aStrSeq(
 103                 xTitle->getText());
 104             for( sal_Int32 i=0; i<aStrSeq.getLength(); ++i )
 105             {
 106                 RelativeSizeHelper::adaptFontSizes(
 107                     Reference< beans::XPropertySet >( aStrSeq[i], uno::UNO_QUERY ),
 108                     aOldRefSize, getPageSize());
 109             }
 110         }
 111
 112         setValuesAtPropertySet( xTitleProp, /* bAdaptFontSizes = */ false );
 113     }
 114     catch( const uno::Exception & ex )
 115     {
 116         ASSERT_EXCEPTION( ex );
 117     }
 118 }
 119
 120 void ReferenceSizeProvider::setValuesAtAllDataSeries()
 121 {
 122     Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( m_xChartDoc ));
 123
 124     // DataSeries/Points
 125     ::std::vector< Reference< XDataSeries > > aSeries(
 126         DiagramHelper::getDataSeriesFromDiagram( xDiagram ));
 127
 128     for( ::std::vector< Reference< XDataSeries > >::const_iterator aIt( aSeries.begin());
 129          aIt != aSeries.end(); ++aIt )
 130     {
 131         Reference< beans::XPropertySet > xSeriesProp( *aIt, uno::UNO_QUERY );
 132         if( xSeriesProp.is())
 133         {
 134             // data points
 135             Sequence< sal_Int32 > aPointIndexes;
 136             try
 137             {
 138                 if( xSeriesProp->getPropertyValue( C2U("AttributedDataPoints")) >>= aPointIndexes )
 139                 {
 140                     for( sal_Int32 i=0; i< aPointIndexes.getLength(); ++i )
 141                         setValuesAtPropertySet(
 142                             (*aIt)->getDataPointByIndex( aPointIndexes[i] ) );
 143                 }
 144             }
 145             catch( const uno::Exception & ex )
 146             {
 147                 ASSERT_EXCEPTION( ex );
 148             }
 149
 150             //it is important to correct the datapoint properties first as they do reference the series properties
 151             setValuesAtPropertySet( xSeriesProp );
 152         }
 153     }
 154 }
 155
 156 void ReferenceSizeProvider::setValuesAtPropertySet(
 157     const Reference< beans::XPropertySet > & xProp,
 158     bool bAdaptFontSizes /* = true */ )
 159 {
 160     if( ! xProp.is())
 161         return;
 162
 163     static const OUString aRefSizeName( RTL_CONSTASCII_USTRINGPARAM("ReferencePageSize"));
 164
 165     try
 166     {
 167         awt::Size aRefSize( getPageSize() );
 168         awt::Size aOldRefSize;
 169         bool bHasOldRefSize( xProp->getPropertyValue( aRefSizeName ) >>= aOldRefSize );
 170
 171         if( useAutoScale())
 172         {
 173             if( ! bHasOldRefSize )
 174                 xProp->setPropertyValue( aRefSizeName, uno::makeAny( aRefSize ));
 175         }
 176         else
 177         {
 178             if( bHasOldRefSize )
 179             {
 180                 xProp->setPropertyValue( aRefSizeName, uno::Any());
 181
 182                 // adapt font sizes
 183                 if( bAdaptFontSizes )
 184                     RelativeSizeHelper::adaptFontSizes( xProp, aOldRefSize, aRefSize );
 185             }
 186         }
 187     }
 188     catch( const uno::Exception & ex )
 189     {
 190         ASSERT_EXCEPTION( ex );
 191     }
 192 }
 193
 194 void ReferenceSizeProvider::getAutoResizeFromPropSet(
 195     const Reference< beans::XPropertySet > & xProp,
 196     ReferenceSizeProvider::AutoResizeState & rInOutState )
 197 {
 198     static const OUString aRefSizeName( RTL_CONSTASCII_USTRINGPARAM("ReferencePageSize"));
 199     AutoResizeState eSingleState = AUTO_RESIZE_UNKNOWN;
 200
 201     if( xProp.is())
 202     {
 203         try
 204         {
 205             if( xProp->getPropertyValue( aRefSizeName ).hasValue())
 206                 eSingleState = AUTO_RESIZE_YES;
 207             else
 208                 eSingleState = AUTO_RESIZE_NO;
 209         }
 210         catch( uno::Exception )
 211         {
 212             // unknown property -> state stays unknown
 213         }
 214     }
 215
 216     // curent state unknown => nothing changes.  Otherwise if current state
 217     // differs from state so far, we have an ambiguity
 218     if( rInOutState == AUTO_RESIZE_UNKNOWN )
 219     {
 220         rInOutState = eSingleState;
 221     }
 222     else if( eSingleState != AUTO_RESIZE_UNKNOWN &&
 223         eSingleState != rInOutState )
 224     {
 225         rInOutState = AUTO_RESIZE_AMBIGUOUS;
 226     }
 227 }
 228
 229 void ReferenceSizeProvider::impl_getAutoResizeFromTitled(
 230     const Reference< XTitled > & xTitled,
 231     ReferenceSizeProvider::AutoResizeState & rInOutState )
 232 {
 233     if( xTitled.is())
 234     {
 235         Reference< beans::XPropertySet > xProp( xTitled->getTitleObject(), uno::UNO_QUERY );
 236         if( xProp.is())
 237             getAutoResizeFromPropSet( xProp, rInOutState );
 238     }
 239 }
 240
 241 /** Retrieves the state auto-resize from all objects that support this
 242     feature.  If all objects return the same state, AUTO_RESIZE_YES or
 243     AUTO_RESIZE_NO is returned.
 244
 245     If no object supporting the feature is found, AUTO_RESIZE_UNKNOWN is
 246     returned.  If there are multiple objects, some with state YES and some
 247     with state NO, AUTO_RESIZE_AMBIGUOUS is returned.
 248 */
 249 ReferenceSizeProvider::AutoResizeState ReferenceSizeProvider::getAutoResizeState(
 250     const Reference< XChartDocument > & xChartDoc )
 251 {
 252     AutoResizeState eResult = AUTO_RESIZE_UNKNOWN;
 253
 254     // Main Title
 255     Reference< XTitled > xDocTitled( xChartDoc, uno::UNO_QUERY );
 256     if( xDocTitled.is())
 257         impl_getAutoResizeFromTitled( xDocTitled, eResult );
 258     if( eResult == AUTO_RESIZE_AMBIGUOUS )
 259         return eResult;
 260
 261     // diagram is needed by the rest of the objects
 262     Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartDoc ), uno::UNO_QUERY );
 263     if( ! xDiagram.is())
 264         return eResult;
 265
 266     // Sub Title
 267     Reference< XTitled > xDiaTitled( xDiagram, uno::UNO_QUERY );
 268     if( xDiaTitled.is())
 269         impl_getAutoResizeFromTitled( xDiaTitled, eResult );
 270     if( eResult == AUTO_RESIZE_AMBIGUOUS )
 271         return eResult;
 272
 273     // Legend
 274     Reference< beans::XPropertySet > xLegendProp( xDiagram->getLegend(), uno::UNO_QUERY );
 275     if( xLegendProp.is())
 276         getAutoResizeFromPropSet( xLegendProp, eResult );
 277     if( eResult == AUTO_RESIZE_AMBIGUOUS )
 278         return eResult;
 279
 280     // Axes (incl. Axis Titles)
 281     Sequence< Reference< XAxis > > aAxes( AxisHelper::getAllAxesOfDiagram( xDiagram ) );
 282     for( sal_Int32 i=0; i<aAxes.getLength(); ++i )
 283     {
 284         Reference< beans::XPropertySet > xProp( aAxes[i], uno::UNO_QUERY );
 285         if( xProp.is())
 286             getAutoResizeFromPropSet( xProp, eResult );
 287         Reference< XTitled > xTitled( aAxes[i], uno::UNO_QUERY );
 288         if( xTitled.is())
 289         {
 290             impl_getAutoResizeFromTitled( xTitled, eResult );
 291             if( eResult == AUTO_RESIZE_AMBIGUOUS )
 292                 return eResult;
 293         }
 294     }
 295
 296     // DataSeries/Points
 297     ::std::vector< Reference< XDataSeries > > aSeries(
 298         DiagramHelper::getDataSeriesFromDiagram( xDiagram ));
 299
 300     for( ::std::vector< Reference< XDataSeries > >::const_iterator aIt( aSeries.begin());
 301          aIt != aSeries.end(); ++aIt )
 302     {
 303         Reference< beans::XPropertySet > xSeriesProp( *aIt, uno::UNO_QUERY );
 304         if( xSeriesProp.is())
 305         {
 306             getAutoResizeFromPropSet( xSeriesProp, eResult );
 307             if( eResult == AUTO_RESIZE_AMBIGUOUS )
 308                 return eResult;
 309
 310             // data points
 311             Sequence< sal_Int32 > aPointIndexes;
 312             try
 313             {
 314                 if( xSeriesProp->getPropertyValue( C2U("AttributedDataPoints")) >>= aPointIndexes )
 315                 {
 316                     for( sal_Int32 i=0; i< aPointIndexes.getLength(); ++i )
 317                     {
 318                         getAutoResizeFromPropSet(
 319                             (*aIt)->getDataPointByIndex( aPointIndexes[i] ), eResult );
 320                         if( eResult == AUTO_RESIZE_AMBIGUOUS )
 321                             return eResult;
 322                     }
 323                 }
 324             }
 325             catch( const uno::Exception & ex )
 326             {
 327                 ASSERT_EXCEPTION( ex );
 328             }
 329         }
 330     }
 331
 332     return eResult;
 333 }
 334
 335 void ReferenceSizeProvider::toggleAutoResizeState()
 336 {
 337     setAutoResizeState( m_bUseAutoScale ? AUTO_RESIZE_NO : AUTO_RESIZE_YES );
 338 }
 339
 340
 341 /** sets the auto-resize at all objects that support this feature for text.
 342     eNewState must be either AUTO_RESIZE_YES or AUTO_RESIZE_NO
 343 */
 344 void ReferenceSizeProvider::setAutoResizeState( ReferenceSizeProvider::AutoResizeState eNewState )
 345 {
 346     m_bUseAutoScale = (eNewState == AUTO_RESIZE_YES);
 347
 348     // Main Title
 349     impl_setValuesAtTitled( Reference< XTitled >( m_xChartDoc, uno::UNO_QUERY ));
 350
 351     // diagram is needed by the rest of the objects
 352     Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( m_xChartDoc ), uno::UNO_QUERY );
 353     if( ! xDiagram.is())
 354         return;
 355
 356     // Sub Title
 357     impl_setValuesAtTitled( Reference< XTitled >( xDiagram, uno::UNO_QUERY ));
 358
 359     // Legend
 360     Reference< beans::XPropertySet > xLegendProp( xDiagram->getLegend(), uno::UNO_QUERY );
 361     if( xLegendProp.is())
 362         setValuesAtPropertySet( xLegendProp );
 363
 364     // Axes (incl. Axis Titles)
 365     Sequence< Reference< XAxis > > aAxes( AxisHelper::getAllAxesOfDiagram( xDiagram ) );
 366     for( sal_Int32 i=0; i<aAxes.getLength(); ++i )
 367     {
 368         Reference< beans::XPropertySet > xProp( aAxes[i], uno::UNO_QUERY );
 369         if( xProp.is())
 370             setValuesAtPropertySet( xProp );
 371         impl_setValuesAtTitled( Reference< XTitled >( aAxes[i], uno::UNO_QUERY ));
 372     }
 373
 374     // DataSeries/Points
 375     setValuesAtAllDataSeries();
 376
 377     // recalculate new state (in case it stays unknown or is ambiguous
 378     m_bUseAutoScale = (getAutoResizeState( m_xChartDoc ) == AUTO_RESIZE_YES);
 379 }
 380
 381 } //  namespace chart