LCOV - code coverage report
Current view: top level - chart2/source/view/main - VLegend.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 308 443 69.5 %
Date: 2014-11-03 Functions: 19 19 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "VLegend.hxx"
      21             : #include "macros.hxx"
      22             : #include "PropertyMapper.hxx"
      23             : #include "CommonConverters.hxx"
      24             : #include "ObjectIdentifier.hxx"
      25             : #include "RelativePositionHelper.hxx"
      26             : #include "AbstractShapeFactory.hxx"
      27             : #include "RelativeSizeHelper.hxx"
      28             : #include "LegendEntryProvider.hxx"
      29             : #include "chartview/DrawModelWrapper.hxx"
      30             : #include <com/sun/star/text/XTextRange.hpp>
      31             : #include <com/sun/star/text/WritingMode2.hpp>
      32             : #include <com/sun/star/beans/XPropertySet.hpp>
      33             : #include <com/sun/star/beans/XPropertyState.hpp>
      34             : #include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
      35             : #include <com/sun/star/drawing/LineJoint.hpp>
      36             : #include <com/sun/star/chart/ChartLegendExpansion.hpp>
      37             : #include <com/sun/star/chart2/LegendPosition.hpp>
      38             : #include <com/sun/star/chart2/RelativePosition.hpp>
      39             : #include <rtl/ustrbuf.hxx>
      40             : #include <svl/languageoptions.hxx>
      41             : 
      42             : #include <vector>
      43             : #include <algorithm>
      44             : 
      45             : using namespace ::com::sun::star;
      46             : using namespace ::com::sun::star::chart2;
      47             : 
      48             : using ::com::sun::star::uno::Reference;
      49             : using ::com::sun::star::uno::Sequence;
      50             : 
      51             : namespace chart
      52             : {
      53             : 
      54             : namespace
      55             : {
      56             : 
      57             : typedef ::std::pair< ::chart::tNameSequence, ::chart::tAnySequence > tPropertyValues;
      58             : 
      59             : typedef ::std::vector< ViewLegendEntry > tViewLegendEntryContainer;
      60             : 
      61         426 : double lcl_CalcViewFontSize(
      62             :     const Reference< beans::XPropertySet > & xProp,
      63             :     const awt::Size & rReferenceSize )
      64             : {
      65         426 :     double fResult = 10.0;
      66             : 
      67         426 :     awt::Size aPropRefSize;
      68         426 :     float fFontHeight( 0.0 );
      69         426 :     if( xProp.is() && ( xProp->getPropertyValue( "CharHeight") >>= fFontHeight ))
      70             :     {
      71         426 :         fResult = fFontHeight;
      72             :         try
      73             :         {
      74         426 :             if( (xProp->getPropertyValue( "ReferencePageSize") >>= aPropRefSize) &&
      75           0 :                 (aPropRefSize.Height > 0))
      76             :             {
      77           0 :                 fResult = ::chart::RelativeSizeHelper::calculate( fFontHeight, aPropRefSize, rReferenceSize );
      78             :             }
      79             :         }
      80           0 :         catch( const uno::Exception & ex )
      81             :         {
      82             :             ASSERT_EXCEPTION( ex );
      83             :         }
      84             :     }
      85             : 
      86             :     // pt -> 1/100th mm
      87         426 :     return (fResult * (2540.0 / 72.0));
      88             : }
      89             : 
      90         426 : void lcl_getProperties(
      91             :     const Reference< beans::XPropertySet > & xLegendProp,
      92             :     tPropertyValues & rOutLineFillProperties,
      93             :     tPropertyValues & rOutTextProperties,
      94             :     const awt::Size & rReferenceSize )
      95             : {
      96             :     // Get Line- and FillProperties from model legend
      97         426 :     if( xLegendProp.is())
      98             :     {
      99             :         // set rOutLineFillProperties
     100         426 :         ::chart::tPropertyNameValueMap aLineFillValueMap;
     101         426 :         ::chart::PropertyMapper::getValueMap( aLineFillValueMap, ::chart::PropertyMapper::getPropertyNameMapForFillAndLineProperties(), xLegendProp );
     102             : 
     103         426 :         aLineFillValueMap[ "LineJoint" ] = uno::makeAny( drawing::LineJoint_ROUND );
     104             : 
     105             :         ::chart::PropertyMapper::getMultiPropertyListsFromValueMap(
     106         426 :             rOutLineFillProperties.first, rOutLineFillProperties.second, aLineFillValueMap );
     107             : 
     108             :         // set rOutTextProperties
     109         852 :         ::chart::tPropertyNameValueMap aTextValueMap;
     110         426 :         ::chart::PropertyMapper::getValueMap( aTextValueMap, ::chart::PropertyMapper::getPropertyNameMapForCharacterProperties(), xLegendProp );
     111             : 
     112         426 :         drawing::TextHorizontalAdjust eHorizAdjust( drawing::TextHorizontalAdjust_LEFT );
     113         426 :         aTextValueMap[ "TextAutoGrowHeight" ] = uno::makeAny( sal_True );
     114         426 :         aTextValueMap[ "TextAutoGrowWidth" ] = uno::makeAny( sal_True );
     115         426 :         aTextValueMap[ "TextHorizontalAdjust" ] = uno::makeAny( eHorizAdjust );
     116         426 :         aTextValueMap[ "TextMaximumFrameWidth" ] = uno::makeAny( rReferenceSize.Width ); //needs to be overwritten by actual available space in the legend
     117             : 
     118             :         // recalculate font size
     119         426 :         awt::Size aPropRefSize;
     120         426 :         float fFontHeight( 0.0 );
     121        1704 :         if( (xLegendProp->getPropertyValue( "ReferencePageSize") >>= aPropRefSize) &&
     122        1278 :             (aPropRefSize.Height > 0) &&
     123         426 :             (aTextValueMap[ "CharHeight" ] >>= fFontHeight) )
     124             :         {
     125           0 :             aTextValueMap[ "CharHeight" ] = uno::makeAny(
     126             :                 static_cast< float >(
     127           0 :                     ::chart::RelativeSizeHelper::calculate( fFontHeight, aPropRefSize, rReferenceSize )));
     128             : 
     129           0 :             if( aTextValueMap[ "CharHeightAsian" ] >>= fFontHeight )
     130             :             {
     131           0 :                 aTextValueMap[ "CharHeightAsian" ] = uno::makeAny(
     132             :                     static_cast< float >(
     133           0 :                         ::chart::RelativeSizeHelper::calculate( fFontHeight, aPropRefSize, rReferenceSize )));
     134             :             }
     135           0 :             if( aTextValueMap[ "CharHeightComplex" ] >>= fFontHeight )
     136             :             {
     137           0 :                 aTextValueMap[ "CharHeightComplex" ] = uno::makeAny(
     138             :                     static_cast< float >(
     139           0 :                         ::chart::RelativeSizeHelper::calculate( fFontHeight, aPropRefSize, rReferenceSize )));
     140             :             }
     141             :         }
     142             : 
     143             :         ::chart::PropertyMapper::getMultiPropertyListsFromValueMap(
     144         852 :             rOutTextProperties.first, rOutTextProperties.second, aTextValueMap );
     145             :     }
     146         426 : }
     147             : 
     148         426 : awt::Size lcl_createTextShapes(
     149             :     const tViewLegendEntryContainer & rEntries,
     150             :     const Reference< lang::XMultiServiceFactory > & xShapeFactory,
     151             :     const Reference< drawing::XShapes > & xTarget,
     152             :     ::std::vector< Reference< drawing::XShape > > & rOutTextShapes,
     153             :     const tPropertyValues & rTextProperties )
     154             : {
     155         426 :     awt::Size aResult;
     156         426 :     AbstractShapeFactory* pShapeFactory = AbstractShapeFactory::getOrCreateShapeFactory(xShapeFactory);
     157             : 
     158        4881 :     for( tViewLegendEntryContainer::const_iterator aIt( rEntries.begin());
     159        3254 :          aIt != rEntries.end(); ++aIt )
     160             :     {
     161             :         try
     162             :         {
     163        1201 :             OUString aLabelString;
     164        2402 :             Sequence< Reference< XFormattedString2 > > aLabelSeq = (*aIt).aLabel;
     165        2402 :             for( sal_Int32 i = 0; i < aLabelSeq.getLength(); ++i )
     166             :             {
     167             :                 // todo: support more than one text range
     168        1201 :                 if( i == 1 )
     169           0 :                     break;
     170             : 
     171        1201 :                 aLabelString = aLabelString + aLabelSeq[i]->getString();
     172             :                 // workaround for Issue #i67540#
     173        1201 :                 if( aLabelString.isEmpty())
     174           2 :                     aLabelString = " ";
     175             :             }
     176             : 
     177             :             Reference< drawing::XShape > xEntry =
     178             :                 pShapeFactory->createText( xTarget, aLabelString,
     179        2402 :                         rTextProperties.first, rTextProperties.second, uno::Any() );
     180             : 
     181             :             // adapt max-extent
     182        1201 :             awt::Size aCurrSize( xEntry->getSize());
     183        1201 :             aResult.Width  = ::std::max( aResult.Width,  aCurrSize.Width  );
     184        1201 :             aResult.Height = ::std::max( aResult.Height, aCurrSize.Height );
     185             : 
     186        2402 :             rOutTextShapes.push_back( xEntry );
     187             :         }
     188           0 :         catch( const uno::Exception & ex )
     189             :         {
     190             :             ASSERT_EXCEPTION( ex );
     191             :         }
     192             :     }
     193             : 
     194         426 :     return aResult;
     195             : }
     196             : 
     197         426 : void lcl_collectColumnWidths( std::vector< sal_Int32 >& rColumnWidths, const sal_Int32 nNumberOfRows, const sal_Int32 nNumberOfColumns
     198             :                              , const ::std::vector< Reference< drawing::XShape > > aTextShapes, sal_Int32 nSymbolPlusDistanceWidth )
     199             : {
     200         426 :     rColumnWidths.clear();
     201         426 :     sal_Int32 nRow = 0;
     202         426 :     sal_Int32 nColumn = 0;
     203         426 :     sal_Int32 nNumberOfEntries = aTextShapes.size();
     204        1586 :     for( ; nRow < nNumberOfRows; ++nRow )
     205             :     {
     206        2368 :         for( nColumn = 0; nColumn < nNumberOfColumns; ++nColumn )
     207             :         {
     208        1208 :             sal_Int32 nEntry = (nColumn + nRow * nNumberOfColumns);
     209        1208 :             if( nEntry < nNumberOfEntries )
     210             :             {
     211        1201 :                 awt::Size aTextSize( aTextShapes[ nEntry ]->getSize() );
     212        1201 :                 sal_Int32 nWidth = nSymbolPlusDistanceWidth + aTextSize.Width;
     213        1201 :                 if( nRow==0 )
     214         467 :                     rColumnWidths.push_back( nWidth );
     215             :                 else
     216         734 :                     rColumnWidths[nColumn] = ::std::max( nWidth, rColumnWidths[nColumn] );
     217             :             }
     218             :         }
     219             :     }
     220         426 : }
     221             : 
     222         426 : void lcl_collectRowHeighs( std::vector< sal_Int32 >& rRowHeights, const sal_Int32 nNumberOfRows, const sal_Int32 nNumberOfColumns
     223             :                           , const ::std::vector< Reference< drawing::XShape > > aTextShapes )
     224             : {
     225             :     // calculate maximum height for each row
     226             :     // and collect column widths
     227         426 :     rRowHeights.clear();
     228         426 :     sal_Int32 nRow = 0;
     229         426 :     sal_Int32 nColumn = 0;
     230         426 :     sal_Int32 nNumberOfEntries = aTextShapes.size();
     231        1586 :     for( ; nRow < nNumberOfRows; ++nRow )
     232             :     {
     233        1160 :         sal_Int32 nCurrentRowHeight = 0;
     234        2368 :         for( nColumn = 0; nColumn < nNumberOfColumns; ++nColumn )
     235             :         {
     236        1208 :             sal_Int32 nEntry = (nColumn + nRow * nNumberOfColumns);
     237        1208 :             if( nEntry < nNumberOfEntries )
     238             :             {
     239        1201 :                 awt::Size aTextSize( aTextShapes[ nEntry ]->getSize() );
     240        1201 :                 nCurrentRowHeight = ::std::max( nCurrentRowHeight, aTextSize.Height );
     241             :             }
     242             :         }
     243        1160 :         rRowHeights.push_back( nCurrentRowHeight );
     244             :     }
     245         426 : }
     246             : 
     247         426 : sal_Int32 lcl_getTextLineHeight( const std::vector< sal_Int32 >& aRowHeights, const sal_Int32 nNumberOfRows, double fViewFontSize )
     248             : {
     249         426 :     const sal_Int32 nFontHeight = static_cast< sal_Int32 >( fViewFontSize );
     250         426 :     sal_Int32 nTextLineHeight = nFontHeight;
     251         426 :     for( sal_Int32 nR=0; nR<nNumberOfRows; nR++ )
     252             :     {
     253         426 :         sal_Int32 nFullTextHeight = aRowHeights[ nR ];
     254         426 :         if( ( nFullTextHeight / nFontHeight ) <= 1 )
     255             :         {
     256         426 :             nTextLineHeight = nFullTextHeight;//found an entry with one line-> have real text height
     257         426 :             break;
     258             :         }
     259             :     }
     260         426 :     return nTextLineHeight;
     261             : }
     262             : 
     263             : //returns resulting legend size
     264         426 : awt::Size lcl_placeLegendEntries(
     265             :     tViewLegendEntryContainer & rEntries,
     266             :     ::com::sun::star::chart::ChartLegendExpansion eExpansion,
     267             :     bool bSymbolsLeftSide,
     268             :     double fViewFontSize,
     269             :     const awt::Size& rMaxSymbolExtent,
     270             :     tPropertyValues & rTextProperties,
     271             :     const Reference< drawing::XShapes > & xTarget,
     272             :     const Reference< lang::XMultiServiceFactory > & xShapeFactory,
     273             :     const awt::Size & rAvailableSpace )
     274             : {
     275         426 :     bool bIsCustomSize = (eExpansion == ::com::sun::star::chart::ChartLegendExpansion_CUSTOM);
     276         426 :     awt::Size aResultingLegendSize(0,0);
     277         426 :     if( bIsCustomSize )
     278           0 :         aResultingLegendSize = rAvailableSpace;
     279             : 
     280             :     // #i109336# Improve auto positioning in chart
     281         426 :     sal_Int32 nXPadding = static_cast< sal_Int32 >( std::max( 100.0, fViewFontSize * 0.33 ) );
     282             :     //sal_Int32 nXPadding = static_cast< sal_Int32 >( std::max( 200.0, fViewFontSize * 0.33 ) );
     283         426 :     sal_Int32 nXOffset  = static_cast< sal_Int32 >( std::max( 100.0, fViewFontSize * 0.66 ) );
     284         426 :     sal_Int32 nYPadding = static_cast< sal_Int32 >( std::max( 100.0, fViewFontSize * 0.2 ) );
     285         426 :     sal_Int32 nYOffset  = static_cast< sal_Int32 >( std::max( 100.0, fViewFontSize * 0.2 ) );
     286             :     //sal_Int32 nYOffset  = static_cast< sal_Int32 >( std::max( 230.0, fViewFontSize * 0.45 ) );
     287             : 
     288         426 :     const sal_Int32 nSymbolToTextDistance = static_cast< sal_Int32 >( std::max( 100.0, fViewFontSize * 0.22 ) );//minimum 1mm
     289         426 :     const sal_Int32 nSymbolPlusDistanceWidth = rMaxSymbolExtent.Width + nSymbolToTextDistance;
     290         426 :     sal_Int32 nMaxTextWidth = rAvailableSpace.Width - (2 * nXPadding) - nSymbolPlusDistanceWidth;
     291         426 :     OUString aPropNameTextMaximumFrameWidth( "TextMaximumFrameWidth" );
     292         426 :     uno::Any* pFrameWidthAny = PropertyMapper::getValuePointer( rTextProperties.second, rTextProperties.first, aPropNameTextMaximumFrameWidth);
     293         426 :     if(pFrameWidthAny)
     294             :     {
     295         426 :         if( eExpansion == ::com::sun::star::chart::ChartLegendExpansion_HIGH )
     296             :         {
     297             :             // limit the width of texts to 30% of the total available width
     298             :             // #i109336# Improve auto positioning in chart
     299         404 :             nMaxTextWidth = rAvailableSpace.Width * 3 / 10;
     300             :         }
     301         426 :         *pFrameWidthAny = uno::makeAny(nMaxTextWidth);
     302             :     }
     303             : 
     304         852 :     ::std::vector< Reference< drawing::XShape > > aTextShapes;
     305         426 :     awt::Size aMaxEntryExtent = lcl_createTextShapes( rEntries, xShapeFactory, xTarget, aTextShapes, rTextProperties );
     306             :     OSL_ASSERT( aTextShapes.size() == rEntries.size());
     307             : 
     308         426 :     sal_Int32 nMaxEntryWidth = nXOffset + nSymbolPlusDistanceWidth + aMaxEntryExtent.Width;
     309         426 :     sal_Int32 nMaxEntryHeight = nYOffset + aMaxEntryExtent.Height;
     310         426 :     sal_Int32 nNumberOfEntries = rEntries.size();
     311             : 
     312         426 :     sal_Int32 nNumberOfColumns = 0, nNumberOfRows = 0;
     313         852 :     std::vector< sal_Int32 > aColumnWidths;
     314         852 :     std::vector< sal_Int32 > aRowHeights;
     315             : 
     316         426 :     sal_Int32 nTextLineHeight = static_cast< sal_Int32 >( fViewFontSize );
     317             : 
     318             :     // determine layout depending on LegendExpansion
     319         426 :     if( eExpansion == ::com::sun::star::chart::ChartLegendExpansion_CUSTOM )
     320             :     {
     321           0 :         sal_Int32 nCurrentRow=0;
     322           0 :         sal_Int32 nCurrentColumn=-1;
     323           0 :         sal_Int32 nMaxColumnCount=-1;
     324           0 :         for( sal_Int32 nN=0; nN<static_cast<sal_Int32>(aTextShapes.size()); nN++ )
     325             :         {
     326           0 :             Reference< drawing::XShape > xShape( aTextShapes[nN] );
     327           0 :             if( !xShape.is() )
     328           0 :                 continue;
     329           0 :             awt::Size aSize( xShape->getSize() );
     330           0 :             sal_Int32 nNewWidth = aSize.Width + nSymbolPlusDistanceWidth;
     331           0 :             sal_Int32 nCurrentColumnCount = aColumnWidths.size();
     332             : 
     333             :             //are we allowed to add a new column?
     334           0 :             if( nMaxColumnCount==-1 || (nCurrentColumn+1) < nMaxColumnCount )
     335             :             {
     336             :                 //try add a new column
     337           0 :                 nCurrentColumn++;
     338           0 :                 if( nCurrentColumn < nCurrentColumnCount )
     339             :                 {
     340             :                     //check whether the current column width is sufficient for the new entry
     341           0 :                     if( aColumnWidths[nCurrentColumn]>=nNewWidth )
     342             :                     {
     343             :                         //all good proceed with next entry
     344           0 :                         continue;
     345             :                     }
     346             :                 }
     347           0 :                 if( nCurrentColumn < nCurrentColumnCount )
     348           0 :                     aColumnWidths[nCurrentColumn] = std::max( nNewWidth, aColumnWidths[nCurrentColumn] );
     349             :                 else
     350           0 :                     aColumnWidths.push_back(nNewWidth);
     351             : 
     352             :                 //do the columns still fit into the given size?
     353           0 :                 nCurrentColumnCount = aColumnWidths.size();//update count
     354           0 :                 sal_Int32 nSumWidth = 0;
     355           0 :                 for( sal_Int32 nC=0; nC<nCurrentColumnCount; nC++ )
     356           0 :                     nSumWidth += aColumnWidths[nC];
     357             : 
     358           0 :                 if( nSumWidth <= rAvailableSpace.Width || nCurrentColumnCount==1 )
     359             :                 {
     360             :                     //all good proceed with next entry
     361           0 :                     continue;
     362             :                 }
     363             :                 else
     364             :                 {
     365             :                     //not enough space for the current amount of columns
     366             :                     //try again with less columns
     367           0 :                     nMaxColumnCount = nCurrentColumnCount-1;
     368           0 :                     nN=-1;
     369           0 :                     nCurrentRow=0;
     370           0 :                     nCurrentColumn=-1;
     371           0 :                     aColumnWidths.clear();
     372           0 :                 }
     373             :             }
     374             :             else
     375             :             {
     376             :                 //add a new row and try the same entry again
     377           0 :                 nCurrentRow++;
     378           0 :                 nCurrentColumn=-1;
     379           0 :                 nN--;
     380             :             }
     381           0 :         }
     382           0 :         nNumberOfColumns = aColumnWidths.size();
     383           0 :         nNumberOfRows = nCurrentRow+1;
     384             : 
     385             :         //check if there is not enough space so that some entries must be removed
     386           0 :         lcl_collectRowHeighs( aRowHeights, nNumberOfRows, nNumberOfColumns, aTextShapes );
     387           0 :         nTextLineHeight = lcl_getTextLineHeight( aRowHeights, nNumberOfRows, fViewFontSize );
     388           0 :         sal_Int32 nSumHeight = 0;
     389           0 :         for( sal_Int32 nR=0; nR<nNumberOfRows; nR++ )
     390           0 :             nSumHeight += aRowHeights[nR];
     391           0 :         sal_Int32 nRemainingSpace = rAvailableSpace.Height - nSumHeight;
     392             : 
     393           0 :         if( nRemainingSpace<0 )
     394             :         {
     395             :             //remove entries that are too big
     396           0 :             for( sal_Int32 nR=nNumberOfRows; nR--; )
     397             :             {
     398           0 :                 for( sal_Int32 nC=nNumberOfColumns; nC--; )
     399             :                 {
     400           0 :                     sal_Int32 nEntry = (nC + nR * nNumberOfColumns);
     401           0 :                     if( nEntry < static_cast<sal_Int32>(aTextShapes.size()) )
     402             :                     {
     403           0 :                         DrawModelWrapper::removeShape( aTextShapes[nEntry] );
     404           0 :                         aTextShapes.pop_back();
     405             :                     }
     406           0 :                     if( nEntry < nNumberOfEntries )
     407             :                     {
     408           0 :                         DrawModelWrapper::removeShape( rEntries[ nEntry ].aSymbol );
     409           0 :                         rEntries.pop_back();
     410           0 :                         nNumberOfEntries--;
     411             :                     }
     412             :                 }
     413           0 :                 nSumHeight -= aRowHeights[nR];
     414           0 :                 aRowHeights.pop_back();
     415           0 :                 nRemainingSpace = rAvailableSpace.Height - nSumHeight;
     416           0 :                 if( nRemainingSpace>=0 )
     417           0 :                     break;
     418             :             }
     419           0 :             nNumberOfRows = static_cast<sal_Int32>(aRowHeights.size());
     420             :         }
     421           0 :         if( nRemainingSpace > 0 )
     422             :         {
     423           0 :             sal_Int32 nNormalSpacingHeight = 2*nYPadding+(nNumberOfRows-1)*nYOffset;
     424           0 :             if( nRemainingSpace < nNormalSpacingHeight )
     425             :             {
     426             :                 //reduce spacing between the entries
     427           0 :                 nYPadding = nYOffset = nRemainingSpace/(nNumberOfRows+1);
     428             :             }
     429             :             else
     430             :             {
     431             :                 //we have some space left that should be spread equally between all rows
     432           0 :                 sal_Int32 nRemainingSingleSpace = (nRemainingSpace-nNormalSpacingHeight)/(nNumberOfRows+1);
     433           0 :                 nYPadding += nRemainingSingleSpace;
     434           0 :                 nYOffset += nRemainingSingleSpace;
     435             :             }
     436             :         }
     437             : 
     438             :         //check spacing between columns
     439           0 :         sal_Int32 nSumWidth = 0;
     440           0 :         for( sal_Int32 nC=0; nC<nNumberOfColumns; nC++ )
     441           0 :             nSumWidth += aColumnWidths[nC];
     442           0 :         nRemainingSpace = rAvailableSpace.Width - nSumWidth;
     443           0 :         if( nRemainingSpace>=0 )
     444             :         {
     445           0 :             sal_Int32 nNormalSpacingWidth = 2*nXPadding+(nNumberOfColumns-1)*nXOffset;
     446           0 :             if( nRemainingSpace < nNormalSpacingWidth )
     447             :             {
     448             :                 //reduce spacing between the entries
     449           0 :                 nXPadding = nXOffset = nRemainingSpace/(nNumberOfColumns+1);
     450             :             }
     451             :             else
     452             :             {
     453             :                 //we have some space left that should be spread equally between all columns
     454           0 :                 sal_Int32 nRemainingSingleSpace = (nRemainingSpace-nNormalSpacingWidth)/(nNumberOfColumns+1);
     455           0 :                 nXPadding += nRemainingSingleSpace;
     456           0 :                 nXOffset += nRemainingSingleSpace;
     457             :             }
     458             :         }
     459             :     }
     460         426 :     else if( eExpansion == ::com::sun::star::chart::ChartLegendExpansion_HIGH )
     461             :     {
     462             :         sal_Int32 nMaxNumberOfRows = nMaxEntryHeight
     463         404 :             ? (rAvailableSpace.Height - 2*nYPadding ) / nMaxEntryHeight
     464         808 :             : 0;
     465             : 
     466             :         nNumberOfColumns = nMaxNumberOfRows
     467             :             ? static_cast< sal_Int32 >(
     468             :                 ceil( static_cast< double >( nNumberOfEntries ) /
     469         404 :                       static_cast< double >( nMaxNumberOfRows ) ))
     470         808 :             : 0;
     471             :         nNumberOfRows =  nNumberOfColumns
     472             :             ? static_cast< sal_Int32 >(
     473             :                 ceil( static_cast< double >( nNumberOfEntries ) /
     474         404 :                       static_cast< double >( nNumberOfColumns ) ))
     475         808 :             : 0;
     476             :     }
     477          22 :     else if( eExpansion == ::com::sun::star::chart::ChartLegendExpansion_WIDE )
     478             :     {
     479             :         sal_Int32 nMaxNumberOfColumns = nMaxEntryWidth
     480          22 :             ? (rAvailableSpace.Width - 2*nXPadding ) / nMaxEntryWidth
     481          44 :             : 0;
     482             : 
     483             :         nNumberOfRows = nMaxNumberOfColumns
     484             :             ? static_cast< sal_Int32 >(
     485             :                 ceil( static_cast< double >( nNumberOfEntries ) /
     486          22 :                       static_cast< double >( nMaxNumberOfColumns ) ))
     487          44 :             : 0;
     488             :         nNumberOfColumns = nNumberOfRows
     489             :             ? static_cast< sal_Int32 >(
     490             :                 ceil( static_cast< double >( nNumberOfEntries ) /
     491          22 :                       static_cast< double >( nNumberOfRows ) ))
     492          44 :             : 0;
     493             :     }
     494             :     else // ::com::sun::star::chart::ChartLegendExpansion_BALANCED
     495             :     {
     496             :         double fAspect = nMaxEntryHeight
     497           0 :             ? static_cast< double >( nMaxEntryWidth ) / static_cast< double >( nMaxEntryHeight )
     498           0 :             : 0.0;
     499             : 
     500             :         nNumberOfRows = static_cast< sal_Int32 >(
     501           0 :             ceil( sqrt( static_cast< double >( nNumberOfEntries ) * fAspect )));
     502             :         nNumberOfColumns = nNumberOfRows
     503             :             ? static_cast< sal_Int32 >(
     504             :                 ceil( static_cast< double >( nNumberOfEntries ) /
     505           0 :                       static_cast< double >( nNumberOfRows ) ))
     506           0 :             : 0;
     507             :     }
     508             : 
     509         426 :     if(nNumberOfRows<=0)
     510           0 :         return aResultingLegendSize;
     511             : 
     512         426 :     if( eExpansion != ::com::sun::star::chart::ChartLegendExpansion_CUSTOM )
     513             :     {
     514         426 :         lcl_collectColumnWidths( aColumnWidths, nNumberOfRows, nNumberOfColumns, aTextShapes, nSymbolPlusDistanceWidth );
     515         426 :         lcl_collectRowHeighs( aRowHeights, nNumberOfRows, nNumberOfColumns, aTextShapes );
     516         426 :         nTextLineHeight = lcl_getTextLineHeight( aRowHeights, nNumberOfRows, fViewFontSize );
     517             :     }
     518             : 
     519         426 :     sal_Int32 nCurrentXPos = nXPadding;
     520         426 :     sal_Int32 nCurrentYPos = nYPadding;
     521         426 :     if( !bSymbolsLeftSide )
     522           0 :         nCurrentXPos = -nXPadding;
     523             : 
     524             :     // place entries into column and rows
     525         426 :     sal_Int32 nMaxYPos = 0;
     526         426 :     sal_Int32 nRow = 0;
     527         426 :     sal_Int32 nColumn = 0;
     528         893 :     for( nColumn = 0; nColumn < nNumberOfColumns; ++nColumn )
     529             :     {
     530         467 :         nCurrentYPos = nYPadding;
     531        1668 :         for( nRow = 0; nRow < nNumberOfRows; ++nRow )
     532             :         {
     533        1208 :             sal_Int32 nEntry = (nColumn + nRow * nNumberOfColumns);
     534        1208 :             if( nEntry >= nNumberOfEntries )
     535           7 :                 break;
     536             : 
     537             :             // text shape
     538        1201 :             Reference< drawing::XShape > xTextShape( aTextShapes[nEntry] );
     539        1201 :             if( xTextShape.is() )
     540             :             {
     541        1201 :                 awt::Size aTextSize( xTextShape->getSize() );
     542        1201 :                 sal_Int32 nTextXPos = nCurrentXPos + nSymbolPlusDistanceWidth;
     543        1201 :                 if( !bSymbolsLeftSide )
     544           0 :                     nTextXPos = nCurrentXPos - nSymbolPlusDistanceWidth - aTextSize.Width;
     545        1201 :                 xTextShape->setPosition( awt::Point( nTextXPos, nCurrentYPos ));
     546             :             }
     547             : 
     548             :             // symbol
     549        2402 :             Reference< drawing::XShape > xSymbol( rEntries[ nEntry ].aSymbol );
     550        1201 :             if( xSymbol.is() )
     551             :             {
     552        1201 :                 awt::Size aSymbolSize( rMaxSymbolExtent );
     553        1201 :                 sal_Int32 nSymbolXPos = nCurrentXPos;
     554        1201 :                 if( !bSymbolsLeftSide )
     555           0 :                     nSymbolXPos = nCurrentXPos - rMaxSymbolExtent.Width;
     556        1201 :                 sal_Int32 nSymbolYPos = nCurrentYPos + ( ( nTextLineHeight - aSymbolSize.Height ) / 2 );
     557        1201 :                 xSymbol->setPosition( awt::Point( nSymbolXPos, nSymbolYPos ) );
     558             :             }
     559             : 
     560        1201 :             nCurrentYPos += aRowHeights[ nRow ];
     561        1201 :             if( nRow+1 < nNumberOfRows )
     562         741 :                 nCurrentYPos += nYOffset;
     563        1201 :             nMaxYPos = ::std::max( nMaxYPos, nCurrentYPos );
     564        1201 :         }
     565         467 :         if( bSymbolsLeftSide )
     566             :         {
     567         467 :             nCurrentXPos += aColumnWidths[nColumn];
     568         467 :             if( nColumn+1 < nNumberOfColumns )
     569          41 :                 nCurrentXPos += nXOffset;
     570             :         }
     571             :         else
     572             :         {
     573           0 :             nCurrentXPos -= aColumnWidths[nColumn];
     574           0 :             if( nColumn+1 < nNumberOfColumns )
     575           0 :                 nCurrentXPos -= nXOffset;
     576             :         }
     577             :     }
     578             : 
     579         426 :     if( !bIsCustomSize )
     580             :     {
     581         426 :         if( bSymbolsLeftSide )
     582         426 :             aResultingLegendSize.Width  = nCurrentXPos + nXPadding;
     583             :         else
     584             :         {
     585           0 :             sal_Int32 nLegendWidth = -(nCurrentXPos-nXPadding);
     586           0 :             aResultingLegendSize.Width  = nLegendWidth;
     587             :         }
     588         426 :         aResultingLegendSize.Height = nMaxYPos + nYPadding;
     589             :     }
     590             : 
     591         426 :     if( !bSymbolsLeftSide )
     592             :     {
     593           0 :         sal_Int32 nLegendWidth = aResultingLegendSize.Width;
     594           0 :         awt::Point aPos(0,0);
     595           0 :         for( sal_Int32 nEntry=0; nEntry<nNumberOfEntries; nEntry++ )
     596             :         {
     597           0 :             Reference< drawing::XShape > xSymbol( rEntries[ nEntry ].aSymbol );
     598           0 :             aPos = xSymbol->getPosition();
     599           0 :             aPos.X += nLegendWidth;
     600           0 :             xSymbol->setPosition( aPos );
     601           0 :             Reference< drawing::XShape > xText( aTextShapes[ nEntry ] );
     602           0 :             aPos = xText->getPosition();
     603           0 :             aPos.X += nLegendWidth;
     604           0 :             xText->setPosition( aPos );
     605           0 :         }
     606             :     }
     607             : 
     608         852 :     return aResultingLegendSize;
     609             : }
     610             : 
     611             : // #i109336# Improve auto positioning in chart
     612         913 : sal_Int32 lcl_getLegendLeftRightMargin()
     613             : {
     614         913 :     return 210;  // 1/100 mm
     615             : }
     616             : 
     617             : // #i109336# Improve auto positioning in chart
     618         531 : sal_Int32 lcl_getLegendTopBottomMargin()
     619             : {
     620         531 :     return 185;  // 1/100 mm
     621             : }
     622             : 
     623         426 : chart2::RelativePosition lcl_getDefaultPosition( LegendPosition ePos, const awt::Rectangle& rOutAvailableSpace, const awt::Size & rPageSize )
     624             : {
     625         426 :     chart2::RelativePosition aResult;
     626             : 
     627         426 :     switch( ePos )
     628             :     {
     629             :         case LegendPosition_LINE_START:
     630             :             {
     631             :                 // #i109336# Improve auto positioning in chart
     632           2 :                 const double fDefaultDistance = ( static_cast< double >( lcl_getLegendLeftRightMargin() ) /
     633           2 :                     static_cast< double >( rPageSize.Width ) );
     634             :                 aResult = chart2::RelativePosition(
     635           2 :                     fDefaultDistance, 0.5, drawing::Alignment_LEFT );
     636             :             }
     637           2 :             break;
     638             :         case LegendPosition_LINE_END:
     639             :             {
     640             :                 // #i109336# Improve auto positioning in chart
     641         402 :                 const double fDefaultDistance = ( static_cast< double >( lcl_getLegendLeftRightMargin() ) /
     642         402 :                     static_cast< double >( rPageSize.Width ) );
     643             :                 aResult = chart2::RelativePosition(
     644         402 :                     1.0 - fDefaultDistance, 0.5, drawing::Alignment_RIGHT );
     645             :             }
     646         402 :             break;
     647             :         case LegendPosition_PAGE_START:
     648             :             {
     649             :                 // #i109336# Improve auto positioning in chart
     650           2 :                 const double fDefaultDistance = ( static_cast< double >( lcl_getLegendTopBottomMargin() ) /
     651           2 :                     static_cast< double >( rPageSize.Height ) );
     652           2 :                 double fDistance = (static_cast<double>(rOutAvailableSpace.Y)/static_cast<double>(rPageSize.Height)) + fDefaultDistance;
     653             :                 aResult = chart2::RelativePosition(
     654           2 :                     0.5, fDistance, drawing::Alignment_TOP );
     655             :             }
     656           2 :             break;
     657             :         case LegendPosition_PAGE_END:
     658             :             {
     659             :                 // #i109336# Improve auto positioning in chart
     660          20 :                 const double fDefaultDistance = ( static_cast< double >( lcl_getLegendTopBottomMargin() ) /
     661          20 :                     static_cast< double >( rPageSize.Height ) );
     662             :                 aResult = chart2::RelativePosition(
     663          20 :                     0.5, 1.0 - fDefaultDistance, drawing::Alignment_BOTTOM );
     664             :             }
     665          20 :             break;
     666             : 
     667             :         case LegendPosition_CUSTOM:
     668             :             // to avoid warning
     669             :         case LegendPosition_MAKE_FIXED_SIZE:
     670             :             // nothing to be set
     671           0 :             break;
     672             :     }
     673             : 
     674         426 :     return aResult;
     675             : }
     676             : 
     677             : /**  @return
     678             :          a point relative to the upper left corner that can be used for
     679             :          XShape::setPosition()
     680             : */
     681         509 : awt::Point lcl_calculatePositionAndRemainingSpace(
     682             :     awt::Rectangle & rRemainingSpace,
     683             :     const awt::Size & rPageSize,
     684             :     chart2::RelativePosition aRelPos,
     685             :     LegendPosition ePos,
     686             :     const awt::Size& aLegendSize )
     687             : {
     688             :     // calculate position
     689             :     awt::Point aResult(
     690         509 :         static_cast< sal_Int32 >( aRelPos.Primary * rPageSize.Width ),
     691        1018 :         static_cast< sal_Int32 >( aRelPos.Secondary * rPageSize.Height ));
     692             : 
     693             :     aResult = RelativePositionHelper::getUpperLeftCornerOfAnchoredObject(
     694         509 :         aResult, aLegendSize, aRelPos.Anchor );
     695             : 
     696             :     // adapt rRemainingSpace if LegendPosition is not CUSTOM
     697             :     // #i109336# Improve auto positioning in chart
     698         509 :     sal_Int32 nXDistance = lcl_getLegendLeftRightMargin();
     699         509 :     sal_Int32 nYDistance = lcl_getLegendTopBottomMargin();
     700         509 :     switch( ePos )
     701             :     {
     702             :         case LegendPosition_LINE_START:
     703             :             {
     704           2 :                 sal_Int32 nExtent = aLegendSize.Width;
     705           2 :                 rRemainingSpace.Width -= ( nExtent + nXDistance );
     706           2 :                 rRemainingSpace.X += ( nExtent + nXDistance );
     707             :             }
     708           2 :         break;
     709             :         case LegendPosition_LINE_END:
     710             :             {
     711         485 :                 rRemainingSpace.Width -= ( aLegendSize.Width + nXDistance );
     712             :             }
     713         485 :             break;
     714             :         case LegendPosition_PAGE_START:
     715             :             {
     716           2 :                 sal_Int32 nExtent = aLegendSize.Height;
     717           2 :                 rRemainingSpace.Height -= ( nExtent + nYDistance );
     718           2 :                 rRemainingSpace.Y += ( nExtent + nYDistance );
     719             :             }
     720           2 :         break;
     721             :         case LegendPosition_PAGE_END:
     722             :             {
     723          20 :                 rRemainingSpace.Height -= ( aLegendSize.Height + nYDistance );
     724             :             }
     725          20 :             break;
     726             : 
     727             :         default:
     728             :             // nothing
     729           0 :             break;
     730             :     }
     731             : 
     732             :     // adjust the legend position. Esp. for old files that had slightly smaller legends
     733         509 :     const sal_Int32 nEdgeDistance( 30 );
     734         509 :     if( aResult.X + aLegendSize.Width > rPageSize.Width )
     735             :     {
     736           0 :         sal_Int32 nNewX( (rPageSize.Width - aLegendSize.Width) - nEdgeDistance );
     737           0 :         if( nNewX > rPageSize.Width / 4 )
     738           0 :             aResult.X = nNewX;
     739             :     }
     740         509 :     if( aResult.Y + aLegendSize.Height > rPageSize.Height )
     741             :     {
     742           0 :         sal_Int32 nNewY( (rPageSize.Height - aLegendSize.Height) - nEdgeDistance );
     743           0 :         if( nNewY > rPageSize.Height / 4 )
     744           0 :             aResult.Y = nNewY;
     745             :     }
     746             : 
     747         509 :     return aResult;
     748             : }
     749             : 
     750         426 : bool lcl_shouldSymbolsBePlacedOnTheLeftSide( const Reference< beans::XPropertySet >& xLegendProp, sal_Int16 nDefaultWritingMode )
     751             : {
     752         426 :     bool bSymbolsLeftSide = true;
     753             :     try
     754             :     {
     755         426 :         if( SvtLanguageOptions().IsCTLFontEnabled() )
     756             :         {
     757         426 :             if(xLegendProp.is())
     758             :             {
     759         426 :                 sal_Int16 nWritingMode=-1;
     760         426 :                 if( (xLegendProp->getPropertyValue( "WritingMode" ) >>= nWritingMode) )
     761             :                 {
     762         426 :                     if( nWritingMode == text::WritingMode2::PAGE )
     763         426 :                         nWritingMode = nDefaultWritingMode;
     764         426 :                     if( nWritingMode == text::WritingMode2::RL_TB )
     765           0 :                         bSymbolsLeftSide=false;
     766             :                 }
     767             :             }
     768             :         }
     769             :     }
     770           0 :     catch( const uno::Exception & ex )
     771             :     {
     772             :         ASSERT_EXCEPTION( ex );
     773             :     }
     774         426 :     return bSymbolsLeftSide;
     775             : }
     776             : 
     777             : } // anonymous namespace
     778             : 
     779         426 : VLegend::VLegend(
     780             :     const Reference< XLegend > & xLegend,
     781             :     const Reference< uno::XComponentContext > & xContext,
     782             :     const std::vector< LegendEntryProvider* >& rLegendEntryProviderList,
     783             :     const Reference< drawing::XShapes >& xTargetPage,
     784             :     const Reference< lang::XMultiServiceFactory >& xFactory,
     785             :     ChartModel& rModel )
     786             :         : m_xTarget(xTargetPage)
     787             :         , m_xShapeFactory(xFactory)
     788             :         , m_xLegend(xLegend)
     789             :         , mrModel(rModel)
     790             :         , m_xContext(xContext)
     791             :         , m_aLegendEntryProviderList(rLegendEntryProviderList)
     792         426 :         , m_nDefaultWritingMode(text::WritingMode2::LR_TB)
     793             : {
     794         426 : }
     795             : 
     796         426 : void VLegend::setDefaultWritingMode( sal_Int16 nDefaultWritingMode )
     797             : {
     798         426 :     m_nDefaultWritingMode = nDefaultWritingMode;
     799         426 : }
     800             : 
     801         680 : bool VLegend::isVisible( const Reference< XLegend > & xLegend )
     802             : {
     803         680 :     if( ! xLegend.is())
     804         240 :         return false;
     805             : 
     806         440 :     bool bShow = false;
     807             :     try
     808             :     {
     809         440 :         Reference< beans::XPropertySet > xLegendProp( xLegend, uno::UNO_QUERY_THROW );
     810         440 :         xLegendProp->getPropertyValue( "Show") >>= bShow;
     811             :     }
     812           0 :     catch( const uno::Exception & ex )
     813             :     {
     814             :         ASSERT_EXCEPTION( ex );
     815             :     }
     816             : 
     817         440 :     return bShow;
     818             : }
     819             : 
     820         426 : void VLegend::createShapes(
     821             :     const awt::Size & rAvailableSpace,
     822             :     const awt::Size & rPageSize )
     823             : {
     824        1278 :     if(! (m_xLegend.is() &&
     825         426 :           m_xShapeFactory.is() &&
     826         852 :           m_xTarget.is()))
     827         426 :         return;
     828             : 
     829             :     try
     830             :     {
     831             :         //create shape and add to page
     832         426 :         AbstractShapeFactory* pShapeFactory = AbstractShapeFactory::getOrCreateShapeFactory(m_xShapeFactory);
     833         426 :         OUString aLegendParticle( ObjectIdentifier::createParticleForLegend( m_xLegend, mrModel ) );
     834             :         m_xShape.set( pShapeFactory->createGroup2D( m_xTarget,
     835         426 :                     ObjectIdentifier::createClassifiedIdentifierForParticle( aLegendParticle )),
     836         426 :                 uno::UNO_QUERY);
     837             : 
     838             :         // create and insert sub-shapes
     839         852 :         Reference< drawing::XShapes > xLegendContainer( m_xShape, uno::UNO_QUERY );
     840         426 :         if( xLegendContainer.is())
     841             :         {
     842             :             // for quickly setting properties
     843         426 :             tPropertyValues aLineFillProperties;
     844         852 :             tPropertyValues aTextProperties;
     845             : 
     846         852 :             Reference< beans::XPropertySet > xLegendProp( m_xLegend, uno::UNO_QUERY );
     847         426 :             ::com::sun::star::chart::ChartLegendExpansion eExpansion = ::com::sun::star::chart::ChartLegendExpansion_HIGH;
     848         426 :             awt::Size aLegendSize( rAvailableSpace );
     849             : 
     850         426 :             if( xLegendProp.is())
     851             :             {
     852             :                 // get Expansion property
     853         426 :                 xLegendProp->getPropertyValue( "Expansion") >>= eExpansion;
     854         426 :                 if( eExpansion == ::com::sun::star::chart::ChartLegendExpansion_CUSTOM )
     855             :                 {
     856           0 :                     RelativeSize aRelativeSize;
     857           0 :                     if ((xLegendProp->getPropertyValue( "RelativeSize") >>= aRelativeSize))
     858             :                     {
     859           0 :                         aLegendSize.Width = static_cast<sal_Int32>(::rtl::math::approxCeil( aRelativeSize.Primary * rPageSize.Width ));
     860           0 :                         aLegendSize.Height = static_cast<sal_Int32>(::rtl::math::approxCeil( aRelativeSize.Secondary * rPageSize.Height ));
     861             :                     }
     862             :                     else
     863           0 :                         eExpansion = ::com::sun::star::chart::ChartLegendExpansion_HIGH;
     864             :                 }
     865         426 :                 lcl_getProperties( xLegendProp, aLineFillProperties, aTextProperties, rPageSize );
     866             :             }
     867             : 
     868             :             // create entries
     869         426 :             double fViewFontSize = lcl_CalcViewFontSize( xLegendProp, rPageSize );//todo
     870             :             // #i109336# Improve auto positioning in chart
     871         426 :             sal_Int32 nSymbolHeight = static_cast< sal_Int32 >( fViewFontSize * 0.6  );
     872         426 :             sal_Int32 nSymbolWidth = static_cast< sal_Int32 >( nSymbolHeight );
     873             : 
     874         426 :             ::std::vector< LegendEntryProvider* >::const_iterator       aIter = m_aLegendEntryProviderList.begin();
     875         426 :             const ::std::vector< LegendEntryProvider* >::const_iterator aEnd  = m_aLegendEntryProviderList.end();
     876         858 :             for( aIter = m_aLegendEntryProviderList.begin(); aIter != aEnd; ++aIter )
     877             :             {
     878         432 :                 LegendEntryProvider* pLegendEntryProvider( *aIter );
     879         432 :                 if( pLegendEntryProvider )
     880             :                 {
     881         432 :                     awt::Size aCurrentRatio = pLegendEntryProvider->getPreferredLegendKeyAspectRatio();
     882         432 :                     sal_Int32 nCurrentWidth = aCurrentRatio.Width;
     883         432 :                     if( aCurrentRatio.Height > 0 )
     884             :                     {
     885         394 :                         nCurrentWidth = nSymbolHeight* aCurrentRatio.Width/aCurrentRatio.Height;
     886             :                     }
     887         432 :                     nSymbolWidth = std::max( nSymbolWidth, nCurrentWidth );
     888             :                 }
     889             :             }
     890         426 :             awt::Size aMaxSymbolExtent( nSymbolWidth, nSymbolHeight );
     891             : 
     892         852 :             tViewLegendEntryContainer aViewEntries;
     893         858 :             for( aIter = m_aLegendEntryProviderList.begin(); aIter != aEnd; ++aIter )
     894             :             {
     895         432 :                 LegendEntryProvider* pLegendEntryProvider( *aIter );
     896         432 :                 if( pLegendEntryProvider )
     897             :                 {
     898         432 :                     std::vector< ViewLegendEntry > aNewEntries = pLegendEntryProvider->createLegendEntries( aMaxSymbolExtent, eExpansion, xLegendProp, xLegendContainer, m_xShapeFactory, m_xContext );
     899         432 :                     aViewEntries.insert( aViewEntries.end(), aNewEntries.begin(), aNewEntries.end() );
     900             :                 }
     901             :             }
     902             : 
     903         426 :             bool bSymbolsLeftSide = lcl_shouldSymbolsBePlacedOnTheLeftSide( xLegendProp, m_nDefaultWritingMode );
     904             : 
     905         426 :             if( !aViewEntries.empty() ) {
     906             :                 // place entries
     907             :                 aLegendSize = lcl_placeLegendEntries( aViewEntries, eExpansion, bSymbolsLeftSide, fViewFontSize, aMaxSymbolExtent,
     908         426 :                                                       aTextProperties, xLegendContainer, m_xShapeFactory, aLegendSize );
     909             : 
     910             :             }
     911             : 
     912             :             Reference< drawing::XShape > xBorder =
     913             :                 pShapeFactory->createRectangle( xLegendContainer,
     914             :                         aLegendSize,
     915             :                         awt::Point(0,0),
     916             :                         aLineFillProperties.first,
     917         852 :                         aLineFillProperties.second, AbstractShapeFactory::Bottom );
     918             : 
     919             :             //because of this name this border will be used for marking the legend
     920         852 :             AbstractShapeFactory::setShapeName( xBorder, "MarkHandles" );
     921         426 :         }
     922             :     }
     923           0 :     catch( const uno::Exception & ex )
     924             :     {
     925             :         ASSERT_EXCEPTION( ex );
     926             :     }
     927             : }
     928             : 
     929         426 : void VLegend::changePosition(
     930             :     awt::Rectangle & rOutAvailableSpace,
     931             :     const awt::Size & rPageSize )
     932             : {
     933         426 :     if(! m_xShape.is())
     934         426 :         return;
     935             : 
     936             :     try
     937             :     {
     938             :         // determine position and alignment depending on default position
     939         426 :         awt::Size aLegendSize = m_xShape->getSize();
     940         426 :         Reference< beans::XPropertySet > xLegendProp( m_xLegend, uno::UNO_QUERY_THROW );
     941         426 :         chart2::RelativePosition aRelativePosition;
     942             : 
     943             :         bool bAutoPosition =
     944         426 :             ! (xLegendProp->getPropertyValue( "RelativePosition") >>= aRelativePosition);
     945             : 
     946         426 :         LegendPosition ePos = LegendPosition_CUSTOM;
     947         426 :         xLegendProp->getPropertyValue( "AnchorPosition") >>= ePos;
     948             : 
     949             :         //calculate position
     950         426 :         if( bAutoPosition )
     951             :         {
     952             :             // auto position: relative to remaining space
     953         343 :             aRelativePosition = lcl_getDefaultPosition( ePos, rOutAvailableSpace, rPageSize );
     954             :             awt::Point aPos = lcl_calculatePositionAndRemainingSpace(
     955         343 :                 rOutAvailableSpace, rPageSize, aRelativePosition, ePos, aLegendSize );
     956         343 :             m_xShape->setPosition( aPos );
     957             :         }
     958             :         else
     959             :         {
     960             :             // manual position: relative to whole page
     961          83 :             awt::Rectangle aAvailableSpace( 0, 0, rPageSize.Width, rPageSize.Height );
     962             :             awt::Point aPos = lcl_calculatePositionAndRemainingSpace(
     963          83 :                 aAvailableSpace, rPageSize, aRelativePosition, ePos, aLegendSize );
     964          83 :             m_xShape->setPosition( aPos );
     965             : 
     966          83 :             if( ePos != LegendPosition_CUSTOM )
     967             :             {
     968             :                 // calculate remaining space as if having autoposition:
     969          83 :                 aRelativePosition = lcl_getDefaultPosition( ePos, rOutAvailableSpace, rPageSize );
     970             :                 lcl_calculatePositionAndRemainingSpace(
     971          83 :                     rOutAvailableSpace, rPageSize, aRelativePosition, ePos, aLegendSize );
     972             :             }
     973         426 :         }
     974             :     }
     975           0 :     catch( const uno::Exception & ex )
     976             :     {
     977             :         ASSERT_EXCEPTION( ex );
     978             :     }
     979             : }
     980             : 
     981         108 : } //namespace chart
     982             : 
     983             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10