chart2/source/tools/PropertyHelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_chart2.hxx"
  30 #include "PropertyHelper.hxx"
  31 #include "ContainerHelper.hxx"
  32 #include "macros.hxx"
  33 #include <com/sun/star/beans/PropertyAttribute.hpp>
  34 #include <com/sun/star/container/XNameContainer.hpp>
  35
  36 #include <vector>
  37 #include <algorithm>
  38 #include <functional>
  39
  40 using namespace ::com::sun::star;
  41 using namespace ::com::sun::star::beans;
  42 using ::rtl::OUString;
  43 using ::com::sun::star::uno::Any;
  44 using ::com::sun::star::uno::Reference;
  45 using ::com::sun::star::uno::Sequence;
  46
  47 namespace
  48 {
  49 struct lcl_EqualsElement : public ::std::unary_function< OUString, bool >
  50 {
  51     explicit lcl_EqualsElement( const Any & rValue, const Reference< container::XNameAccess > & xAccess )
  52             : m_aValue( rValue ), m_xAccess( xAccess )
  53     {
  54         OSL_ASSERT( m_xAccess.is());
  55     }
  56
  57     bool operator() ( const OUString & rName )
  58     {
  59         try
  60         {
  61             return (m_xAccess->getByName( rName ) == m_aValue);
  62         }
  63         catch( const uno::Exception & ex )
  64         {
  65             ASSERT_EXCEPTION( ex );
  66         }
  67         return false;
  68     }
  69
  70 private:
  71     Any m_aValue;
  72     Reference< container::XNameAccess > m_xAccess;
  73 };
  74
  75 struct lcl_StringMatches : public ::std::unary_function< OUString ,bool >
  76 {
  77     lcl_StringMatches( const OUString & rCmpStr ) :
  78             m_aCmpStr( rCmpStr )
  79     {}
  80
  81     bool operator() ( const OUString & rStr )
  82     {
  83         return rStr.match( m_aCmpStr );
  84     }
  85
  86 private:
  87     OUString m_aCmpStr;
  88 };
  89
  90 struct lcl_OUStringRestToInt32 : public ::std::unary_function< OUString, sal_Int32 >
  91 {
  92     lcl_OUStringRestToInt32( sal_Int32 nPrefixLength ) :
  93             m_nPrefixLength( nPrefixLength )
  94     {}
  95     sal_Int32 operator() ( const OUString & rStr )
  96     {
  97         if( m_nPrefixLength > rStr.getLength() )
  98             return 0;
  99         return rStr.copy( m_nPrefixLength ).toInt32( 10 /* radix */ );
 100     }
 101 private:
 102     sal_Int32 m_nPrefixLength;
 103 };
 104
 105 /** adds a fill gradient, fill hatch, fill bitmap, fill transparency gradient,
 106     line dash or line marker to the corresponding name container with a unique
 107     name.
 108
 109     @param rPrefix
 110         The prefix used for automated name generation.
 111
 112     @param rPreferredName
 113         If this string is not empty it is used as name if it is unique in the
 114         table. Otherwise a new name is generated using pPrefix.
 115
 116     @return the new name under which the property was stored in the table
 117 */
 118 OUString lcl_addNamedPropertyUniqueNameToTable(
 119     const Any & rValue,
 120     const Reference< container::XNameContainer > & xNameContainer,
 121     const OUString & rPrefix,
 122     const OUString & rPreferredName )
 123 {
 124     if( ! xNameContainer.is() ||
 125         ! rValue.hasValue() ||
 126         ( rValue.getValueType() != xNameContainer->getElementType()))
 127         return rPreferredName;
 128
 129     try
 130     {
 131         Reference< container::XNameAccess > xNameAccess( xNameContainer, uno::UNO_QUERY_THROW );
 132         ::std::vector< OUString > aNames( ::chart::ContainerHelper::SequenceToVector( xNameAccess->getElementNames()));
 133         ::std::vector< OUString >::const_iterator aIt(
 134             ::std::find_if( aNames.begin(), aNames.end(), lcl_EqualsElement( rValue, xNameAccess )));
 135
 136         // element not found in container
 137         if( aIt == aNames.end())
 138         {
 139             OUString aUniqueName;
 140
 141             // check if preferred name is already used
 142             if( rPreferredName.getLength())
 143             {
 144                 aIt = ::std::find( aNames.begin(), aNames.end(), rPreferredName );
 145                 if( aIt == aNames.end())
 146                     aUniqueName = rPreferredName;
 147             }
 148
 149             if( ! aUniqueName.getLength())
 150             {
 151                 // create a unique id using the prefix plus a number
 152                 ::std::vector< sal_Int32 > aNumbers;
 153                 ::std::vector< OUString >::iterator aNonConstIt(
 154                     ::std::partition( aNames.begin(), aNames.end(), lcl_StringMatches( rPrefix )));
 155                 ::std::transform( aNames.begin(), aNonConstIt,
 156                                   back_inserter( aNumbers ),
 157                                   lcl_OUStringRestToInt32( rPrefix.getLength() ));
 158                 ::std::vector< sal_Int32 >::const_iterator aMaxIt(
 159                     ::std::max_element( aNumbers.begin(), aNumbers.end()));
 160
 161                 sal_Int32 nIndex = 1;
 162                 if( aMaxIt != aNumbers.end())
 163                     nIndex = (*aMaxIt) + 1;
 164
 165                 aUniqueName = rPrefix + OUString::valueOf( nIndex );
 166             }
 167
 168             OSL_ASSERT( aUniqueName.getLength());
 169             xNameContainer->insertByName( aUniqueName, rValue );
 170             return aUniqueName;
 171         }
 172         else
 173             // element found => return name
 174             return *aIt;
 175     }
 176     catch( const uno::Exception & ex )
 177     {
 178         ASSERT_EXCEPTION( ex );
 179     }
 180
 181     return rPreferredName;
 182 }
 183
 184 } // anonymous namespace
 185
 186 namespace chart
 187 {
 188 namespace PropertyHelper
 189 {
 190
 191 OUString addLineDashUniqueNameToTable(
 192     const Any & rValue,
 193     const Reference< lang::XMultiServiceFactory > & xFact,
 194     const OUString & rPreferredName )
 195 {
 196     if( xFact.is())
 197     {
 198         Reference< container::XNameContainer > xNameCnt(
 199             xFact->createInstance( C2U( "com.sun.star.drawing.DashTable" )),
 200             uno::UNO_QUERY );
 201         if( xNameCnt.is())
 202             return lcl_addNamedPropertyUniqueNameToTable(
 203                 rValue, xNameCnt, C2U( "ChartDash " ), rPreferredName );
 204     }
 205     return OUString();
 206 }
 207
 208 OUString addGradientUniqueNameToTable(
 209     const Any & rValue,
 210     const Reference< lang::XMultiServiceFactory > & xFact,
 211     const OUString & rPreferredName )
 212 {
 213     if( xFact.is())
 214     {
 215         Reference< container::XNameContainer > xNameCnt(
 216             xFact->createInstance( C2U( "com.sun.star.drawing.GradientTable" )),
 217             uno::UNO_QUERY );
 218         if( xNameCnt.is())
 219             return lcl_addNamedPropertyUniqueNameToTable(
 220                 rValue, xNameCnt, C2U( "ChartGradient " ), rPreferredName );
 221     }
 222     return OUString();
 223 }
 224
 225
 226 OUString addTransparencyGradientUniqueNameToTable(
 227     const Any & rValue,
 228     const Reference< lang::XMultiServiceFactory > & xFact,
 229     const OUString & rPreferredName )
 230 {
 231     if( xFact.is())
 232     {
 233         Reference< container::XNameContainer > xNameCnt(
 234             xFact->createInstance( C2U( "com.sun.star.drawing.TransparencyGradientTable" )),
 235             uno::UNO_QUERY );
 236         if( xNameCnt.is())
 237             return lcl_addNamedPropertyUniqueNameToTable(
 238                 rValue, xNameCnt, C2U( "ChartTransparencyGradient " ), rPreferredName );
 239     }
 240     return OUString();
 241 }
 242
 243 OUString addHatchUniqueNameToTable(
 244     const Any & rValue,
 245     const Reference< lang::XMultiServiceFactory > & xFact,
 246     const OUString & rPreferredName )
 247 {
 248     if( xFact.is())
 249     {
 250         Reference< container::XNameContainer > xNameCnt(
 251             xFact->createInstance( C2U( "com.sun.star.drawing.HatchTable" )),
 252             uno::UNO_QUERY );
 253         if( xNameCnt.is())
 254             return lcl_addNamedPropertyUniqueNameToTable(
 255                 rValue, xNameCnt, C2U( "ChartHatch " ), rPreferredName );
 256     }
 257     return OUString();
 258 }
 259
 260 OUString addBitmapUniqueNameToTable(
 261     const Any & rValue,
 262     const Reference< lang::XMultiServiceFactory > & xFact,
 263     const OUString & rPreferredName )
 264 {
 265     if( xFact.is())
 266     {
 267         Reference< container::XNameContainer > xNameCnt(
 268             xFact->createInstance( C2U( "com.sun.star.drawing.BitmapTable" )),
 269             uno::UNO_QUERY );
 270         if( xNameCnt.is())
 271             return lcl_addNamedPropertyUniqueNameToTable(
 272                 rValue, xNameCnt, C2U( "ChartBitmap " ), rPreferredName );
 273     }
 274     return OUString();
 275 }
 276
 277 // ----------------------------------------
 278
 279 void setPropertyValueAny( tPropertyValueMap & rOutMap, tPropertyValueMapKey key, const uno::Any & rAny )
 280 {
 281     tPropertyValueMap::iterator aIt( rOutMap.find( key ));
 282     if( aIt == rOutMap.end())
 283         rOutMap.insert( tPropertyValueMap::value_type( key, rAny ));
 284     else
 285         (*aIt).second = rAny;
 286 }
 287
 288 template<>
 289     void setPropertyValue< ::com::sun::star::uno::Any >( tPropertyValueMap & rOutMap, tPropertyValueMapKey key, const ::com::sun::star::uno::Any & rAny )
 290 {
 291     setPropertyValueAny( rOutMap, key, rAny );
 292 }
 293
 294 void setPropertyValueDefaultAny( tPropertyValueMap & rOutMap, tPropertyValueMapKey key, const uno::Any & rAny )
 295 {
 296     OSL_ENSURE( rOutMap.end() == rOutMap.find( key ), "Default already exists for property" );
 297     setPropertyValue( rOutMap, key, rAny );
 298 }
 299
 300 template<>
 301     void setPropertyValueDefault< ::com::sun::star::uno::Any >( tPropertyValueMap & rOutMap, tPropertyValueMapKey key, const ::com::sun::star::uno::Any & rAny )
 302 {
 303     setPropertyValueDefaultAny( rOutMap, key, rAny );
 304 }
 305
 306
 307 void setEmptyPropertyValueDefault( tPropertyValueMap & rOutMap, tPropertyValueMapKey key )
 308 {
 309     setPropertyValueDefault( rOutMap, key, uno::Any());
 310 }
 311
 312 } // namespace PropertyHelper
 313
 314 } //  namespace chart