| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_charttools.hxx" | |
| #include "ReferenceSizeProvider.hxx" | |
| #include "RelativeSizeHelper.hxx" | |
| #include "ChartModelHelper.hxx" | |
| #include "DiagramHelper.hxx" | |
| #include "macros.hxx" | |
| #include "AxisHelper.hxx" | |
| #include "DataSeriesHelper.hxx" | |
| #include <com/sun/star/chart2/XTitled.hpp> | |
| #include <com/sun/star/chart2/XTitle.hpp> | |
| #include <com/sun/star/chart2/XDataSeries.hpp> | |
| #include <vector> | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::chart2; | |
| using ::com::sun::star::uno::Reference; | |
| using ::com::sun::star::uno::Sequence; | |
| using ::rtl::OUString; | |
| // ================================================================================ | |
| namespace chart | |
| { | |
| ReferenceSizeProvider::ReferenceSizeProvider( | |
| awt::Size aPageSize, | |
| const Reference< XChartDocument > & xChartDoc ) : | |
| m_aPageSize( aPageSize ), | |
| m_xChartDoc( xChartDoc ), | |
| m_bUseAutoScale( getAutoResizeState( xChartDoc ) == AUTO_RESIZE_YES ) | |
| {} | |
| awt::Size ReferenceSizeProvider::getPageSize() const | |
| { | |
| return m_aPageSize; | |
| } | |
| bool ReferenceSizeProvider::useAutoScale() const | |
| { | |
| return m_bUseAutoScale; | |
| } | |
| void ReferenceSizeProvider::impl_setValuesAtTitled( | |
| const Reference< XTitled > & xTitled ) | |
| { | |
| if( xTitled.is()) | |
| { | |
| Reference< XTitle > xTitle( xTitled->getTitleObject()); | |
| if( xTitle.is()) | |
| setValuesAtTitle( xTitle ); | |
| } | |
| } | |
| void ReferenceSizeProvider::setValuesAtTitle( | |
| const Reference< XTitle > & xTitle ) | |
| { | |
| try | |
| { | |
| Reference< beans::XPropertySet > xTitleProp( xTitle, uno::UNO_QUERY_THROW ); | |
| awt::Size aOldRefSize; | |
| bool bHasOldRefSize( | |
| xTitleProp->getPropertyValue( C2U("ReferencePageSize")) >>= aOldRefSize ); | |
| // set from auto-resize on to off -> adapt font sizes at XFormattedStrings | |
| if( bHasOldRefSize && ! useAutoScale()) | |
| { | |
| uno::Sequence< uno::Reference< XFormattedString > > aStrSeq( | |
| xTitle->getText()); | |
| for( sal_Int32 i=0; i<aStrSeq.getLength(); ++i ) | |
| { | |
| RelativeSizeHelper::adaptFontSizes( | |
| Reference< beans::XPropertySet >( aStrSeq[i], uno::UNO_QUERY ), | |
| aOldRefSize, getPageSize()); | |
| } | |
| } | |
| setValuesAtPropertySet( xTitleProp, /* bAdaptFontSizes = */ false ); | |
| } | |
| catch( const uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| } | |
| void ReferenceSizeProvider::setValuesAtAllDataSeries() | |
| { | |
| Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( m_xChartDoc )); | |
| // DataSeries/Points | |
| ::std::vector< Reference< XDataSeries > > aSeries( | |
| DiagramHelper::getDataSeriesFromDiagram( xDiagram )); | |
| for( ::std::vector< Reference< XDataSeries > >::const_iterator aIt( aSeries.begin()); | |
| aIt != aSeries.end(); ++aIt ) | |
| { | |
| Reference< beans::XPropertySet > xSeriesProp( *aIt, uno::UNO_QUERY ); | |
| if( xSeriesProp.is()) | |
| { | |
| // data points | |
| Sequence< sal_Int32 > aPointIndexes; | |
| try | |
| { | |
| if( xSeriesProp->getPropertyValue( C2U("AttributedDataPoints")) >>= aPointIndexes ) | |
| { | |
| for( sal_Int32 i=0; i< aPointIndexes.getLength(); ++i ) | |
| setValuesAtPropertySet( | |
| (*aIt)->getDataPointByIndex( aPointIndexes[i] ) ); | |
| } | |
| } | |
| catch( const uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| // it is important to correct the datapoint properties first as they do reference the series properties | |
| setValuesAtPropertySet( xSeriesProp ); | |
| } | |
| } | |
| } | |
| void ReferenceSizeProvider::setValuesAtPropertySet( | |
| const Reference< beans::XPropertySet > & xProp, | |
| bool bAdaptFontSizes /* = true */ ) | |
| { | |
| if( ! xProp.is()) | |
| return; | |
| static const OUString aRefSizeName( RTL_CONSTASCII_USTRINGPARAM("ReferencePageSize")); | |
| try | |
| { | |
| awt::Size aRefSize( getPageSize() ); | |
| awt::Size aOldRefSize; | |
| bool bHasOldRefSize( xProp->getPropertyValue( aRefSizeName ) >>= aOldRefSize ); | |
| if( useAutoScale()) | |
| { | |
| if( ! bHasOldRefSize ) | |
| xProp->setPropertyValue( aRefSizeName, uno::makeAny( aRefSize )); | |
| } | |
| else | |
| { | |
| if( bHasOldRefSize ) | |
| { | |
| xProp->setPropertyValue( aRefSizeName, uno::Any()); | |
| // adapt font sizes | |
| if( bAdaptFontSizes ) | |
| RelativeSizeHelper::adaptFontSizes( xProp, aOldRefSize, aRefSize ); | |
| } | |
| } | |
| } | |
| catch( const uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| } | |
| void ReferenceSizeProvider::getAutoResizeFromPropSet( | |
| const Reference< beans::XPropertySet > & xProp, | |
| ReferenceSizeProvider::AutoResizeState & rInOutState ) | |
| { | |
| static const OUString aRefSizeName( RTL_CONSTASCII_USTRINGPARAM("ReferencePageSize")); | |
| AutoResizeState eSingleState = AUTO_RESIZE_UNKNOWN; | |
| if( xProp.is()) | |
| { | |
| try | |
| { | |
| if( xProp->getPropertyValue( aRefSizeName ).hasValue()) | |
| eSingleState = AUTO_RESIZE_YES; | |
| else | |
| eSingleState = AUTO_RESIZE_NO; | |
| } | |
| catch( uno::Exception ) | |
| { | |
| // unknown property -> state stays unknown | |
| } | |
| } | |
| // current state unknown => nothing changes. Otherwise if current state | |
| // differs from state so far, we have an ambiguity | |
| if( rInOutState == AUTO_RESIZE_UNKNOWN ) | |
| { | |
| rInOutState = eSingleState; | |
| } | |
| else if( eSingleState != AUTO_RESIZE_UNKNOWN && | |
| eSingleState != rInOutState ) | |
| { | |
| rInOutState = AUTO_RESIZE_AMBIGUOUS; | |
| } | |
| } | |
| void ReferenceSizeProvider::impl_getAutoResizeFromTitled( | |
| const Reference< XTitled > & xTitled, | |
| ReferenceSizeProvider::AutoResizeState & rInOutState ) | |
| { | |
| if( xTitled.is()) | |
| { | |
| Reference< beans::XPropertySet > xProp( xTitled->getTitleObject(), uno::UNO_QUERY ); | |
| if( xProp.is()) | |
| getAutoResizeFromPropSet( xProp, rInOutState ); | |
| } | |
| } | |
| /** Retrieves the state auto-resize from all objects that support this | |
| feature. If all objects return the same state, AUTO_RESIZE_YES or | |
| AUTO_RESIZE_NO is returned. | |
| If no object supporting the feature is found, AUTO_RESIZE_UNKNOWN is | |
| returned. If there are multiple objects, some with state YES and some | |
| with state NO, AUTO_RESIZE_AMBIGUOUS is returned. | |
| */ | |
| ReferenceSizeProvider::AutoResizeState ReferenceSizeProvider::getAutoResizeState( | |
| const Reference< XChartDocument > & xChartDoc ) | |
| { | |
| AutoResizeState eResult = AUTO_RESIZE_UNKNOWN; | |
| // Main Title | |
| Reference< XTitled > xDocTitled( xChartDoc, uno::UNO_QUERY ); | |
| if( xDocTitled.is()) | |
| impl_getAutoResizeFromTitled( xDocTitled, eResult ); | |
| if( eResult == AUTO_RESIZE_AMBIGUOUS ) | |
| return eResult; | |
| // diagram is needed by the rest of the objects | |
| Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartDoc ), uno::UNO_QUERY ); | |
| if( ! xDiagram.is()) | |
| return eResult; | |
| // Sub Title | |
| Reference< XTitled > xDiaTitled( xDiagram, uno::UNO_QUERY ); | |
| if( xDiaTitled.is()) | |
| impl_getAutoResizeFromTitled( xDiaTitled, eResult ); | |
| if( eResult == AUTO_RESIZE_AMBIGUOUS ) | |
| return eResult; | |
| // Legend | |
| Reference< beans::XPropertySet > xLegendProp( xDiagram->getLegend(), uno::UNO_QUERY ); | |
| if( xLegendProp.is()) | |
| getAutoResizeFromPropSet( xLegendProp, eResult ); | |
| if( eResult == AUTO_RESIZE_AMBIGUOUS ) | |
| return eResult; | |
| // Axes (incl. Axis Titles) | |
| Sequence< Reference< XAxis > > aAxes( AxisHelper::getAllAxesOfDiagram( xDiagram ) ); | |
| for( sal_Int32 i=0; i<aAxes.getLength(); ++i ) | |
| { | |
| Reference< beans::XPropertySet > xProp( aAxes[i], uno::UNO_QUERY ); | |
| if( xProp.is()) | |
| getAutoResizeFromPropSet( xProp, eResult ); | |
| Reference< XTitled > xTitled( aAxes[i], uno::UNO_QUERY ); | |
| if( xTitled.is()) | |
| { | |
| impl_getAutoResizeFromTitled( xTitled, eResult ); | |
| if( eResult == AUTO_RESIZE_AMBIGUOUS ) | |
| return eResult; | |
| } | |
| } | |
| // DataSeries/Points | |
| ::std::vector< Reference< XDataSeries > > aSeries( | |
| DiagramHelper::getDataSeriesFromDiagram( xDiagram )); | |
| for( ::std::vector< Reference< XDataSeries > >::const_iterator aIt( aSeries.begin()); | |
| aIt != aSeries.end(); ++aIt ) | |
| { | |
| Reference< beans::XPropertySet > xSeriesProp( *aIt, uno::UNO_QUERY ); | |
| if( xSeriesProp.is()) | |
| { | |
| getAutoResizeFromPropSet( xSeriesProp, eResult ); | |
| if( eResult == AUTO_RESIZE_AMBIGUOUS ) | |
| return eResult; | |
| // data points | |
| Sequence< sal_Int32 > aPointIndexes; | |
| try | |
| { | |
| if( xSeriesProp->getPropertyValue( C2U("AttributedDataPoints")) >>= aPointIndexes ) | |
| { | |
| for( sal_Int32 i=0; i< aPointIndexes.getLength(); ++i ) | |
| { | |
| getAutoResizeFromPropSet( | |
| (*aIt)->getDataPointByIndex( aPointIndexes[i] ), eResult ); | |
| if( eResult == AUTO_RESIZE_AMBIGUOUS ) | |
| return eResult; | |
| } | |
| } | |
| } | |
| catch( const uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| } | |
| } | |
| return eResult; | |
| } | |
| void ReferenceSizeProvider::toggleAutoResizeState() | |
| { | |
| setAutoResizeState( m_bUseAutoScale ? AUTO_RESIZE_NO : AUTO_RESIZE_YES ); | |
| } | |
| /** sets the auto-resize at all objects that support this feature for text. | |
| eNewState must be either AUTO_RESIZE_YES or AUTO_RESIZE_NO | |
| */ | |
| void ReferenceSizeProvider::setAutoResizeState( ReferenceSizeProvider::AutoResizeState eNewState ) | |
| { | |
| m_bUseAutoScale = (eNewState == AUTO_RESIZE_YES); | |
| // Main Title | |
| impl_setValuesAtTitled( Reference< XTitled >( m_xChartDoc, uno::UNO_QUERY )); | |
| // diagram is needed by the rest of the objects | |
| Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( m_xChartDoc ), uno::UNO_QUERY ); | |
| if( ! xDiagram.is()) | |
| return; | |
| // Sub Title | |
| impl_setValuesAtTitled( Reference< XTitled >( xDiagram, uno::UNO_QUERY )); | |
| // Legend | |
| Reference< beans::XPropertySet > xLegendProp( xDiagram->getLegend(), uno::UNO_QUERY ); | |
| if( xLegendProp.is()) | |
| setValuesAtPropertySet( xLegendProp ); | |
| // Axes (incl. Axis Titles) | |
| Sequence< Reference< XAxis > > aAxes( AxisHelper::getAllAxesOfDiagram( xDiagram ) ); | |
| for( sal_Int32 i=0; i<aAxes.getLength(); ++i ) | |
| { | |
| Reference< beans::XPropertySet > xProp( aAxes[i], uno::UNO_QUERY ); | |
| if( xProp.is()) | |
| setValuesAtPropertySet( xProp ); | |
| impl_setValuesAtTitled( Reference< XTitled >( aAxes[i], uno::UNO_QUERY )); | |
| } | |
| // DataSeries/Points | |
| setValuesAtAllDataSeries(); | |
| // recalculate new state (in case it stays unknown or is ambiguous | |
| m_bUseAutoScale = (getAutoResizeState( m_xChartDoc ) == AUTO_RESIZE_YES); | |
| } | |
| } // namespace chart |