chart2/source/tools/ReferenceSizeProvider.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <ReferenceSizeProvider.hxx>
  21 #include <RelativeSizeHelper.hxx>
  22 #include <ChartModelHelper.hxx>
  23 #include <DiagramHelper.hxx>
  24 #include <AxisHelper.hxx>
  25
  26 #include <com/sun/star/chart2/XTitled.hpp>
  27 #include <com/sun/star/chart2/XTitle.hpp>
  28 #include <com/sun/star/chart2/XDataSeries.hpp>
  29 #include <tools/diagnose_ex.h>
  30
  31 #include <vector>
  32
  33 using namespace ::com::sun::star;
  34 using namespace ::com::sun::star::chart2;
  35
  36 using ::com::sun::star::uno::Reference;
  37 using ::com::sun::star::uno::Sequence;
  38
  39 namespace chart
  40 {
  41
  42 ReferenceSizeProvider::ReferenceSizeProvider(
  43     awt::Size aPageSize,
  44     const Reference< XChartDocument > & xChartDoc ) :
  45         m_aPageSize( aPageSize ),
  46         m_xChartDoc( xChartDoc ),
  47         m_bUseAutoScale( getAutoResizeState( xChartDoc ) == AUTO_RESIZE_YES )
  48 {}
  49
  50 void ReferenceSizeProvider::impl_setValuesAtTitled(
  51     const Reference< XTitled > & xTitled )
  52 {
  53     if( xTitled.is())
  54     {
  55         Reference< XTitle > xTitle( xTitled->getTitleObject());
  56         if( xTitle.is())
  57             setValuesAtTitle( xTitle );
  58     }
  59 }
  60
  61 void ReferenceSizeProvider::setValuesAtTitle(
  62     const Reference< XTitle > & xTitle )
  63 {
  64     try
  65     {
  66         Reference< beans::XPropertySet > xTitleProp( xTitle, uno::UNO_QUERY_THROW );
  67         awt::Size aOldRefSize;
  68         bool bHasOldRefSize(
  69             xTitleProp->getPropertyValue( "ReferencePageSize") >>= aOldRefSize );
  70
  71         // set from auto-resize on to off -> adapt font sizes at XFormattedStrings
  72         if( bHasOldRefSize && ! useAutoScale())
  73         {
  74             uno::Sequence< uno::Reference< XFormattedString > > aStrSeq(
  75                 xTitle->getText());
  76             for( sal_Int32 i=0; i<aStrSeq.getLength(); ++i )
  77             {
  78                 RelativeSizeHelper::adaptFontSizes(
  79                     Reference< beans::XPropertySet >( aStrSeq[i], uno::UNO_QUERY ),
  80                     aOldRefSize, getPageSize());
  81             }
  82         }
  83
  84         setValuesAtPropertySet( xTitleProp, /* bAdaptFontSizes = */ false );
  85     }
  86     catch (const uno::Exception&)
  87     {
  88         DBG_UNHANDLED_EXCEPTION("chart2");
  89     }
  90 }
  91
  92 void ReferenceSizeProvider::setValuesAtAllDataSeries()
  93 {
  94     Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( m_xChartDoc ));
  95
  96     // DataSeries/Points
  97     std::vector< Reference< XDataSeries > > aSeries(
  98         DiagramHelper::getDataSeriesFromDiagram( xDiagram ));
  99
 100     for (auto const& elem : aSeries)
 101     {
 102         Reference< beans::XPropertySet > xSeriesProp(elem, uno::UNO_QUERY );
 103         if( xSeriesProp.is())
 104         {
 105             // data points
 106             Sequence< sal_Int32 > aPointIndexes;
 107             try
 108             {
 109                 if( xSeriesProp->getPropertyValue( "AttributedDataPoints") >>= aPointIndexes )
 110                 {
 111                     for( sal_Int32 i=0; i< aPointIndexes.getLength(); ++i )
 112                         setValuesAtPropertySet(
 113                             elem->getDataPointByIndex( aPointIndexes[i] ) );
 114                 }
 115             }
 116             catch (const uno::Exception&)
 117             {
 118                 DBG_UNHANDLED_EXCEPTION("chart2");
 119             }
 120
 121             //it is important to correct the datapoint properties first as they do reference the series properties
 122             setValuesAtPropertySet( xSeriesProp );
 123         }
 124     }
 125 }
 126
 127 void ReferenceSizeProvider::setValuesAtPropertySet(
 128     const Reference< beans::XPropertySet > & xProp,
 129     bool bAdaptFontSizes /* = true */ )
 130 {
 131     if( ! xProp.is())
 132         return;
 133
 134     static const char aRefSizeName[] = "ReferencePageSize";
 135
 136     try
 137     {
 138         awt::Size aRefSize( getPageSize() );
 139         awt::Size aOldRefSize;
 140         bool bHasOldRefSize( xProp->getPropertyValue( aRefSizeName ) >>= aOldRefSize );
 141
 142         if( useAutoScale())
 143         {
 144             if( ! bHasOldRefSize )
 145                 xProp->setPropertyValue( aRefSizeName, uno::Any( aRefSize ));
 146         }
 147         else
 148         {
 149             if( bHasOldRefSize )
 150             {
 151                 xProp->setPropertyValue( aRefSizeName, uno::Any());
 152
 153                 // adapt font sizes
 154                 if( bAdaptFontSizes )
 155                     RelativeSizeHelper::adaptFontSizes( xProp, aOldRefSize, aRefSize );
 156             }
 157         }
 158     }
 159     catch (const uno::Exception&)
 160     {
 161         DBG_UNHANDLED_EXCEPTION("chart2");
 162     }
 163 }
 164
 165 void ReferenceSizeProvider::getAutoResizeFromPropSet(
 166     const Reference< beans::XPropertySet > & xProp,
 167     ReferenceSizeProvider::AutoResizeState & rInOutState )
 168 {
 169     AutoResizeState eSingleState = AUTO_RESIZE_UNKNOWN;
 170
 171     if( xProp.is())
 172     {
 173         try
 174         {
 175             if( xProp->getPropertyValue( "ReferencePageSize" ).hasValue())
 176                 eSingleState = AUTO_RESIZE_YES;
 177             else
 178                 eSingleState = AUTO_RESIZE_NO;
 179         }
 180         catch (const uno::Exception&)
 181         {
 182             // unknown property -> state stays unknown
 183         }
 184     }
 185
 186     // current state unknown => nothing changes.  Otherwise if current state
 187     // differs from state so far, we have an ambiguity
 188     if( rInOutState == AUTO_RESIZE_UNKNOWN )
 189     {
 190         rInOutState = eSingleState;
 191     }
 192     else if( eSingleState != AUTO_RESIZE_UNKNOWN &&
 193         eSingleState != rInOutState )
 194     {
 195         rInOutState = AUTO_RESIZE_AMBIGUOUS;
 196     }
 197 }
 198
 199 void ReferenceSizeProvider::impl_getAutoResizeFromTitled(
 200     const Reference< XTitled > & xTitled,
 201     ReferenceSizeProvider::AutoResizeState & rInOutState )
 202 {
 203     if( xTitled.is())
 204     {
 205         Reference< beans::XPropertySet > xProp( xTitled->getTitleObject(), uno::UNO_QUERY );
 206         if( xProp.is())
 207             getAutoResizeFromPropSet( xProp, rInOutState );
 208     }
 209 }
 210
 211 /** Retrieves the state auto-resize from all objects that support this
 212     feature.  If all objects return the same state, AUTO_RESIZE_YES or
 213     AUTO_RESIZE_NO is returned.
 214
 215     If no object supporting the feature is found, AUTO_RESIZE_UNKNOWN is
 216     returned.  If there are multiple objects, some with state YES and some
 217     with state NO, AUTO_RESIZE_AMBIGUOUS is returned.
 218 */
 219 ReferenceSizeProvider::AutoResizeState ReferenceSizeProvider::getAutoResizeState(
 220     const Reference< XChartDocument > & xChartDoc )
 221 {
 222     AutoResizeState eResult = AUTO_RESIZE_UNKNOWN;
 223
 224     // Main Title
 225     Reference< XTitled > xDocTitled( xChartDoc, uno::UNO_QUERY );
 226     if( xDocTitled.is())
 227         impl_getAutoResizeFromTitled( xDocTitled, eResult );
 228     if( eResult == AUTO_RESIZE_AMBIGUOUS )
 229         return eResult;
 230
 231     // diagram is needed by the rest of the objects
 232     Reference< XDiagram > xDiagram = ChartModelHelper::findDiagram( xChartDoc );
 233     if( ! xDiagram.is())
 234         return eResult;
 235
 236     // Sub Title
 237     Reference< XTitled > xDiaTitled( xDiagram, uno::UNO_QUERY );
 238     if( xDiaTitled.is())
 239         impl_getAutoResizeFromTitled( xDiaTitled, eResult );
 240     if( eResult == AUTO_RESIZE_AMBIGUOUS )
 241         return eResult;
 242
 243     // Legend
 244     Reference< beans::XPropertySet > xLegendProp( xDiagram->getLegend(), uno::UNO_QUERY );
 245     if( xLegendProp.is())
 246         getAutoResizeFromPropSet( xLegendProp, eResult );
 247     if( eResult == AUTO_RESIZE_AMBIGUOUS )
 248         return eResult;
 249
 250     // Axes (incl. Axis Titles)
 251     Sequence< Reference< XAxis > > aAxes( AxisHelper::getAllAxesOfDiagram( xDiagram ) );
 252     for( sal_Int32 i=0; i<aAxes.getLength(); ++i )
 253     {
 254         Reference< beans::XPropertySet > xProp( aAxes[i], uno::UNO_QUERY );
 255         if( xProp.is())
 256             getAutoResizeFromPropSet( xProp, eResult );
 257         Reference< XTitled > xTitled( aAxes[i], uno::UNO_QUERY );
 258         if( xTitled.is())
 259         {
 260             impl_getAutoResizeFromTitled( xTitled, eResult );
 261             if( eResult == AUTO_RESIZE_AMBIGUOUS )
 262                 return eResult;
 263         }
 264     }
 265
 266     // DataSeries/Points
 267     std::vector< Reference< XDataSeries > > aSeries(
 268         DiagramHelper::getDataSeriesFromDiagram( xDiagram ));
 269
 270     for (auto const& elem : aSeries)
 271     {
 272         Reference< beans::XPropertySet > xSeriesProp(elem, uno::UNO_QUERY);
 273         if( xSeriesProp.is())
 274         {
 275             getAutoResizeFromPropSet( xSeriesProp, eResult );
 276             if( eResult == AUTO_RESIZE_AMBIGUOUS )
 277                 return eResult;
 278
 279             // data points
 280             Sequence< sal_Int32 > aPointIndexes;
 281             try
 282             {
 283                 if( xSeriesProp->getPropertyValue( "AttributedDataPoints") >>= aPointIndexes )
 284                 {
 285                     for( sal_Int32 i=0; i< aPointIndexes.getLength(); ++i )
 286                     {
 287                         getAutoResizeFromPropSet(
 288                             elem->getDataPointByIndex( aPointIndexes[i] ), eResult );
 289                         if( eResult == AUTO_RESIZE_AMBIGUOUS )
 290                             return eResult;
 291                     }
 292                 }
 293             }
 294             catch (const uno::Exception&)
 295             {
 296                 DBG_UNHANDLED_EXCEPTION("chart2");
 297             }
 298         }
 299     }
 300
 301     return eResult;
 302 }
 303
 304 void ReferenceSizeProvider::toggleAutoResizeState()
 305 {
 306     setAutoResizeState( m_bUseAutoScale ? AUTO_RESIZE_NO : AUTO_RESIZE_YES );
 307 }
 308
 309 /** sets the auto-resize at all objects that support this feature for text.
 310     eNewState must be either AUTO_RESIZE_YES or AUTO_RESIZE_NO
 311 */
 312 void ReferenceSizeProvider::setAutoResizeState( ReferenceSizeProvider::AutoResizeState eNewState )
 313 {
 314     m_bUseAutoScale = (eNewState == AUTO_RESIZE_YES);
 315
 316     // Main Title
 317     impl_setValuesAtTitled( Reference< XTitled >( m_xChartDoc, uno::UNO_QUERY ));
 318
 319     // diagram is needed by the rest of the objects
 320     Reference< XDiagram > xDiagram = ChartModelHelper::findDiagram( m_xChartDoc );
 321     if( ! xDiagram.is())
 322         return;
 323
 324     // Sub Title
 325     impl_setValuesAtTitled( Reference< XTitled >( xDiagram, uno::UNO_QUERY ));
 326
 327     // Legend
 328     Reference< beans::XPropertySet > xLegendProp( xDiagram->getLegend(), uno::UNO_QUERY );
 329     if( xLegendProp.is())
 330         setValuesAtPropertySet( xLegendProp );
 331
 332     // Axes (incl. Axis Titles)
 333     Sequence< Reference< XAxis > > aAxes( AxisHelper::getAllAxesOfDiagram( xDiagram ) );
 334     for( sal_Int32 i=0; i<aAxes.getLength(); ++i )
 335     {
 336         Reference< beans::XPropertySet > xProp( aAxes[i], uno::UNO_QUERY );
 337         if( xProp.is())
 338             setValuesAtPropertySet( xProp );
 339         impl_setValuesAtTitled( Reference< XTitled >( aAxes[i], uno::UNO_QUERY ));
 340     }
 341
 342     // DataSeries/Points
 343     setValuesAtAllDataSeries();
 344
 345     // recalculate new state (in case it stays unknown or is ambiguous
 346     m_bUseAutoScale = (getAutoResizeState( m_xChartDoc ) == AUTO_RESIZE_YES);
 347 }
 348
 349 } //  namespace chart
 350
 351 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */