fapihelper.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 .
 */

#pragma once

#include <com/sun/star/uno/Any.hxx>
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/uno/Sequence.hxx>
#include <osl/diagnose.h>
#include <tools/color.hxx>
#include "ftools.hxx"

namespace com::sun::star {
    namespace lang { class XMultiServiceFactory; }
}

namespace com::sun::star::beans { struct NamedValue; }
namespace com::sun::star::beans { class XPropertySet; }
namespace com::sun::star::beans { class XMultiPropertySet; }

namespace comphelper { class IDocPasswordVerifier; }

// Static helper functions ====================================================

class SfxMedium;
class SfxObjectShell;

class ScfApiHelper
{
public:
    template< typename Type >
    static css::uno::Sequence< Type >
                            VectorToSequence( const ::std::vector< Type >& rVector );

    static OUString GetServiceName( const css::uno::Reference< css::uno::XInterface >& xInt );

    static css::uno::Reference< css::lang::XMultiServiceFactory > GetServiceFactory( const SfxObjectShell* pShell );

    static css::uno::Reference< css::uno::XInterface > CreateInstance(
                            const css::uno::Reference< css::lang::XMultiServiceFactory >& xFactory,
                            const OUString& rServiceName );

    static css::uno::Reference< css::uno::XInterface > CreateInstance(
                            const SfxObjectShell* pShell,
                            const OUString& rServiceName );

    static css::uno::Reference< css::uno::XInterface > CreateInstance( const OUString& rServiceName );

    static css::uno::Sequence< css::beans::NamedValue > QueryEncryptionDataForMedium( SfxMedium& rMedium,
                            ::comphelper::IDocPasswordVerifier& rVerifier,
                            const ::std::vector< OUString >* pDefaultPasswords );
};

template< typename Type >
css::uno::Sequence< Type > ScfApiHelper::VectorToSequence( const ::std::vector< Type >& rVector )
{
    OSL_ENSURE( !rVector.empty(), "ScfApiHelper::VectorToSequence - vector is empty" );
    return css::uno::Sequence<Type>(rVector.data(), static_cast< sal_Int32 >(rVector.size()));
}

// Property sets ==============================================================

class ScfPropertySet
{
public:
    explicit     ScfPropertySet() {}
    explicit     ScfPropertySet( const css::uno::Reference< css::beans::XPropertySet > & xPropSet ) { Set( xPropSet ); }
    template< typename InterfaceType >
    explicit     ScfPropertySet( const css::uno::Reference< InterfaceType >& xInterface ) { Set( xInterface ); }

                        ~ScfPropertySet();
    //TODO:
    ScfPropertySet(ScfPropertySet const &) = default;
    ScfPropertySet(ScfPropertySet &&) = default;
    ScfPropertySet & operator =(ScfPropertySet const &) = default;
    ScfPropertySet & operator =(ScfPropertySet &&) = default;

    void                Set( css::uno::Reference< css::beans::XPropertySet > const & xPropSet );
    template< typename InterfaceType >
    void         Set( css::uno::Reference< InterfaceType > xInterface )
                            { Set( css::uno::Reference< css::beans::XPropertySet >( xInterface, css::uno::UNO_QUERY ) ); }

    bool         Is() const { return mxPropSet.is(); }

    const css::uno::Reference< css::beans::XPropertySet >& GetApiPropertySet() const { return mxPropSet; }

    OUString     GetServiceName() const;

    // Get properties ---------------------------------------------------------

    bool                HasProperty( const OUString& rPropName ) const;

    bool                GetAnyProperty( css::uno::Any& rValue, const OUString& rPropName ) const;

    template< typename Type >
    bool         GetProperty( Type& rValue, const OUString& rPropName ) const
                            { css::uno::Any aAny; return GetAnyProperty( aAny, rPropName ) && (aAny >>= rValue); }

    bool                GetBoolProperty( const OUString& rPropName ) const;

    OUString       GetStringProperty( const OUString& rPropName ) const;

    bool                GetColorProperty( Color& rColor, const OUString& rPropName ) const;

    void                GetProperties( css::uno::Sequence< css::uno::Any >& rValues, const css::uno::Sequence< OUString >& rPropNames ) const;

    // Set properties ---------------------------------------------------------

    void                SetAnyProperty( const OUString& rPropName, const css::uno::Any& rValue );

    template< typename Type >
    void         SetProperty( const OUString& rPropName, const Type& rValue )
                            { SetAnyProperty( rPropName, css::uno::Any( rValue ) ); }

    void         SetBoolProperty( const OUString& rPropName, bool bValue )
                            { SetAnyProperty( rPropName, css::uno::Any( bValue ) ); }

    void         SetStringProperty( const OUString& rPropName, const OUString& rValue )
                            { SetProperty( rPropName, rValue ); }

    void         SetColorProperty( const OUString& rPropName, const Color& rColor )
                            { SetProperty( rPropName, sal_Int32( rColor ) ); }

    void                SetProperties( const css::uno::Sequence< OUString > & rPropNames, const css::uno::Sequence< css::uno::Any >& rValues );

private:
    css::uno::Reference< css::beans::XPropertySet >       mxPropSet;          
    css::uno::Reference< css::beans::XMultiPropertySet >  mxMultiPropSet;     
};

class ScfPropSetHelper
{
public:
    explicit            ScfPropSetHelper( const char* const* ppcPropNames );

    // read properties --------------------------------------------------------

    void                ReadFromPropertySet( const ScfPropertySet& rPropSet );

    template< typename Type >
    void                ReadValue( Type& rValue );
    void                ReadValue( css::uno::Any& rAny );
    void                ReadValue( Color& rColor );
    void                ReadValue( bool& rbValue );

    // write properties -------------------------------------------------------

    void                InitializeWrite();

    template< typename Type >
    void                WriteValue( const Type& rValue );
    void                WriteValue( const css::uno::Any& rAny );
    void         WriteValue( const Color& rColor )
                            { WriteValue( sal_Int32( rColor ) ); }
    void                WriteValue( bool rbValue );

    void                WriteToPropertySet( ScfPropertySet& rPropSet ) const;

private:
    css::uno::Any*             GetNextAny();

private:
    css::uno::Sequence< OUString >       maNameSeq;          
    css::uno::Sequence< css::uno::Any >  maValueSeq;         
    ScfInt32Vec         maNameOrder;        
    size_t              mnNextIdx;          
};

template< typename Type >
void ScfPropSetHelper::ReadValue( Type& rValue )
{
    css::uno::Any* pAny = GetNextAny();
    if (pAny)
        *pAny >>= rValue;
}

template< typename Type >
void ScfPropSetHelper::WriteValue( const Type& rValue )
{
    css::uno::Any* pAny = GetNextAny();
    if( pAny )
        *pAny <<= rValue;
}

template< typename Type >
ScfPropSetHelper& operator>>( ScfPropSetHelper& rPropSetHelper, Type& rValue )
{
    rPropSetHelper.ReadValue( rValue );
    return rPropSetHelper;
}

template< typename Type >
ScfPropSetHelper& operator<<( ScfPropSetHelper& rPropSetHelper, const Type& rValue )
{
    rPropSetHelper.WriteValue( rValue );
    return rPropSetHelper;
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */