libreoffice/extensions/source/resource/resource.cxx

/*************************************************************************
 *
 *  $RCSfile: resource.cxx,v $
 *
 *  $Revision: 1.3 $
 *
 *  last change: $Author: pl $ $Date: 2001-05-14 09:38:52 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses
 *
 *         - GNU Lesser General Public License Version 2.1
 *         - Sun Industry Standards Source License Version 1.1
 *
 *  Sun Microsystems Inc., October, 2000
 *
 *  GNU Lesser General Public License Version 2.1
 *  =============================================
 *  Copyright 2000 by Sun Microsystems, Inc.
 *  901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *
 *  Sun Industry Standards Source License Version 1.1
 *  =================================================
 *  The contents of this file are subject to the Sun Industry Standards
 *  Source License Version 1.1 (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.openoffice.org/license.html.
 *
 *  Software provided under this License is provided on an "AS IS" basis,
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 *  See the License for the specific provisions governing your rights and
 *  obligations concerning the Software.
 *
 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 *
 *  Copyright: 2000 by Sun Microsystems, Inc.
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): _______________________________________
 *
 *
 ************************************************************************/

#include <vos/mutex.hxx>
//#include <usr/ustring.hxx>
//#include <usr/factoryhlp.hxx>
//#include <usr/weak.hxx>

//#include <smart/com/sun/star/lang/XServiceInfo.hxx>
//#include <smart/com/sun/star/script/XInvocation.hxx>
//#include <smart/com/sun/star/script/XTypeConverter.hxx>
//#include <smart/com/sun/star/beans/XExactName.hxx>

// Changes from ...Ref to Reference< ... >, USR_QUERY -> UNO_QUERY, THROWS( ... ) -> throw( ... ),
// UsrAny -> Any, (BOOL -> sal_BOOL, ...), OUString -> OUString, put SAL_CALL infront of each interface method,
// UsrSystemException -> RuntimeException, const is removed from each interface method
// are done without comment
/**** NEW ****/
#include <uno/lbnames.h>            // CPPU_CURRENT_LANGUAGE_BINDING_NAME macro, which specify the environment type
#include <cppuhelper/factory.hxx>   // helper for factories
#include <cppuhelper/implbase3.hxx> // helper for implementations

#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/script/XInvocation.hpp>
#include <com/sun/star/script/XTypeConverter.hpp>
#include <com/sun/star/reflection/InvocationTargetException.hpp>
#include <com/sun/star/beans/XExactName.hpp>

/**** END NEW ****/

#include <tools/resmgr.hxx>
#include <tools/rcid.h>
#include <vcl/svapp.hxx>

#include <rtl/ustring.hxx>

#ifndef _VOS_NO_NAMESPACE
using namespace vos;
//using namespace usr;
using namespace rtl;
/**** NEW ****/
using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
using namespace com::sun::star::registry;
using namespace com::sun::star::script;
using namespace com::sun::star::beans;
using namespace com::sun::star::reflection;
/**** END NEW ****/
#endif


//------------------------------------------------------------------------
//------------------------------------------------------------------------
//------------------------------------------------------------------------
//class ResourceService : public XInvocation
//                      , public XExactName
//                      , public XServiceInfo
//                      , public OWeakObject

/**** NEW ****/
class ResourceService : public cppu::WeakImplHelper3< XInvocation, XExactName, XServiceInfo >
/**** END NEW ****/
{
public:
                                ResourceService( const Reference< XMultiServiceFactory > & );
                                ~ResourceService();

    // XInterface
    //BOOL                      queryInterface( Uik aUik, Reference< XInterface > & rOut );
    //void                      acquire()                        { OWeakObject::acquire(); }
    //void                      release()                        { OWeakObject::release(); }
    //void*                         getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }

    // XIdlClassProvider
    //Sequence< Reference< XIdlClass > >    getIdlClasses(void);

    // XServiceInfo
    OUString SAL_CALL           getImplementationName() throw();
    BOOL     SAL_CALL           supportsService(const OUString& ServiceName) throw();
    Sequence< OUString > SAL_CALL   getSupportedServiceNames(void) throw();

    static Sequence< OUString >  getSupportedServiceNames_Static(void) throw();
    static OUString             getImplementationName_Static() throw()
                                {
                                    return OUString::createFromAscii("com.sun.star.comp.extensions.ResourceService");
                                }

    // XExactName
    OUString  SAL_CALL          getExactName( const OUString & ApproximateName );

    // XInvokation
    Reference< XIntrospectionAccess >  SAL_CALL getIntrospection(void)  throw(RuntimeException);
    Any  SAL_CALL               invoke(const OUString& FunctionName, const Sequence< Any >& Params, Sequence< INT16 >& OutParamIndex, Sequence< Any >& OutParam) throw(IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException);
    void  SAL_CALL              setValue(const OUString& PropertyName, const Any& Value) throw(UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException);
    Any  SAL_CALL               getValue(const OUString& PropertyName) throw(UnknownPropertyException, RuntimeException);
    BOOL  SAL_CALL              hasMethod(const OUString& Name)  throw(RuntimeException);
    BOOL  SAL_CALL              hasProperty(const OUString& Name)  throw(RuntimeException);
private:
    Reference< XTypeConverter >         getTypeConverter() const;
    Reference< XInvocation >            getDefaultInvocation() const;
    //Reference< XIdlClass >            getStaticIdlClass();

    Reference< XMultiServiceFactory >   xSMgr;
    Reference< XInvocation >            xDefaultInvocation;
    Reference< XTypeConverter >         xTypeConverter;
    OUString                                aFileName;
    ResMgr *                            pResMgr;
};


ResourceService::ResourceService( const Reference< XMultiServiceFactory > & rSMgr )
    : xSMgr( rSMgr )
    , pResMgr( NULL )
{
}

//-----------------------------------------------------------------------------
ResourceService::~ResourceService()
{
    delete pResMgr;
}

//-----------------------------------------------------------------------------
Reference< XInterface > SAL_CALL ResourceService_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr ) throw(Exception)
{
    Reference< XInterface > xService = (cppu::OWeakObject*)new ResourceService( rSMgr );
    return xService;
}

//*************************************************************************
// DLLImplementationLoader::getStaticIdlClass()
//
//Reference< XIdlClass > ResourceService::getStaticIdlClass()
//{
//  // Global Method, must be guarded (multithreading)
//  OGuard aGuard( OMutex::getGlobalMutex() );
//  {
//      // use the standard class implementation of the usr library
//      static Reference< XIdlClass > xClass =
//      createStandardClass( getImplementationName_Static(),
//                      OWeakObject::getStaticIdlClass(), 2,
//                      XInvocation_Reference< get >lection(),
//                      XExactName_getReflection(),
//                      XServiceInfo_getReflection()
//                      );
//      return xClass;
//  }
//}

// Methoden von XInterface
//BOOL ResourceService::queryInterface( Uik aUik, Reference< XInterface > & rOut )
//{
//  if( aUik == XInvocation::getSmartUik() )
//      rOut = (XInvocation*)this;
//  else if( aUik == XExactName::getSmartUik() )
//      rOut = (XExactName*)this;
//  else if( aUik == XServiceInfo::getSmartUik() )
//      rOut = (XServiceInfo *)this;
//  else
//      OWeakObject::queryInterface( aUik, rOut );
//  return rOut.is();
//}
//
// XIdlClassProvider
//Sequence< XIdlClassRef > ResourceService::getIdlClasses()
//{
//  XIdlClassRef x = getStaticIdlClass();
//  return Sequence< XIdlClassRef >( &x, 1 );
//}


// XServiceInfo
OUString ResourceService::getImplementationName() throw()
{
    return getImplementationName_Static();
}

// XServiceInfo
BOOL SAL_CALL ResourceService::supportsService(const OUString& ServiceName) throw()
{
    Sequence< OUString > aSNL = getSupportedServiceNames();
    const OUString * pArray = aSNL.getConstArray();
    for( INT32 i = 0; i < aSNL.getLength(); i++ )
        if( pArray[i] == ServiceName )
            return TRUE;
    return FALSE;
}

// XServiceInfo
Sequence< OUString > SAL_CALL ResourceService::getSupportedServiceNames(void) throw()
{
    return getSupportedServiceNames_Static();
}

// ResourceService
Sequence< OUString > ResourceService::getSupportedServiceNames_Static(void) throw()
{
    Sequence< OUString > aSNS( 1 );
    aSNS.getArray()[0] = OUString::createFromAscii("com.sun.star.resource.VclStringResourceLoader");
    return aSNS;
}

// ResourceService
Reference< XTypeConverter > ResourceService::getTypeConverter() const
{
    OGuard aGuard( Application::GetSolarMutex() );
    if( xSMgr.is() )
    {
        Reference< XTypeConverter > xConv( xSMgr->createInstance( OUString::createFromAscii("com.sun.star.script.Converter" )), UNO_QUERY );
        ((ResourceService*)this)->xTypeConverter = xConv;
    }
    return xTypeConverter;
}

// ResourceService
Reference< XInvocation > ResourceService::getDefaultInvocation() const
{
    OGuard aGuard( Application::GetSolarMutex() );
    /* f<>hrt zur Zeit noch zu einer rekursion
    if( xSMgr.is() )
    {
        Reference< XSingleServiceFactory > xFact( xSMgr->createInstance( OUString::createFromAscii("com.sun.star.script.Invocation") ), UNO_QUERY );
        if( xFact.is() )
        {
            Sequence< Any > aArgs( 1 );
            Reference< XInterface > xThis( *this );
            aArgs.getArray()[0].set( &xThis, XInterface_Reference< get >lection() );
            Reference< XInvokation > xI( xFact->createInstanceWithArguments( aArgs ), UNO_QUERY );
            ((ResourceService*)this)->xDefaultInvocation = xI;
        }
    }
    */
    return xDefaultInvocation;
}

// XExactName
OUString    SAL_CALL ResourceService::getExactName( const OUString & ApproximateName )
{
    OUString aName( ApproximateName );
    aName = aName.toAsciiLowerCase();
    if( aName == OUString::createFromAscii("filename") )
        return OUString::createFromAscii("FileName");
    else if( aName == OUString::createFromAscii("getstring" ))
        return OUString::createFromAscii("getString");
    else if( aName == OUString::createFromAscii("hasstring") )
        return OUString::createFromAscii("hasString");
    Reference< XExactName > xEN( getDefaultInvocation(), UNO_QUERY );
    if( xEN.is() )
        return xEN->getExactName( ApproximateName );
    return OUString();
}

// XInvokation
Reference< XIntrospectionAccess > SAL_CALL ResourceService::getIntrospection(void)
    throw(RuntimeException)
{
    Reference< XInvocation > xI = getDefaultInvocation();
    if( xI.is() )
        return xI->getIntrospection();
    return Reference< XIntrospectionAccess >();
}

// XInvokation
Any SAL_CALL ResourceService::invoke
(
    const OUString& FunctionName,
    const Sequence< Any >& Params,
    Sequence< INT16 >& OutParamIndex,
    Sequence< Any >& OutParam
)
    throw(IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException)
{
    if( FunctionName == OUString::createFromAscii("getString") || FunctionName == OUString::createFromAscii("hasString" ))
    {
        if( Params.getLength() != 1 )
            throw IllegalArgumentException();
        INT32 nId;
        /**** NEW ****/
        if( !(Params.getConstArray()[0] >>= nId) )
        /**** END NEW ****/
        //if( Params.getConstArray()[0].getReflection()->getTypeClass() == TypeClass_LONG )
        //  nId = Params.getConstArray()[0].getINT32();
        //else
        {
            Reference< XTypeConverter > xC = getTypeConverter();
            if( xC.is() )
            {
                /**** NEW ****/
                xC->convertToSimpleType( Params.getConstArray()[0], TypeClass_LONG ) >>= nId;
                /**** END NEW ****/
                //nId = xC->convertToSimpleType( Params.getConstArray()[0], TypeClass_LONG ).getINT32();
            }
            else
                throw CannotConvertException();
        }
        if( nId > 0xFFFF || nId < 0 )
            throw IllegalArgumentException();

        OGuard aGuard( Application::GetSolarMutex() );
        if( FunctionName == OUString::createFromAscii("getString" ))
        {
            if( !pResMgr )
                throw IllegalArgumentException();
            ResId aId( (USHORT)nId, pResMgr );
            aId.SetRT( RSC_STRING );
            if( pResMgr->IsAvailable( aId ) )
            {
                String aStr( aId );
        /**** NEW ****/
//              return makeAny( StringToOUString( aStr, CHARSET_SYSTEM ) );
                return makeAny( OUString( aStr ) );
        /**** END NEW ****/
                //return Any( StringToOWString( aStr, CHARSET_SYSTEM ) );
            }
            else
                throw IllegalArgumentException();
        }
        else //if( FunctionName == OUString::createFromAscii("hasString") )
        {
            sal_Bool bRet = sal_False;
            if( pResMgr )
            {
                ResId aId( (USHORT)nId, pResMgr );
                aId.SetRT( RSC_STRING );
                bRet = pResMgr->IsAvailable( aId );
            }
            //return UsrAny( bRet );
            /**** NEW ****/
            return Any( &bRet, getBooleanCppuType() );
            /**** END NEW ****/
        }
    }
    else
    {
        Reference< XInvocation > xI = getDefaultInvocation();
        if( xI.is() )
            return xI->invoke( FunctionName, Params, OutParamIndex, OutParam );
        else
            throw IllegalArgumentException();
    }
    return Any();
}

// XInvokation
void SAL_CALL ResourceService::setValue(const OUString& PropertyName, const Any& Value)
    throw(UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException)
{
    if( PropertyName == OUString::createFromAscii("FileName") )
    {
        OUString aName;
        //if( Value.getReflection()->getTypeClass() == TypeClass_STRING )
        //  aName = Value.getString();
        //else
        /**** NEW ****/
        if( !(Value >>= aName) )
        /**** END NEW ****/
        {
            Reference< XTypeConverter > xC = getTypeConverter();
            if( xC.is() )
                xC->convertToSimpleType( Value, TypeClass_STRING ) >>= aName;
                //aName = xC->convertToSimpleType( Value, TypeClass_STRING ).getString();
            else
                throw CannotConvertException();
        }

        OGuard aGuard( Application::GetSolarMutex() );
        aName = aName + OUString( OUString::valueOf( (INT32)SUPD ).getStr() );
//      ResMgr * pRM = ResMgr::CreateResMgr( OUStringToString( aName, CHARSET_SYSTEM ) );
        String aTmpString( aName );
        ByteString a( aTmpString, gsl_getSystemTextEncoding() );
        ResMgr * pRM = ResMgr::CreateResMgr( a.GetBuffer() );
        if( !pRM )
            throw InvocationTargetException();
        if( pResMgr )
            delete pResMgr;
        pResMgr = pRM;
        aFileName = aName;
    }
    else
    {
        Reference< XInvocation > xI = getDefaultInvocation();
        if( xI.is() )
            xI->setValue( PropertyName, Value );
        else
            throw UnknownPropertyException();
    }
}

// XInvokation
Any SAL_CALL ResourceService::getValue(const OUString& PropertyName)
    throw(UnknownPropertyException, RuntimeException)
{
    OGuard aGuard( Application::GetSolarMutex() );
    if( PropertyName == OUString::createFromAscii("FileName" ))
        return makeAny( aFileName );
    else
    {
        Reference< XInvocation > xI = getDefaultInvocation();
        if( xI.is() )
            return xI->getValue( PropertyName );
        else
            throw UnknownPropertyException();
    }
    return Any();
}

// XInvokation
BOOL SAL_CALL ResourceService::hasMethod(const OUString& Name)
    throw(RuntimeException)
{
    if( Name == OUString::createFromAscii("getString") || Name == OUString::createFromAscii("hasString") )
        return TRUE;
    else
    {
        Reference< XInvocation > xI = getDefaultInvocation();
        if( xI.is() )
            return xI->hasMethod( Name );
        else
            return FALSE;
    }
}

// XInvokation
BOOL SAL_CALL ResourceService::hasProperty(const OUString& Name)
    throw(RuntimeException)
{
    if( Name == OUString::createFromAscii("FileName") )
        return TRUE;
    else
    {
        Reference< XInvocation > xI = getDefaultInvocation();
        if( xI.is() )
            return xI->hasProperty( Name );
        else
            return FALSE;
    }
}


extern "C" {

// NEW: return the environment type name of the c++ compiler
void SAL_CALL component_getImplementationEnvironment(
    const sal_Char ** ppEnvTypeName, uno_Environment ** ppEnv )
{
    *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
}

//BOOL EXTERN_SERVICE_CALLTYPE exService_writeRegEntry(
//        const UNO_INTERFACE(XRegistryKey)* xUnoKey)
sal_Bool SAL_CALL component_writeInfo( void * /*pServiceManager*/, XRegistryKey * pRegistryKey )
{
    //XRegistryKeyRef   pRegistryKey;
    //uno2smart(pRegistryKey, *xUnoKey);
    /**** NEW ****/
    try
    {
        Reference< XRegistryKey > xNewKey =
    /**** END NEW ****/
            pRegistryKey->createKey(
            OUString::createFromAscii( "/" ) + ResourceService::getImplementationName_Static() + OUString::createFromAscii( "/UNO/SERVICES" ) );
        Sequence< OUString > aServices = ResourceService::getSupportedServiceNames_Static();
        for( INT32 i = 0; i < aServices.getLength(); i++ )
            xNewKey->createKey( aServices.getConstArray()[i]);

        return sal_True;
    /**** NEW ****/
    }
    catch (Exception &)
    {
        // not allowed to throw an exception over the c function.
        //OSL_ENSURE( sal_False, "Exception cannot register component!" );
        return sal_False;
    }
    /**** END NEW ****/

}

//UNO_INTERFACE(XInterface) EXTERN_SERVICE_CALLTYPE exService_getFactory
//(
//  const sal_Unicode* pImplName,
//  const UNO_INTERFACE(XMultiServiceFactory)* pServiceManager,
//  const UNO_INTERFACE(XRegistryKey)*
//)
void * SAL_CALL component_getFactory(
    const sal_Char * pImplName, XMultiServiceFactory * pServiceManager, void * /*pRegistryKey*/ )
{
    //UNO_INTERFACE(XInterface) xUnoRet = {0, 0};
    //XInterfaceRef             xRet;
    //XMultiServiceFactoryRef xSMgr;
    //OUString                  aImplementationName(pImplName);
    //uno2smart(xSMgr, *xUnoFact);
    //if (OUString(pImplName) == ResourceService::getpImplName_Static() )
    //{
    //  xRet = createSingleFactory( pServiceManager, pImplName,
    //                              ResourceService_CreateInstance,
    //                              ResourceService::getSupportedServiceNames_Static() );
    //}
    //
    //if (xRet.is())
    //{
    //  smart2uno(xRet, xUnoRet);
    //}
    //return xUnoRet;

    /**** NEW ****/
    void * pRet = 0;
    if (!ResourceService::getImplementationName_Static().compareToAscii( pImplName ) )
    {
        // create the factory
        Reference< XSingleServiceFactory > xFactory =
            cppu::createSingleFactory(
                pServiceManager, ResourceService::getImplementationName_Static(),
                ResourceService_CreateInstance,
                ResourceService::getSupportedServiceNames_Static() );
        // acquire, because we return an interface pointer instead of a reference
        xFactory->acquire();
        pRet = xFactory.get();
    }
    return pRet;
    /**** END NEW ****/
}

}