sc/source/ui/unoobj/miscuno.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 <cppuhelper/supportsservice.hxx>
  21 #include <vcl/svapp.hxx>
  22
  23 #include "miscuno.hxx"
  24
  25 using namespace com::sun::star;
  26 using ::com::sun::star::uno::Reference;
  27 using ::com::sun::star::uno::Any;
  28
  29 SC_SIMPLE_SERVICE_INFO( ScNameToIndexAccess, "ScNameToIndexAccess", "stardiv.unknown" )
  30
  31 uno::Reference<uno::XInterface> ScUnoHelpFunctions::AnyToInterface( const uno::Any& rAny )
  32 {
  33     if ( rAny.getValueTypeClass() == uno::TypeClass_INTERFACE )
  34     {
  35         return uno::Reference<uno::XInterface>(rAny, uno::UNO_QUERY);
  36     }
  37     return uno::Reference<uno::XInterface>();   //! Exception?
  38 }
  39
  40 bool ScUnoHelpFunctions::GetBoolProperty( const uno::Reference<beans::XPropertySet>& xProp,
  41                                             const OUString& rName, bool bDefault )
  42 {
  43     bool bRet = bDefault;
  44     if ( xProp.is() )
  45     {
  46         try
  47         {
  48             uno::Any aAny(xProp->getPropertyValue( rName ));
  49             //! type conversion???
  50             //  operator >>= shouldn't be used for bool (?)
  51             if ( aAny.getValueTypeClass() == uno::TypeClass_BOOLEAN )
  52             {
  53                 //! safe way to get bool value from any???
  54                 bRet = *static_cast<sal_Bool const *>(aAny.getValue());
  55             }
  56         }
  57         catch(uno::Exception&)
  58         {
  59             // keep default
  60         }
  61     }
  62     return bRet;
  63 }
  64
  65 sal_Int32 ScUnoHelpFunctions::GetLongProperty( const uno::Reference<beans::XPropertySet>& xProp,
  66                                             const OUString& rName, long nDefault )
  67 {
  68     sal_Int32 nRet = nDefault;
  69     if ( xProp.is() )
  70     {
  71         try
  72         {
  73             //! type conversion???
  74             xProp->getPropertyValue( rName ) >>= nRet;
  75         }
  76         catch(uno::Exception&)
  77         {
  78             // keep default
  79         }
  80     }
  81     return nRet;
  82 }
  83
  84 sal_Int32 ScUnoHelpFunctions::GetEnumProperty( const uno::Reference<beans::XPropertySet>& xProp,
  85                                             const OUString& rName, long nDefault )
  86 {
  87     sal_Int32 nRet = nDefault;
  88     if ( xProp.is() )
  89     {
  90         try
  91         {
  92             uno::Any aAny(xProp->getPropertyValue( rName ));
  93
  94             if ( aAny.getValueTypeClass() == uno::TypeClass_ENUM )
  95             {
  96                 //! get enum value from any???
  97                 nRet = *static_cast<sal_Int32 const *>(aAny.getValue());
  98             }
  99             else
 100             {
 101                 //! type conversion???
 102                 aAny >>= nRet;
 103             }
 104         }
 105         catch(uno::Exception&)
 106         {
 107             // keep default
 108         }
 109     }
 110     return nRet;
 111 }
 112
 113 OUString ScUnoHelpFunctions::GetStringProperty(
 114     const Reference<beans::XPropertySet>& xProp, const OUString& rName, const OUString& rDefault )
 115 {
 116     OUString aRet = rDefault;
 117     if (!xProp.is())
 118         return aRet;
 119
 120     try
 121     {
 122         Any any = xProp->getPropertyValue(rName);
 123         any >>= aRet;
 124     }
 125     catch (const uno::Exception&)
 126     {
 127     }
 128
 129     return aRet;
 130 }
 131
 132 bool ScUnoHelpFunctions::GetBoolFromAny( const uno::Any& aAny )
 133 {
 134     if ( aAny.getValueTypeClass() == uno::TypeClass_BOOLEAN )
 135         return *static_cast<sal_Bool const *>(aAny.getValue());
 136     return false;
 137 }
 138
 139 sal_Int16 ScUnoHelpFunctions::GetInt16FromAny( const uno::Any& aAny )
 140 {
 141     sal_Int16 nRet = 0;
 142     if ( aAny >>= nRet )
 143         return nRet;
 144     return 0;
 145 }
 146
 147 sal_Int32 ScUnoHelpFunctions::GetInt32FromAny( const uno::Any& aAny )
 148 {
 149     sal_Int32 nRet = 0;
 150     if ( aAny >>= nRet )
 151         return nRet;
 152     return 0;
 153 }
 154
 155 sal_Int32 ScUnoHelpFunctions::GetEnumFromAny( const uno::Any& aAny )
 156 {
 157     sal_Int32 nRet = 0;
 158     if ( aAny.getValueTypeClass() == uno::TypeClass_ENUM )
 159         nRet = *static_cast<sal_Int32 const *>(aAny.getValue());
 160     else
 161         aAny >>= nRet;
 162     return nRet;
 163 }
 164
 165 void ScUnoHelpFunctions::SetBoolInAny( uno::Any& rAny, bool bValue )
 166 {
 167     sal_Bool bTemp = bValue ? 1 : 0;
 168     rAny.setValue( &bTemp, cppu::UnoType<bool>::get() );
 169 }
 170
 171 void ScUnoHelpFunctions::SetOptionalPropertyValue(
 172     Reference<beans::XPropertySet>& rPropSet, const sal_Char* pPropName, const Any& rVal )
 173 {
 174     try
 175     {
 176         rPropSet->setPropertyValue(OUString::createFromAscii(pPropName), rVal);
 177     }
 178     catch (const beans::UnknownPropertyException&)
 179     {
 180         // ignored - not supported.
 181     }
 182 }
 183
 184 ScIndexEnumeration::ScIndexEnumeration(const uno::Reference<container::XIndexAccess>& rInd,
 185                                        const OUString& rServiceName) :
 186     xIndex( rInd ),
 187     sServiceName(rServiceName),
 188     nPos( 0 )
 189 {
 190 }
 191
 192 ScIndexEnumeration::~ScIndexEnumeration()
 193 {
 194 }
 195
 196 // XEnumeration
 197
 198 sal_Bool SAL_CALL ScIndexEnumeration::hasMoreElements() throw(uno::RuntimeException, std::exception)
 199 {
 200     SolarMutexGuard aGuard;
 201     return ( nPos < xIndex->getCount() );
 202 }
 203
 204 uno::Any SAL_CALL ScIndexEnumeration::nextElement() throw(container::NoSuchElementException,
 205                                         lang::WrappedTargetException, uno::RuntimeException, std::exception)
 206 {
 207     SolarMutexGuard aGuard;
 208     uno::Any aReturn;
 209     try
 210     {
 211         aReturn = xIndex->getByIndex(nPos++);
 212     }
 213     catch (lang::IndexOutOfBoundsException&)
 214     {
 215         throw container::NoSuchElementException();
 216     }
 217     return aReturn;
 218 }
 219
 220 OUString SAL_CALL ScIndexEnumeration::getImplementationName()
 221     throw(::com::sun::star::uno::RuntimeException, std::exception)
 222 {
 223     return OUString("ScIndexEnumeration");
 224 }
 225
 226 sal_Bool SAL_CALL ScIndexEnumeration::supportsService( const OUString& ServiceName )
 227     throw(::com::sun::star::uno::RuntimeException, std::exception)
 228 {
 229     return cppu::supportsService(this, ServiceName);
 230 }
 231
 232 ::com::sun::star::uno::Sequence< OUString >
 233     SAL_CALL ScIndexEnumeration::getSupportedServiceNames()
 234     throw(::com::sun::star::uno::RuntimeException, std::exception)
 235 {
 236     ::com::sun::star::uno::Sequence< OUString > aRet(1);
 237     OUString* pArray = aRet.getArray();
 238     pArray[0] = sServiceName;
 239     return aRet;
 240 }
 241
 242 ScNameToIndexAccess::ScNameToIndexAccess( const com::sun::star::uno::Reference<
 243                                             com::sun::star::container::XNameAccess>& rNameObj ) :
 244     xNameAccess( rNameObj )
 245 {
 246     //! test for XIndexAccess interface at rNameObj, use that instead!
 247
 248     if ( xNameAccess.is() )
 249         aNames = xNameAccess->getElementNames();
 250 }
 251
 252 ScNameToIndexAccess::~ScNameToIndexAccess()
 253 {
 254 }
 255
 256 // XIndexAccess
 257
 258 sal_Int32 SAL_CALL ScNameToIndexAccess::getCount(  ) throw(::com::sun::star::uno::RuntimeException, std::exception)
 259 {
 260     return aNames.getLength();
 261 }
 262
 263 ::com::sun::star::uno::Any SAL_CALL ScNameToIndexAccess::getByIndex( sal_Int32 nIndex )
 264                                 throw(::com::sun::star::lang::IndexOutOfBoundsException,
 265                                         ::com::sun::star::lang::WrappedTargetException,
 266                                         ::com::sun::star::uno::RuntimeException, std::exception)
 267 {
 268     if ( xNameAccess.is() && nIndex >= 0 && nIndex < aNames.getLength() )
 269         return xNameAccess->getByName( aNames.getConstArray()[nIndex] );
 270
 271     throw lang::IndexOutOfBoundsException();
 272 }
 273
 274 // XElementAccess
 275
 276 ::com::sun::star::uno::Type SAL_CALL ScNameToIndexAccess::getElementType(  )
 277                                 throw(::com::sun::star::uno::RuntimeException, std::exception)
 278 {
 279     if ( xNameAccess.is() )
 280         return xNameAccess->getElementType();
 281     else
 282         return uno::Type();
 283 }
 284
 285 sal_Bool SAL_CALL ScNameToIndexAccess::hasElements(  ) throw(::com::sun::star::uno::RuntimeException, std::exception)
 286 {
 287     return getCount() > 0;
 288 }
 289
 290 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */