basic/source/classes/propacc.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
  21 #include "propacc.hxx"
  22
  23 #include <basic/sbstar.hxx>
  24 #include <sbunoobj.hxx>
  25 #include <basic/sbuno.hxx>
  26
  27 using com::sun::star::uno::Reference;
  28 using namespace com::sun::star;
  29 using namespace com::sun::star::uno;
  30 using namespace com::sun::star::lang;
  31 using namespace com::sun::star::beans;
  32 using namespace cppu;
  33
  34 #ifdef WNT
  35 #define CDECL _cdecl
  36 #endif
  37 #if defined(UNX)
  38 #define CDECL
  39 #endif
  40
  41 int CDECL SbCompare_PropertyValues_Impl( const void *arg1, const void *arg2 )
  42 {
  43    return ((PropertyValue*)arg1)->Name.compareTo( ((PropertyValue*)arg2)->Name );
  44 }
  45
  46 struct SbCompare_UString_PropertyValue_Impl
  47 {
  48    bool operator() (const OUString& lhs, PropertyValue const & rhs)
  49    {
  50       return lhs.compareTo(rhs.Name) < 0;
  51    }
  52    bool operator() (PropertyValue const & lhs, const OUString& rhs)
  53    {
  54       return lhs.Name.compareTo(rhs) < 0;
  55    }
  56 #ifdef DBG_UTIL
  57    bool operator() (PropertyValue const & lhs, const PropertyValue& rhs)
  58    {
  59        return lhs.Name.compareTo(rhs.Name) < 0;
  60    }
  61 #endif
  62 };
  63
  64 int CDECL SbCompare_Properties_Impl( const void *arg1, const void *arg2 )
  65 {
  66    return ((Property*)arg1)->Name.compareTo( ((Property*)arg2)->Name );
  67 }
  68
  69 extern "C" int CDECL SbCompare_UString_Property_Impl( const void *arg1, const void *arg2 )
  70 {
  71     const OUString *pArg1 = (OUString*) arg1;
  72     const Property *pArg2 = (Property*) arg2;
  73     return pArg1->compareTo( pArg2->Name );
  74 }
  75
  76 //----------------------------------------------------------------------------
  77
  78 SbPropertyValues::SbPropertyValues()
  79 {
  80 }
  81
  82 //----------------------------------------------------------------------------
  83
  84 SbPropertyValues::~SbPropertyValues()
  85 {
  86     m_xInfo = Reference< XPropertySetInfo >();
  87 }
  88
  89 //----------------------------------------------------------------------------
  90
  91 Reference< XPropertySetInfo > SbPropertyValues::getPropertySetInfo(void) throw( RuntimeException )
  92 {
  93     // create on demand?
  94     if (!m_xInfo.is())
  95     {
  96         SbPropertySetInfo *pInfo = new SbPropertySetInfo( m_aPropVals );
  97         m_xInfo.set(pInfo);
  98     }
  99     return m_xInfo;
 100 }
 101
 102 //-------------------------------------------------------------------------
 103
 104 size_t SbPropertyValues::GetIndex_Impl( const OUString &rPropName ) const
 105 {
 106     SbPropertyValueArr_Impl::const_iterator it = std::lower_bound(
 107           m_aPropVals.begin(), m_aPropVals.end(), rPropName,
 108           SbCompare_UString_PropertyValue_Impl() );
 109     if (it == m_aPropVals.end())
 110     {
 111         throw beans::UnknownPropertyException(
 112                 "Property not found: " + rPropName,
 113                 const_cast<SbPropertyValues&>(*this));
 114     }
 115     return it - m_aPropVals.begin();
 116 }
 117
 118 //----------------------------------------------------------------------------
 119
 120 void SbPropertyValues::setPropertyValue(
 121                     const OUString& aPropertyName,
 122                     const Any& aValue)
 123                     throw (::com::sun::star::beans::UnknownPropertyException,
 124                     ::com::sun::star::beans::PropertyVetoException,
 125                     ::com::sun::star::lang::IllegalArgumentException,
 126                     ::com::sun::star::lang::WrappedTargetException,
 127                     ::com::sun::star::uno::RuntimeException)
 128 {
 129     size_t const nIndex = GetIndex_Impl( aPropertyName );
 130     PropertyValue & rPropVal = m_aPropVals[nIndex];
 131     rPropVal.Value = aValue;
 132 }
 133
 134 //----------------------------------------------------------------------------
 135
 136 Any SbPropertyValues::getPropertyValue(
 137                     const OUString& aPropertyName)
 138                     throw(::com::sun::star::beans::UnknownPropertyException,
 139                     ::com::sun::star::lang::WrappedTargetException,
 140                     ::com::sun::star::uno::RuntimeException)
 141 {
 142     size_t const nIndex = GetIndex_Impl( aPropertyName );
 143     return m_aPropVals[nIndex].Value;
 144 }
 145
 146 //----------------------------------------------------------------------------
 147
 148 void SbPropertyValues::addPropertyChangeListener(
 149                     const OUString& aPropertyName,
 150                     const Reference< XPropertyChangeListener >& )
 151                     throw ()
 152 {
 153     (void)aPropertyName;
 154 }
 155
 156 //----------------------------------------------------------------------------
 157
 158 void SbPropertyValues::removePropertyChangeListener(
 159                     const OUString& aPropertyName,
 160                     const Reference< XPropertyChangeListener >& )
 161                     throw ()
 162 {
 163     (void)aPropertyName;
 164 }
 165
 166 //----------------------------------------------------------------------------
 167
 168 void SbPropertyValues::addVetoableChangeListener(
 169                     const OUString& aPropertyName,
 170                     const Reference< XVetoableChangeListener >& )
 171                     throw()
 172 {
 173     (void)aPropertyName;
 174 }
 175
 176 //----------------------------------------------------------------------------
 177
 178 void SbPropertyValues::removeVetoableChangeListener(
 179                     const OUString& aPropertyName,
 180                     const Reference< XVetoableChangeListener >& )
 181                     throw()
 182 {
 183     (void)aPropertyName;
 184 }
 185
 186 //----------------------------------------------------------------------------
 187
 188 Sequence< PropertyValue > SbPropertyValues::getPropertyValues(void) throw (::com::sun::star::uno::RuntimeException)
 189 {
 190     Sequence<PropertyValue> aRet( m_aPropVals.size() );
 191     for (size_t n = 0; n < m_aPropVals.size(); ++n)
 192         aRet.getArray()[n] = m_aPropVals[n];
 193     return aRet;
 194 }
 195
 196 //----------------------------------------------------------------------------
 197
 198 void SbPropertyValues::setPropertyValues(const Sequence< PropertyValue >& rPropertyValues )
 199                      throw (::com::sun::star::beans::UnknownPropertyException,
 200                      ::com::sun::star::beans::PropertyVetoException,
 201                      ::com::sun::star::lang::IllegalArgumentException,
 202                      ::com::sun::star::lang::WrappedTargetException,
 203                      ::com::sun::star::uno::RuntimeException)
 204 {
 205     if ( !m_aPropVals.empty() )
 206         throw PropertyExistException();
 207
 208     const PropertyValue *pPropVals = rPropertyValues.getConstArray();
 209     for (sal_Int32 n = 0; n < rPropertyValues.getLength(); ++n)
 210     {
 211         PropertyValue *pPropVal = new PropertyValue(pPropVals[n]);
 212         m_aPropVals.push_back( pPropVal );
 213     }
 214 }
 215
 216 //============================================================================
 217 //PropertySetInfoImpl
 218
 219 PropertySetInfoImpl::PropertySetInfoImpl()
 220 {
 221 }
 222
 223 sal_Int32 PropertySetInfoImpl::GetIndex_Impl( const OUString &rPropName ) const
 224 {
 225     Property *pP;
 226     pP = (Property*)
 227             bsearch( &rPropName, _aProps.getConstArray(), _aProps.getLength(),
 228                       sizeof( Property ),
 229                       SbCompare_UString_Property_Impl );
 230     return pP ? sal::static_int_cast<sal_Int32>( pP - _aProps.getConstArray() ) : -1;
 231 }
 232
 233 Sequence< Property > PropertySetInfoImpl::getProperties(void) throw()
 234 {
 235     return _aProps;
 236 }
 237
 238 Property PropertySetInfoImpl::getPropertyByName(const OUString& Name) throw( RuntimeException )
 239 {
 240     sal_Int32 nIndex = GetIndex_Impl( Name );
 241     if( USHRT_MAX != nIndex )
 242         return _aProps.getConstArray()[ nIndex ];
 243     return Property();
 244 }
 245
 246 sal_Bool PropertySetInfoImpl::hasPropertyByName(const OUString& Name) throw( RuntimeException )
 247 {
 248     sal_Int32 nIndex = GetIndex_Impl( Name );
 249     return USHRT_MAX != nIndex;
 250 }
 251
 252
 253 //----------------------------------------------------------------------------
 254
 255 SbPropertySetInfo::SbPropertySetInfo( const SbPropertyValueArr_Impl &rPropVals )
 256 {
 257     aImpl._aProps.realloc( rPropVals.size() );
 258     for ( sal_uInt16 n = 0; n < rPropVals.size(); ++n )
 259     {
 260         Property &rProp = aImpl._aProps.getArray()[n];
 261         const PropertyValue &rPropVal = rPropVals[n];
 262         rProp.Name = rPropVal.Name;
 263         rProp.Handle = rPropVal.Handle;
 264         rProp.Type = getCppuVoidType();
 265         rProp.Attributes = 0;
 266     }
 267 }
 268
 269 //----------------------------------------------------------------------------
 270
 271 SbPropertySetInfo::~SbPropertySetInfo()
 272 {
 273 }
 274
 275 //-------------------------------------------------------------------------
 276
 277 Sequence< Property > SbPropertySetInfo::getProperties(void) throw( RuntimeException )
 278 {
 279     return aImpl.getProperties();
 280 }
 281
 282 Property SbPropertySetInfo::getPropertyByName(const OUString& Name)
 283     throw( RuntimeException )
 284 {
 285     return aImpl.getPropertyByName( Name );
 286 }
 287
 288 sal_Bool SbPropertySetInfo::hasPropertyByName(const OUString& Name)
 289     throw( RuntimeException )
 290 {
 291     return aImpl.hasPropertyByName( Name );
 292 }
 293
 294 //----------------------------------------------------------------------------
 295
 296 void RTL_Impl_CreatePropertySet( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite )
 297 {
 298     (void)pBasic;
 299     (void)bWrite;
 300
 301     // We need at least one parameter
 302     // TODO: In this case < 2 is not correct ;-)
 303     if ( rPar.Count() < 2 )
 304     {
 305         StarBASIC::Error( SbERR_BAD_ARGUMENT );
 306         return;
 307     }
 308
 309     // Get class names of struct
 310     OUString aServiceName( "stardiv.uno.beans.PropertySet");
 311
 312     Reference< XInterface > xInterface = (OWeakObject*) new SbPropertyValues();
 313
 314     SbxVariableRef refVar = rPar.Get(0);
 315     if( xInterface.is() )
 316     {
 317         // Set PropertyValues
 318         Any aArgAsAny = sbxToUnoValue( rPar.Get(1),
 319                 getCppuType( (Sequence<PropertyValue>*)0 ) );
 320         Sequence<PropertyValue> *pArg =
 321                 (Sequence<PropertyValue>*) aArgAsAny.getValue();
 322         Reference< XPropertyAccess > xPropAcc = Reference< XPropertyAccess >::query( xInterface );
 323         xPropAcc->setPropertyValues( *pArg );
 324
 325         // Build a SbUnoObject and return it
 326         Any aAny;
 327         aAny <<= xInterface;
 328         SbUnoObjectRef xUnoObj = new SbUnoObject( aServiceName, aAny );
 329         if( xUnoObj->getUnoAny().getValueType().getTypeClass() != TypeClass_VOID )
 330         {
 331             // Return object
 332             refVar->PutObject( (SbUnoObject*)xUnoObj );
 333             return;
 334         }
 335     }
 336
 337     // Object could not be created
 338     refVar->PutObject( NULL );
 339 }
 340
 341 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */