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