editeng/source/uno/unoipset.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 <com/sun/star/beans/XPropertySet.hpp>
  21 #include <svl/itemprop.hxx>
  22 #include <tools/helpers.hxx>
  23 #include <editeng/unoipset.hxx>
  24 #include <svl/itempool.hxx>
  25 #include <svl/solar.hrc>
  26 #include <o3tl/any.hxx>
  27 #include <osl/diagnose.h>
  28 #include <sal/log.hxx>
  29 #include <algorithm>
  30
  31 using namespace ::com::sun::star;
  32
  33
  34 struct SvxIDPropertyCombine
  35 {
  36     sal_uInt16  nWID;
  37     sal_uInt8   memberId;
  38     uno::Any    aAny;
  39 };
  40
  41
  42 SvxItemPropertySet::SvxItemPropertySet( const SfxItemPropertyMapEntry* pMap, SfxItemPool& rItemPool )
  43 :   m_aPropertyMap( pMap ),
  44     mrItemPool( rItemPool )
  45 {
  46 }
  47
  48
  49 SvxItemPropertySet::~SvxItemPropertySet()
  50 {
  51     ClearAllUsrAny();
  52 }
  53
  54
  55 uno::Any* SvxItemPropertySet::GetUsrAnyForID(SfxItemPropertySimpleEntry const & entry) const
  56 {
  57     for (auto const & pActual : aCombineList)
  58     {
  59         if( pActual->nWID == entry.nWID && pActual->memberId == entry.nMemberId )
  60             return &pActual->aAny;
  61     }
  62     return nullptr;
  63 }
  64
  65
  66 void SvxItemPropertySet::AddUsrAnyForID(
  67     const uno::Any& rAny, SfxItemPropertySimpleEntry const & entry)
  68 {
  69     std::unique_ptr<SvxIDPropertyCombine> pNew(new SvxIDPropertyCombine);
  70     pNew->nWID = entry.nWID;
  71     pNew->memberId = entry.nMemberId;
  72     pNew->aAny = rAny;
  73     aCombineList.push_back( std::move(pNew) );
  74 }
  75
  76
  77 void SvxItemPropertySet::ClearAllUsrAny()
  78 {
  79     aCombineList.clear();
  80 }
  81
  82
  83 static bool SvxUnoCheckForPositiveValue( const uno::Any& rVal )
  84 {
  85     bool bConvert = true; // the default is that all metric items must be converted
  86     sal_Int32 nValue = 0;
  87     if( rVal >>= nValue )
  88         bConvert = (nValue > 0);
  89     return bConvert;
  90 }
  91
  92
  93 uno::Any SvxItemPropertySet::getPropertyValue( const SfxItemPropertySimpleEntry* pMap, const SfxItemSet& rSet, bool bSearchInParent, bool bDontConvertNegativeValues )
  94 {
  95     uno::Any aVal;
  96     if(!pMap || !pMap->nWID)
  97         return aVal;
  98
  99     const SfxPoolItem* pItem = nullptr;
 100     SfxItemPool* pPool = rSet.GetPool();
 101     (void)rSet.GetItemState( pMap->nWID, bSearchInParent, &pItem );
 102     if( nullptr == pItem && pPool )
 103         pItem = &(pPool->GetDefaultItem( pMap->nWID ));
 104
 105     const MapUnit eMapUnit = pPool ? pPool->GetMetric(pMap->nWID) : MapUnit::Map100thMM;
 106     sal_uInt8 nMemberId = pMap->nMemberId;
 107     if( eMapUnit == MapUnit::Map100thMM )
 108         nMemberId &= (~CONVERT_TWIPS);
 109
 110     if(pItem)
 111     {
 112         pItem->QueryValue( aVal, nMemberId );
 113         if( pMap->nMoreFlags & PropertyMoreFlags::METRIC_ITEM )
 114         {
 115             if( eMapUnit != MapUnit::Map100thMM )
 116             {
 117                 if ( !bDontConvertNegativeValues || SvxUnoCheckForPositiveValue( aVal ) )
 118                     SvxUnoConvertToMM( eMapUnit, aVal );
 119             }
 120         }
 121         else if ( pMap->aType.getTypeClass() == uno::TypeClass_ENUM &&
 122               aVal.getValueType() == ::cppu::UnoType<sal_Int32>::get() )
 123         {
 124             // convert typeless SfxEnumItem to enum type
 125             sal_Int32 nEnum;
 126             aVal >>= nEnum;
 127             aVal.setValue( &nEnum, pMap->aType );
 128         }
 129     }
 130     else
 131     {
 132         OSL_FAIL( "No SfxPoolItem found for property!" );
 133     }
 134
 135     return aVal;
 136 }
 137
 138
 139 void SvxItemPropertySet::setPropertyValue( const SfxItemPropertySimpleEntry* pMap, const uno::Any& rVal, SfxItemSet& rSet, bool bDontConvertNegativeValues )
 140 {
 141     if(!pMap || !pMap->nWID)
 142         return;
 143
 144     // Get item
 145     const SfxPoolItem* pItem = nullptr;
 146     SfxItemState eState = rSet.GetItemState( pMap->nWID, true, &pItem );
 147     SfxItemPool* pPool = rSet.GetPool();
 148
 149     // Put UnoAny in the item value
 150     if(eState < SfxItemState::DEFAULT || pItem == nullptr)
 151     {
 152         if( pPool == nullptr )
 153         {
 154             OSL_FAIL( "No default item and no pool?" );
 155             return;
 156         }
 157
 158         pItem = &pPool->GetDefaultItem( pMap->nWID );
 159     }
 160
 161     uno::Any aValue(rVal);
 162
 163     const MapUnit eMapUnit = pPool ? pPool->GetMetric(pMap->nWID) : MapUnit::Map100thMM;
 164
 165     // check for needed metric translation
 166     if ((pMap->nMoreFlags & PropertyMoreFlags::METRIC_ITEM) && eMapUnit != MapUnit::Map100thMM)
 167     {
 168         if (!bDontConvertNegativeValues || SvxUnoCheckForPositiveValue(aValue))
 169             SvxUnoConvertFromMM(eMapUnit, aValue);
 170     }
 171
 172     std::unique_ptr<SfxPoolItem> pNewItem(pItem->Clone());
 173
 174     sal_uInt8 nMemberId = pMap->nMemberId;
 175     if (eMapUnit == MapUnit::Map100thMM)
 176         nMemberId &= (~CONVERT_TWIPS);
 177
 178     if (pNewItem->PutValue(aValue, nMemberId))
 179     {
 180         // Set new item in item set
 181         pNewItem->SetWhich(pMap->nWID);
 182         rSet.Put(*pNewItem);
 183     }
 184 }
 185
 186
 187 uno::Any SvxItemPropertySet::getPropertyValue( const SfxItemPropertySimpleEntry* pMap ) const
 188 {
 189     // Already entered a value? Then finish quickly
 190     uno::Any* pUsrAny = GetUsrAnyForID(*pMap);
 191     if(pUsrAny)
 192         return *pUsrAny;
 193
 194     // No UsrAny detected yet, generate Default entry and return this
 195     const MapUnit eMapUnit = mrItemPool.GetMetric(pMap->nWID);
 196     sal_uInt8 nMemberId = pMap->nMemberId;
 197     if( eMapUnit == MapUnit::Map100thMM )
 198         nMemberId &= (~CONVERT_TWIPS);
 199     uno::Any aVal;
 200     SfxItemSet aSet( mrItemPool, {{pMap->nWID, pMap->nWID}});
 201
 202     if( (pMap->nWID < OWN_ATTR_VALUE_START) || (pMap->nWID > OWN_ATTR_VALUE_END ) )
 203     {
 204         // Get Default from ItemPool
 205         if(SfxItemPool::IsWhich(pMap->nWID))
 206             aSet.Put(mrItemPool.GetDefaultItem(pMap->nWID));
 207     }
 208
 209     if(aSet.Count())
 210     {
 211         const SfxPoolItem* pItem = nullptr;
 212         SfxItemState eState = aSet.GetItemState( pMap->nWID, true, &pItem );
 213         if(eState >= SfxItemState::DEFAULT && pItem)
 214         {
 215             pItem->QueryValue( aVal, nMemberId );
 216             const_cast<SvxItemPropertySet*>(this)->AddUsrAnyForID(aVal, *pMap);
 217         }
 218     }
 219
 220     // check for needed metric translation
 221     if(pMap->nMoreFlags & PropertyMoreFlags::METRIC_ITEM && eMapUnit != MapUnit::Map100thMM)
 222     {
 223         SvxUnoConvertToMM( eMapUnit, aVal );
 224     }
 225
 226     if ( pMap->aType.getTypeClass() == uno::TypeClass_ENUM &&
 227           aVal.getValueType() == ::cppu::UnoType<sal_Int32>::get() )
 228     {
 229         sal_Int32 nEnum;
 230         aVal >>= nEnum;
 231
 232         aVal.setValue( &nEnum, pMap->aType );
 233     }
 234
 235     return aVal;
 236 }
 237
 238
 239 void SvxItemPropertySet::setPropertyValue( const SfxItemPropertySimpleEntry* pMap, const uno::Any& rVal ) const
 240 {
 241     uno::Any* pUsrAny = GetUsrAnyForID(*pMap);
 242     if(!pUsrAny)
 243         const_cast<SvxItemPropertySet*>(this)->AddUsrAnyForID(rVal, *pMap);
 244     else
 245         *pUsrAny = rVal;
 246 }
 247
 248
 249 const SfxItemPropertySimpleEntry* SvxItemPropertySet::getPropertyMapEntry(const OUString &rName) const
 250 {
 251     return m_aPropertyMap.getByName( rName );
 252  }
 253
 254
 255 uno::Reference< beans::XPropertySetInfo > const &  SvxItemPropertySet::getPropertySetInfo() const
 256 {
 257     if( !m_xInfo.is() )
 258         m_xInfo = new SfxItemPropertySetInfo( m_aPropertyMap );
 259     return m_xInfo;
 260 }
 261
 262
 263 #ifndef TWIPS_TO_MM
 264 #define TWIPS_TO_MM(val) ((val * 127 + 36) / 72)
 265 #endif
 266
 267 /** converts the given any with a metric to 100th/mm if needed */
 268 void SvxUnoConvertToMM( const MapUnit eSourceMapUnit, uno::Any & rMetric ) throw()
 269 {
 270     // map the metric of the itempool to 100th mm
 271     switch(eSourceMapUnit)
 272     {
 273         case MapUnit::MapTwip :
 274         {
 275             switch( rMetric.getValueTypeClass() )
 276             {
 277             case uno::TypeClass_BYTE:
 278                 rMetric <<= static_cast<sal_Int8>(TWIPS_TO_MM(*o3tl::forceAccess<sal_Int8>(rMetric)));
 279                 break;
 280             case uno::TypeClass_SHORT:
 281                 rMetric <<= static_cast<sal_Int16>(TWIPS_TO_MM(*o3tl::forceAccess<sal_Int16>(rMetric)));
 282                 break;
 283             case uno::TypeClass_UNSIGNED_SHORT:
 284                 rMetric <<= static_cast<sal_uInt16>(TWIPS_TO_MM(*o3tl::forceAccess<sal_uInt16>(rMetric)));
 285                 break;
 286             case uno::TypeClass_LONG:
 287                 rMetric <<= static_cast<sal_Int32>(TWIPS_TO_MM(*o3tl::forceAccess<sal_Int32>(rMetric)));
 288                 break;
 289             case uno::TypeClass_UNSIGNED_LONG:
 290                 rMetric <<= static_cast<sal_uInt32>(TWIPS_TO_MM(*o3tl::forceAccess<sal_uInt32>(rMetric)));
 291                 break;
 292             default:
 293                 SAL_WARN("editeng", "AW: Missing unit translation to 100th mm, " << OString::number(static_cast<sal_Int32>(rMetric.getValueTypeClass())));
 294                 assert(false);
 295             }
 296             break;
 297         }
 298         default:
 299         {
 300             OSL_FAIL("AW: Missing unit translation to 100th mm!");
 301         }
 302     }
 303 }
 304
 305
 306 /** converts the given any with a metric from 100th/mm to the given metric if needed */
 307 void SvxUnoConvertFromMM( const MapUnit eDestinationMapUnit, uno::Any & rMetric ) throw()
 308 {
 309     switch(eDestinationMapUnit)
 310     {
 311         case MapUnit::MapTwip :
 312         {
 313             switch( rMetric.getValueTypeClass() )
 314             {
 315                 case uno::TypeClass_BYTE:
 316                     rMetric <<= static_cast<sal_Int8>(sanitiseMm100ToTwip(*o3tl::forceAccess<sal_Int8>(rMetric)));
 317                     break;
 318                 case uno::TypeClass_SHORT:
 319                     rMetric <<= static_cast<sal_Int16>(sanitiseMm100ToTwip(*o3tl::forceAccess<sal_Int16>(rMetric)));
 320                     break;
 321                 case uno::TypeClass_UNSIGNED_SHORT:
 322                     rMetric <<= static_cast<sal_uInt16>(sanitiseMm100ToTwip(*o3tl::forceAccess<sal_uInt16>(rMetric)));
 323                     break;
 324                 case uno::TypeClass_LONG:
 325                     rMetric <<= static_cast<sal_Int32>(sanitiseMm100ToTwip(*o3tl::forceAccess<sal_Int32>(rMetric)));
 326                     break;
 327                 case uno::TypeClass_UNSIGNED_LONG:
 328                     rMetric <<= static_cast<sal_uInt32>(sanitiseMm100ToTwip(*o3tl::forceAccess<sal_uInt32>(rMetric)));
 329                     break;
 330                 default:
 331                     OSL_FAIL("AW: Missing unit translation to 100th mm!");
 332             }
 333             break;
 334         }
 335         default:
 336         {
 337             OSL_FAIL("AW: Missing unit translation to PoolMetrics!");
 338         }
 339     }
 340 }
 341
 342 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */