propshlp.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
/*
 * This file is part of LibreOffice published API.
 */
 
#ifndef INCLUDED_CPPUHELPER_PROPSHLP_HXX
#define INCLUDED_CPPUHELPER_PROPSHLP_HXX
 
#include "rtl/alloc.h"
 
#include "cppuhelper/interfacecontainer.h"
 
#include "com/sun/star/beans/XPropertySet.hpp"
#include "com/sun/star/beans/XPropertySetOption.hpp"
#include "com/sun/star/beans/XMultiPropertySet.hpp"
#include "com/sun/star/beans/XFastPropertySet.hpp"
 
#include "cppuhelper/cppuhelperdllapi.h"
 
 
namespace cppu
{
 
 
/*************************************************************************
*************************************************************************/
 
 
class SAL_WARN_UNUSED CPPUHELPER_DLLPUBLIC IPropertyArrayHelper
{
public:
    // these are here to force memory de/allocation to sal lib.
    static void * SAL_CALL operator new( size_t nSize )
        { return ::rtl_allocateMemory( nSize ); }
    static void SAL_CALL operator delete( void * pMem )
        { ::rtl_freeMemory( pMem ); }
    static void * SAL_CALL operator new( size_t, void * pMem )
        { return pMem; }
    static void SAL_CALL operator delete( void *, void * )
        {}
 
    virtual ~IPropertyArrayHelper();
 
    virtual sal_Bool SAL_CALL fillPropertyMembersByHandle(
        ::rtl::OUString * pPropName, sal_Int16 * pAttributes, sal_Int32 nHandle ) = 0;
    virtual css::uno::Sequence< css::beans::Property > SAL_CALL getProperties() = 0;
    virtual css::beans::Property SAL_CALL getPropertyByName(
        const ::rtl::OUString& rPropertyName ) = 0;
    virtual sal_Bool SAL_CALL hasPropertyByName(const ::rtl::OUString& rPropertyName) = 0;
    virtual sal_Int32 SAL_CALL getHandleByName( const ::rtl::OUString & rPropertyName ) = 0;
    virtual sal_Int32 SAL_CALL fillHandles(
        /*out*/ sal_Int32 * pHandles, const css::uno::Sequence< ::rtl::OUString > & rPropNames ) = 0;
};
 
class SAL_WARN_UNUSED CPPUHELPER_DLLPUBLIC OPropertyArrayHelper : public IPropertyArrayHelper
{
public:
    OPropertyArrayHelper(
        css::beans::Property *pProps,
        sal_Int32 nElements ,
        sal_Bool bSorted = true );
 
    OPropertyArrayHelper(
        const css::uno::Sequence< css::beans::Property > & aProps,
        sal_Bool bSorted = true );
 
    sal_Int32 SAL_CALL getCount() const;
    virtual sal_Bool SAL_CALL fillPropertyMembersByHandle(
        ::rtl::OUString * pPropName, sal_Int16 * pAttributes, sal_Int32 nHandle ) SAL_OVERRIDE;
    virtual css::uno::Sequence< css::beans::Property > SAL_CALL getProperties() SAL_OVERRIDE;
    virtual css::beans::Property SAL_CALL getPropertyByName(
        const ::rtl::OUString& rPropertyName ) SAL_OVERRIDE;
    virtual sal_Bool SAL_CALL hasPropertyByName(const ::rtl::OUString& rPropertyName) SAL_OVERRIDE;
    virtual sal_Int32 SAL_CALL getHandleByName( const ::rtl::OUString & rPropertyName ) SAL_OVERRIDE;
    virtual sal_Int32 SAL_CALL fillHandles(
        /*out*/sal_Int32 * pHandles, const css::uno::Sequence< ::rtl::OUString > & rPropNames ) SAL_OVERRIDE;
 
protected:
    void * m_pReserved;
 
private:
    void init( sal_Bool bSorted );
 
    css::uno::Sequence< css::beans::Property > aInfos;
 
    sal_Bool                    bRightOrdered;
};
 
 
// helper defines needed for an interface container with a 32 bit key values
 
struct equalInt32_Impl
{
    bool operator()(const sal_Int32 & i1 , const sal_Int32 & i2) const
        { return i1 == i2; }
};
 
struct hashInt32_Impl
{
    size_t operator()(const sal_Int32 & i) const
        { return i; }
};
 
class SAL_WARN_UNUSED CPPUHELPER_DLLPUBLIC OMultiTypeInterfaceContainerHelperInt32
{
public:
    // these are here to force memory de/allocation to sal lib.
    static void * SAL_CALL operator new( size_t nSize )
        { return ::rtl_allocateMemory( nSize ); }
    static void SAL_CALL operator delete( void * pMem )
        { ::rtl_freeMemory( pMem ); }
    static void * SAL_CALL operator new( size_t, void * pMem )
        { return pMem; }
    static void SAL_CALL operator delete( void *, void * )
        {}
 
    OMultiTypeInterfaceContainerHelperInt32( ::osl::Mutex & rMutex );
    ~OMultiTypeInterfaceContainerHelperInt32();
 
    css::uno::Sequence< sal_Int32 > SAL_CALL getContainedTypes() const;
 
    OInterfaceContainerHelper * SAL_CALL getContainer( const sal_Int32 & rKey ) const;
 
    sal_Int32 SAL_CALL addInterface(
        const sal_Int32 & rKey,
        const css::uno::Reference< css::uno::XInterface > & r );
 
    sal_Int32 SAL_CALL removeInterface(
        const sal_Int32 & rKey,
        const css::uno::Reference< css::uno::XInterface > & rxIFace );
 
    void SAL_CALL disposeAndClear( const css::lang::EventObject & rEvt );
    void SAL_CALL clear();
 
    typedef sal_Int32 keyType;
private:
    void *          m_pMap;
    ::osl::Mutex &  rMutex;
 
    OMultiTypeInterfaceContainerHelperInt32( const OMultiTypeInterfaceContainerHelperInt32 & ) SAL_DELETED_FUNCTION;
    OMultiTypeInterfaceContainerHelperInt32 & operator = ( const OMultiTypeInterfaceContainerHelperInt32 & )SAL_DELETED_FUNCTION;
};
 
 
class IEventNotificationHook
{
public:
    virtual void fireEvents(
        sal_Int32 * pnHandles,
        sal_Int32 nCount,
        sal_Bool bVetoable,
        bool bIgnoreRuntimeExceptionsWhileFiring) = 0;
 
#if !defined _MSC_VER // public -> protected changes mangled names there
protected:
#endif
    ~IEventNotificationHook() {}
        // avoid warnings about virtual members and non-virtual dtor
};
 
 
class CPPUHELPER_DLLPUBLIC OPropertySetHelper :
                           public css::beans::XMultiPropertySet,
                           public css::beans::XFastPropertySet,
                           public css::beans::XPropertySet
{
public:
    OPropertySetHelper( OBroadcastHelper & rBHelper );
 
    OPropertySetHelper(
        OBroadcastHelper & rBHelper, bool bIgnoreRuntimeExceptionsWhileFiring );
 
    OPropertySetHelper(
        OBroadcastHelper & rBHelper,
        IEventNotificationHook *i_pFireEvents,
        bool bIgnoreRuntimeExceptionsWhileFiring = false);
 
    virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) SAL_OVERRIDE;
 
    css::uno::Sequence< css::uno::Type > getTypes();
 
    void SAL_CALL disposing();
 
    virtual void SAL_CALL setPropertyValue( const ::rtl::OUString& rPropertyName, const css::uno::Any& aValue ) SAL_OVERRIDE;
    virtual css::uno::Any SAL_CALL getPropertyValue(const ::rtl::OUString& aPropertyName) SAL_OVERRIDE;
    virtual void SAL_CALL addPropertyChangeListener(
        const ::rtl::OUString& aPropertyName,
        const css::uno::Reference< css::beans::XPropertyChangeListener >& aListener) SAL_OVERRIDE;
 
    virtual void SAL_CALL removePropertyChangeListener(
        const ::rtl::OUString& aPropertyName,
        const css::uno::Reference < css::beans::XPropertyChangeListener >& aListener) SAL_OVERRIDE;
 
    virtual void SAL_CALL addVetoableChangeListener(
        const ::rtl::OUString& aPropertyName,
        const css::uno::Reference< css::beans::XVetoableChangeListener >& aListener) SAL_OVERRIDE;
 
    virtual void SAL_CALL removeVetoableChangeListener(
        const ::rtl::OUString& aPropertyName,
        const css::uno::Reference< css::beans::XVetoableChangeListener > & aListener ) SAL_OVERRIDE;
 
    virtual void SAL_CALL setFastPropertyValue( sal_Int32 nHandle, const css::uno::Any& rValue ) SAL_OVERRIDE;
 
    virtual css::uno::Any SAL_CALL getFastPropertyValue( sal_Int32 nHandle ) SAL_OVERRIDE;
 
    // XMultiPropertySet
    virtual void SAL_CALL setPropertyValues(
        const css::uno::Sequence< ::rtl::OUString >& PropertyNames,
        const css::uno::Sequence< css::uno::Any >& Values ) SAL_OVERRIDE;
 
    virtual css::uno::Sequence< css::uno::Any > SAL_CALL getPropertyValues(
        const css::uno::Sequence< ::rtl::OUString >& PropertyNames ) SAL_OVERRIDE;
 
    virtual void SAL_CALL addPropertiesChangeListener(
        const css::uno::Sequence< ::rtl::OUString >& PropertyNames,
        const css::uno::Reference< css::beans::XPropertiesChangeListener >& Listener ) SAL_OVERRIDE;
 
    virtual void SAL_CALL removePropertiesChangeListener(
        const css::uno::Reference< css::beans::XPropertiesChangeListener >& Listener ) SAL_OVERRIDE;
 
    virtual void SAL_CALL firePropertiesChangeEvent(
        const css::uno::Sequence< ::rtl::OUString >& PropertyNames,
        const css::uno::Reference< css::beans::XPropertiesChangeListener > & Listener ) SAL_OVERRIDE;
 
    static css::uno::Reference < css::beans::XPropertySetInfo > SAL_CALL
        createPropertySetInfo( IPropertyArrayHelper & rProperties );
protected:
    void SAL_CALL fire(
        sal_Int32 * pnHandles,
        const css::uno::Any * pNewValues,
        const css::uno::Any * pOldValues,
        sal_Int32 nCount,
        sal_Bool bVetoable );
 
    void SAL_CALL setFastPropertyValues(
        sal_Int32 nSeqLen,
        sal_Int32 * pHandles,
        const css::uno::Any * pValues,
        sal_Int32 nHitCount );
 
    virtual IPropertyArrayHelper & SAL_CALL getInfoHelper() = 0;
 
    virtual sal_Bool SAL_CALL convertFastPropertyValue(
        css::uno::Any & rConvertedValue,
        css::uno::Any & rOldValue,
        sal_Int32 nHandle,
        const css::uno::Any& rValue ) = 0;
 
    virtual void SAL_CALL setFastPropertyValue_NoBroadcast(
        sal_Int32 nHandle,
        const css::uno::Any& rValue ) = 0;
    virtual void SAL_CALL getFastPropertyValue(
        css::uno::Any& rValue,
        sal_Int32 nHandle ) const = 0;
 
    void    setDependentFastPropertyValue(
                sal_Int32 i_handle,
                const css::uno::Any& i_value
            );
 
    OBroadcastHelper    &rBHelper;
    OMultiTypeInterfaceContainerHelperInt32  aBoundLC;
    OMultiTypeInterfaceContainerHelperInt32 aVetoableLC;
 
    class Impl;
 
    Impl * const m_pReserved;
 
private:
    OPropertySetHelper( const OPropertySetHelper & ) SAL_DELETED_FUNCTION;
    OPropertySetHelper &    operator = ( const OPropertySetHelper & )
        SAL_DELETED_FUNCTION;
 
    void    impl_fireAll(
                sal_Int32* i_handles,
                const css::uno::Any * i_newValues,
                const css::uno::Any * i_oldValues,
                sal_Int32 i_count
            );
 
#if defined _MSC_VER // public -> protected changes mangled names there
public:
#else
protected:
#endif
    ~OPropertySetHelper();
};
 
class CPPUHELPER_DLLPUBLIC OPropertySetHelper2 : public OPropertySetHelper,
                            public css::beans::XPropertySetOption
{
public:
    explicit OPropertySetHelper2(
        OBroadcastHelper & rBHelper,
        IEventNotificationHook *i_pFireEvents = NULL,
        bool bIgnoreRuntimeExceptionsWhileFiring = false);
 
    // XInterface
    virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) SAL_OVERRIDE;
 
    // XPropertySetOption
    virtual void SAL_CALL enableChangeListenerNotification( sal_Bool bEnable ) SAL_OVERRIDE;
 
 
private:
    OPropertySetHelper2( const OPropertySetHelper2 & ) SAL_DELETED_FUNCTION;
    OPropertySetHelper2 &    operator = ( const OPropertySetHelper2 & )
        SAL_DELETED_FUNCTION;
 
#if defined _MSC_VER // public -> protected changes mangled names there
public:
#else
protected:
#endif
// Suppress warning about virtual functions but non-virtual destructor:
    virtual ~OPropertySetHelper2();
};
 
} // end namespace cppuhelper
#endif
 
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */