/libreoffice-3.6.0.2/scripting/source/stringresource/stringresource.cxx

Large files files are truncated, but you can click here to view the full file

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org 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 version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

#include "stringresource.hxx"
#include <com/sun/star/io/XTextInputStream.hpp>
#include <com/sun/star/io/XTextOutputStream.hpp>
#include <com/sun/star/io/XActiveDataSink.hpp>
#include <com/sun/star/io/XActiveDataSource.hpp>
#include <com/sun/star/io/XStream.hpp>
#include <com/sun/star/io/XSeekable.hpp>
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/lang/XMultiComponentFactory.hpp>
#include <cppuhelper/implementationentry.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/container/XNameAccess.hpp>


#include <rtl/ustrbuf.hxx>
#include <rtl/strbuf.hxx>
#include <tools/urlobj.hxx>

using namespace ::com::sun::star;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::ucb;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::embed;
using namespace ::com::sun::star::container;


//.........................................................................
namespace stringresource
{
//.........................................................................

// =============================================================================
// mutex
// =============================================================================

::osl::Mutex& getMutex()
{
    static ::osl::Mutex* s_pMutex = 0;
    if ( !s_pMutex )
    {
        ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
        if ( !s_pMutex )
        {
            static ::osl::Mutex s_aMutex;
            s_pMutex = &s_aMutex;
        }
    }
    return *s_pMutex;
}


// =============================================================================
// StringResourceImpl
// =============================================================================

// component operations
static Sequence< ::rtl::OUString > getSupportedServiceNames_StringResourceImpl()
{
    Sequence< ::rtl::OUString > names(1);
    names[0] = ::rtl::OUString( "com.sun.star.resource.StringResource" );
    return names;
}

static ::rtl::OUString getImplementationName_StringResourceImpl()
{
    return ::rtl::OUString( "com.sun.star.comp.scripting.StringResource" );
}

static Reference< XInterface > SAL_CALL create_StringResourceImpl(
    Reference< XComponentContext > const & xContext )
    SAL_THROW(())
{
    return static_cast< ::cppu::OWeakObject * >( new StringResourcePersistenceImpl( xContext ) );
}


// =============================================================================

StringResourceImpl::StringResourceImpl( const Reference< XComponentContext >& rxContext )
    : m_xContext( rxContext )
    , m_pCurrentLocaleItem( NULL )
    , m_pDefaultLocaleItem( NULL )
    , m_bDefaultModified( false )
    , m_aListenerContainer( getMutex() )
    , m_bModified( false )
    , m_bReadOnly( false )
    , m_nNextUniqueNumericId( UNIQUE_NUMBER_NEEDS_INITIALISATION )
{
}

// =============================================================================

StringResourceImpl::~StringResourceImpl()
{
    for( LocaleItemVectorIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); ++it )
    {
        LocaleItem* pLocaleItem = *it;
        delete pLocaleItem;
    }

    for( LocaleItemVectorIt it = m_aDeletedLocaleItemVector.begin(); it != m_aDeletedLocaleItemVector.end(); ++it )
    {
        LocaleItem* pLocaleItem = *it;
        delete pLocaleItem;
    }
}


// =============================================================================
// XServiceInfo

::rtl::OUString StringResourceImpl::getImplementationName(  ) throw (RuntimeException)
{
    return getImplementationName_StringResourceImpl();
}

sal_Bool StringResourceImpl::supportsService( const ::rtl::OUString& rServiceName ) throw (RuntimeException)
{
    Sequence< ::rtl::OUString > aNames( getSupportedServiceNames() );
    const ::rtl::OUString* pNames = aNames.getConstArray();
    const ::rtl::OUString* pEnd = pNames + aNames.getLength();
    for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames )
        ;

    return pNames != pEnd;
}

Sequence< ::rtl::OUString > StringResourceImpl::getSupportedServiceNames(  ) throw (RuntimeException)
{
    return getSupportedServiceNames_StringResourceImpl();
}


// =============================================================================
// XModifyBroadcaster

void StringResourceImpl::addModifyListener( const Reference< XModifyListener >& aListener )
    throw (RuntimeException)
{
    if( !aListener.is() )
        throw RuntimeException();

    ::osl::MutexGuard aGuard( getMutex() );
    Reference< XInterface > xIface( aListener, UNO_QUERY );
    m_aListenerContainer.addInterface( xIface );
}

void StringResourceImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
    throw (RuntimeException)
{
    if( !aListener.is() )
        throw RuntimeException();

    ::osl::MutexGuard aGuard( getMutex() );
    Reference< XInterface > xIface( aListener, UNO_QUERY );
    m_aListenerContainer.removeInterface( xIface );
}


// =============================================================================
// XStringResourceResolver

::rtl::OUString StringResourceImpl::implResolveString
    ( const ::rtl::OUString& ResourceID, LocaleItem* pLocaleItem )
        throw (::com::sun::star::resource::MissingResourceException)
{
    ::rtl::OUString aRetStr;
    bool bSuccess = false;
    if( pLocaleItem != NULL && loadLocale( pLocaleItem ) )
    {
        IdToStringMap::iterator it = pLocaleItem->m_aIdToStringMap.find( ResourceID );
        if( !( it == pLocaleItem->m_aIdToStringMap.end() ) )
        {
            aRetStr = (*it).second;
            bSuccess = true;
        }
    }
    if( !bSuccess )
    {
        ::rtl::OUString errorMsg("StringResourceImpl: No entry for ResourceID: ");
        errorMsg.concat( ResourceID );
        throw ::com::sun::star::resource::MissingResourceException( errorMsg, Reference< XInterface >() );
    }
    return aRetStr;
}

::rtl::OUString StringResourceImpl::resolveString( const ::rtl::OUString& ResourceID )
    throw (::com::sun::star::resource::MissingResourceException, RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    return implResolveString( ResourceID, m_pCurrentLocaleItem );
}

::rtl::OUString StringResourceImpl::resolveStringForLocale( const ::rtl::OUString& ResourceID, const Locale& locale )
    throw ( ::com::sun::star::resource::MissingResourceException, RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
    return implResolveString( ResourceID, pLocaleItem );
}

sal_Bool StringResourceImpl::implHasEntryForId( const ::rtl::OUString& ResourceID, LocaleItem* pLocaleItem )
{
    bool bSuccess = false;
    if( pLocaleItem != NULL && loadLocale( pLocaleItem ) )
    {
        IdToStringMap::iterator it = pLocaleItem->m_aIdToStringMap.find( ResourceID );
        if( !( it == pLocaleItem->m_aIdToStringMap.end() ) )
            bSuccess = true;
    }
    return bSuccess;
}

sal_Bool StringResourceImpl::hasEntryForId( const ::rtl::OUString& ResourceID )
    throw (RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    return implHasEntryForId( ResourceID, m_pCurrentLocaleItem );
}

sal_Bool StringResourceImpl::hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID,
    const Locale& locale )
        throw (RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
    return implHasEntryForId( ResourceID, pLocaleItem );
}

Sequence< ::rtl::OUString > StringResourceImpl::implGetResourceIDs( LocaleItem* pLocaleItem )
{
    Sequence< ::rtl::OUString > aIDSeq( 0 );
    if( pLocaleItem && loadLocale( pLocaleItem ) )
    {
        const IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
        sal_Int32 nResourceIDCount = rHashMap.size();
        aIDSeq.realloc( nResourceIDCount );
        ::rtl::OUString* pStrings = aIDSeq.getArray();

        IdToStringMap::const_iterator it;
        int iTarget = 0;
        for( it = rHashMap.begin(); it != rHashMap.end(); ++it )
        {
            ::rtl::OUString aStr = (*it).first;
            pStrings[iTarget] = aStr;
            iTarget++;
        }
    }
    return aIDSeq;
}

Sequence< ::rtl::OUString > StringResourceImpl::getResourceIDsForLocale
    ( const Locale& locale ) throw (::com::sun::star::uno::RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
    return implGetResourceIDs( pLocaleItem );
}

Sequence< ::rtl::OUString > StringResourceImpl::getResourceIDs(  )
    throw (RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    return implGetResourceIDs( m_pCurrentLocaleItem );
}

Locale StringResourceImpl::getCurrentLocale()
    throw (RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );

    Locale aRetLocale;
    if( m_pCurrentLocaleItem != NULL )
        aRetLocale = m_pCurrentLocaleItem->m_locale;
    return aRetLocale;
}

Locale StringResourceImpl::getDefaultLocale(  )
    throw (RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );

    Locale aRetLocale;
    if( m_pDefaultLocaleItem != NULL )
        aRetLocale = m_pDefaultLocaleItem->m_locale;
    return aRetLocale;
}

Sequence< Locale > StringResourceImpl::getLocales(  )
    throw (RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );

    sal_Int32 nSize = m_aLocaleItemVector.size();
    Sequence< Locale > aLocalSeq( nSize );
    Locale* pLocales = aLocalSeq.getArray();
    int iTarget = 0;
    for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); ++it )
    {
        LocaleItem* pLocaleItem = *it;
        pLocales[iTarget] = pLocaleItem->m_locale;
        iTarget++;
    }
    return aLocalSeq;
}


// =============================================================================
// XStringResourceManager

void StringResourceImpl::implCheckReadOnly( const sal_Char* pExceptionMsg )
    throw (NoSupportException)
{
    if( m_bReadOnly )
    {
        ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( pExceptionMsg );
        throw NoSupportException( errorMsg, Reference< XInterface >() );
    }
}

sal_Bool StringResourceImpl::isReadOnly()
    throw (RuntimeException)
{
    return m_bReadOnly;
}

void StringResourceImpl::implSetCurrentLocale( const Locale& locale,
    sal_Bool FindClosestMatch, sal_Bool bUseDefaultIfNoMatch )
        throw (IllegalArgumentException, RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );

    LocaleItem* pLocaleItem = NULL;
    if( FindClosestMatch )
        pLocaleItem = getClosestMatchItemForLocale( locale );
    else
        pLocaleItem = getItemForLocale( locale, true );

    if( pLocaleItem == NULL && bUseDefaultIfNoMatch )
        pLocaleItem = m_pDefaultLocaleItem;

    if( pLocaleItem != NULL )
    {
        loadLocale( pLocaleItem );
        m_pCurrentLocaleItem = pLocaleItem;

        // Only notify without modifying
        implNotifyListeners();
    }
}

void StringResourceImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
    throw (IllegalArgumentException, RuntimeException)
{
    sal_Bool bUseDefaultIfNoMatch = false;
    implSetCurrentLocale( locale, FindClosestMatch, bUseDefaultIfNoMatch );
}

void StringResourceImpl::setDefaultLocale( const Locale& locale )
    throw (IllegalArgumentException, RuntimeException,NoSupportException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    implCheckReadOnly( "StringResourceImpl::setDefaultLocale(): Read only" );

    LocaleItem* pLocaleItem = getItemForLocale( locale, true );
    if( pLocaleItem && pLocaleItem != m_pDefaultLocaleItem )
    {
        if( m_pDefaultLocaleItem )
        {
            LocaleItem* pChangedDefaultLocaleItem = new LocaleItem( m_pDefaultLocaleItem->m_locale );
            m_aChangedDefaultLocaleVector.push_back( pChangedDefaultLocaleItem );
        }

        m_pDefaultLocaleItem = pLocaleItem;
        m_bDefaultModified = true;
        implModified();
    }
}

void StringResourceImpl::implSetString( const ::rtl::OUString& ResourceID,
    const ::rtl::OUString& Str, LocaleItem* pLocaleItem )
{
    if( pLocaleItem != NULL && loadLocale( pLocaleItem ) )
    {
        IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;

        IdToStringMap::iterator it = rHashMap.find( ResourceID );
        bool bNew = ( it == rHashMap.end() );
        if( bNew )
        {
            IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap;
            rIndexMap[ ResourceID ] = pLocaleItem->m_nNextIndex++;
            implScanIdForNumber( ResourceID );
        }
        rHashMap[ ResourceID ] = Str;
        pLocaleItem->m_bModified = true;
        implModified();
    }
}

void StringResourceImpl::setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str )
    throw (NoSupportException, RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    implCheckReadOnly( "StringResourceImpl::setString(): Read only" );
    implSetString( ResourceID, Str, m_pCurrentLocaleItem );
}

void StringResourceImpl::setStringForLocale
    ( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str, const Locale& locale )
        throw (NoSupportException, RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    implCheckReadOnly( "StringResourceImpl::setStringForLocale(): Read only" );
    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
    implSetString( ResourceID, Str, pLocaleItem );
}

void StringResourceImpl::implRemoveId( const ::rtl::OUString& ResourceID, LocaleItem* pLocaleItem )
    throw (::com::sun::star::resource::MissingResourceException)
{
    if( pLocaleItem != NULL && loadLocale( pLocaleItem ) )
    {
        IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
        IdToStringMap::iterator it = rHashMap.find( ResourceID );
        if( it == rHashMap.end() )
        {
            ::rtl::OUString errorMsg("StringResourceImpl: No entries for ResourceID: ");
            errorMsg.concat( ResourceID );
            throw ::com::sun::star::resource::MissingResourceException( errorMsg, Reference< XInterface >() );
        }
        rHashMap.erase( it );
        pLocaleItem->m_bModified = true;
        implModified();
    }
}

void StringResourceImpl::removeId( const ::rtl::OUString& ResourceID )
    throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    implCheckReadOnly( "StringResourceImpl::removeId(): Read only" );
    implRemoveId( ResourceID, m_pCurrentLocaleItem );
}

void StringResourceImpl::removeIdForLocale( const ::rtl::OUString& ResourceID, const Locale& locale )
    throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    implCheckReadOnly( "StringResourceImpl::removeIdForLocale(): Read only" );
    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
    implRemoveId( ResourceID, pLocaleItem );
}

void StringResourceImpl::newLocale( const Locale& locale )
    throw (ElementExistException, IllegalArgumentException, RuntimeException, NoSupportException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    implCheckReadOnly( "StringResourceImpl::newLocale(): Read only" );

    if( getItemForLocale( locale, false ) != NULL )
    {
        ::rtl::OUString errorMsg("StringResourceImpl: locale already exists");
        throw ElementExistException( errorMsg, Reference< XInterface >() );
    }

    // TODO?: Check if locale is valid? How?
    bool bValid = true;
    if( bValid )
    {
        LocaleItem* pLocaleItem = new LocaleItem( locale );
        m_aLocaleItemVector.push_back( pLocaleItem );
        pLocaleItem->m_bModified = true;

        // Copy strings from default locale
        LocaleItem* pCopyFromItem = m_pDefaultLocaleItem;
        if( pCopyFromItem == NULL )
            pCopyFromItem = m_pCurrentLocaleItem;
        if( pCopyFromItem != NULL && loadLocale( pCopyFromItem ) )
        {
            const IdToStringMap& rSourceMap = pCopyFromItem->m_aIdToStringMap;
            IdToStringMap& rTargetMap = pLocaleItem->m_aIdToStringMap;
            IdToStringMap::const_iterator it;
            for( it = rSourceMap.begin(); it != rSourceMap.end(); ++it )
            {
                ::rtl::OUString aId  = (*it).first;
                ::rtl::OUString aStr = (*it).second;
                rTargetMap[ aId ] = aStr;
            }

            const IdToIndexMap& rSourceIndexMap = pCopyFromItem->m_aIdToIndexMap;
            IdToIndexMap& rTargetIndexMap = pLocaleItem->m_aIdToIndexMap;
            IdToIndexMap::const_iterator it_index;
            for( it_index = rSourceIndexMap.begin(); it_index != rSourceIndexMap.end(); ++it_index )
            {
                ::rtl::OUString aId  = (*it_index).first;
                sal_Int32 nIndex = (*it_index).second;
                rTargetIndexMap[ aId ] = nIndex;
            }
            pLocaleItem->m_nNextIndex = pCopyFromItem->m_nNextIndex;
        }

        if( m_pCurrentLocaleItem == NULL )
            m_pCurrentLocaleItem = pLocaleItem;

        if( m_pDefaultLocaleItem == NULL )
        {
            m_pDefaultLocaleItem = pLocaleItem;
            m_bDefaultModified = true;
        }

        implModified();
    }
    else
    {
        ::rtl::OUString errorMsg("StringResourceImpl: Invalid locale");
        throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 );
    }
}

void StringResourceImpl::removeLocale( const Locale& locale )
    throw (IllegalArgumentException, RuntimeException, NoSupportException)
{
    ::osl::MutexGuard aGuard( getMutex() );
    implCheckReadOnly( "StringResourceImpl::removeLocale(): Read only" );

    LocaleItem* pRemoveItem = getItemForLocale( locale, true );
    if( pRemoveItem )
    {
        // Last locale?
        sal_Int32 nLocaleCount = m_aLocaleItemVector.size();
        if( nLocaleCount > 1 )
        {
            LocaleItem* pFallbackItem = NULL;
            if( m_pCurrentLocaleItem == pRemoveItem ||
                m_pDefaultLocaleItem  == pRemoveItem )
            {
                for( LocaleItemVectorIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); ++it )
                {
                    LocaleItem* pLocaleItem = *it;
                    if( pLocaleItem != pRemoveItem )
                    {
                        pFallbackItem = pLocaleItem;
                        break;
                    }
                }
                if( m_pCurrentLocaleItem == pRemoveItem )
                {
                    sal_Bool FindClosestMatch = false;
                    setCurrentLocale( pFallbackItem->m_locale, FindClosestMatch );
                }
                if( m_pDefaultLocaleItem == pRemoveItem )
                {
                    setDefaultLocale( pFallbackItem->m_locale );
                }
            }
        }
        for( LocaleItemVectorIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); ++it )
        {
            LocaleItem* pLocaleItem = *it;
            if( pLocaleItem == pRemoveItem )
            {
                // Remember locale item to delete file while storing
                m_aDeletedLocaleItemVector.push_back( pLocaleItem );

                // Last locale?
                if( nLocaleCount == 1 )
                {
                    m_nNextUniqueNumericId = 0;
                    if( m_pDefaultLocaleItem )
                    {
                        LocaleItem* pChangedDefaultLocaleItem = new LocaleItem( m_pDefaultLocaleItem->m_locale );
                        m_aChangedDefaultLocaleVector.push_back( pChangedDefaultLocaleItem );
                    }
                    m_pCurrentLocaleItem = NULL;
                    m_pDefaultLocaleItem = NULL;
                }

                m_aLocaleItemVector.erase( it );

                implModified();
                break;
            }
        }
    }
}

void StringResourceImpl::implScanIdForNumber( const ::rtl::OUString& ResourceID )
{
    const sal_Unicode* pSrc = ResourceID.getStr();
    sal_Int32 nLen = ResourceID.getLength();

    sal_Int32 nNumber = 0;
    for( sal_Int32 i = 0 ; i < nLen ; i++ )
    {
        sal_Unicode c = pSrc[i];
        if( c >= '0' && c <= '9' )
        {
            sal_uInt16 nDigitVal = c - '0';
            nNumber = 10*nNumber + nDigitVal;
        }
        else
            break;
    }

    if( m_nNextUniqueNumericId < nNumber + 1 )
        m_nNextUniqueNumericId = nNumber + 1;
}

sal_Int32 StringResourceImpl::getUniqueNumericId(  )
    throw (RuntimeException, NoSupportException)
{
    if( m_nNextUniqueNumericId == UNIQUE_NUMBER_NEEDS_INITIALISATION )
    {
        implLoadAllLocales();
        m_nNextUniqueNumericId = 0;
    }

    if( m_nNextUniqueNumericId < UNIQUE_NUMBER_NEEDS_INITIALISATION )
    {
        ::rtl::OUString errorMsg("getUniqueNumericId: Extended sal_Int32 range");
        throw NoSupportException( errorMsg, Reference< XInterface >() );
    }
    return m_nNextUniqueNumericId;
}


// =============================================================================
// Private helper methods

LocaleItem* StringResourceImpl::getItemForLocale
    ( const Locale& locale, sal_Bool bException )
        throw (::com::sun::star::lang::IllegalArgumentException)
{
    LocaleItem* pRetItem = NULL;

    // Search for locale
    for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); ++it )
    {
        LocaleItem* pLocaleItem = *it;
        if( pLocaleItem )
        {
            Locale& cmp_locale = pLocaleItem->m_locale;
            if( cmp_locale.Language == locale.Language &&
                cmp_locale.Country  == locale.Country &&
                cmp_locale.Variant  == locale.Variant )
            {
                pRetItem = pLocaleItem;
                break;
            }
        }
    }

    if( pRetItem == NULL && bException )
    {
        ::rtl::OUString errorMsg("StringResourceImpl: Invalid locale");
        throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 );
    }
    return pRetItem;
}

// Returns the LocalItem for a given locale, if it exists, otherwise NULL
// This method performes a closest match search, at least the language must match
LocaleItem* StringResourceImpl::getClosestMatchItemForLocale( const Locale& locale )
{
    LocaleItem* pRetItem = NULL;

    // Search for locale
    for( sal_Int32 iPass = 0 ; iPass <= 2 ; ++iPass )
    {
        for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); ++it )
        {
            LocaleItem* pLocaleItem = *it;
            if( pLocaleItem )
            {
                Locale& cmp_locale = pLocaleItem->m_locale;
                if( cmp_locale.Language == locale.Language &&
                    (iPass > 1 || cmp_locale.Country  == locale.Country) &&
                    (iPass > 0 || cmp_locale.Variant  == locale.Variant) )
                {
                    pRetItem = pLocaleItem;
                    break;
                }
            }
        }
        if( pRetItem )
            break;
    }

    return pRetItem;
}

void StringResourceImpl::implModified( void )
{
    m_bModified = true;
    implNotifyListeners();
}

void StringResourceImpl::implNotifyListeners( void )
{
    EventObject aEvent;
    aEvent.Source = static_cast< XInterface* >( (OWeakObject*)this );

    ::cppu::OInterfaceIteratorHelper it( m_aListenerContainer );
    while( it.hasMoreElements() )
    {
        Reference< XInterface > xIface = it.next();
        Reference< XModifyListener > xListener( xIface, UNO_QUERY );
        try
        {
            xListener->modified( aEvent );
        }
        catch(RuntimeException&)
        {
            it.remove();
        }
    }
}


// =============================================================================
// Loading

bool StringResourceImpl::loadLocale( LocaleItem* pLocaleItem )
{
    // Base implementation has nothing to load
    (void)pLocaleItem;
    return true;
}

void StringResourceImpl::implLoadAllLocales( void )
{
    // Base implementation has nothing to load
}


Reference< XMultiComponentFactory > StringResourceImpl::getMultiComponentFactory( void )
{
    ::osl::MutexGuard aGuard( getMutex() );

    if( !m_xMCF.is() )
    {
        Reference< XMultiComponentFactory > xSMgr( m_xContext->getServiceManager(), UNO_QUERY );
        if( !xSMgr.is() )
        {
            throw RuntimeException(
                ::rtl::OUString( "StringResourceImpl::getMultiComponentFactory: Couldn't instantiate MultiComponentFactory"  ),
                    Reference< XInterface >() );
        }
        m_xMCF = xSMgr;
    }
    return m_xMCF;
}


// =============================================================================
// StringResourcePersistenceImpl
// =============================================================================

StringResourcePersistenceImpl::StringResourcePersistenceImpl( const Reference< XComponentContext >& rxContext )
    : StringResourcePersistenceImpl_BASE( rxContext )
{
}

// -----------------------------------------------------------------------------

StringResourcePersistenceImpl::~StringResourcePersistenceImpl()
{
}

// -----------------------------------------------------------------------------
// XServiceInfo
// -----------------------------------------------------------------------------

::rtl::OUString StringResourcePersistenceImpl::getImplementationName(  )
    throw (RuntimeException)
{
    return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM
        ( "com.sun.star.comp.scripting.StringResourceWithLocation") );
}

// -----------------------------------------------------------------------------

sal_Bool StringResourcePersistenceImpl::supportsService( const ::rtl::OUString& rServiceName )
    throw (RuntimeException)
{
    return StringResourceImpl::supportsService( rServiceName );
}

// -----------------------------------------------------------------------------

Sequence< ::rtl::OUString > StringResourcePersistenceImpl::getSupportedServiceNames(  )
    throw (RuntimeException)
{
    return StringResourceImpl::getSupportedServiceNames();
}

// -----------------------------------------------------------------------------
// XInitialization base functionality for derived classes
// -----------------------------------------------------------------------------

static ::rtl::OUString aNameBaseDefaultStr("strings");

void StringResourcePersistenceImpl::implInitializeCommonParameters
    ( const Sequence< Any >& aArguments )
        throw (Exception, RuntimeException)
{
    bool bReadOnlyOk = (aArguments[1] >>= m_bReadOnly);
    if( !bReadOnlyOk )
    {
        ::rtl::OUString errorMsg("XInitialization::initialize: Expected ReadOnly flag");
        throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 1 );
    }

    com::sun::star::lang::Locale aCurrentLocale;
    bool bLocaleOk = (aArguments[2] >>= aCurrentLocale);
    if( !bLocaleOk )
    {
        ::rtl::OUString errorMsg("XInitialization::initialize: Expected Locale");
        throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 2 );
    }

    bool bNameBaseOk = (aArguments[3] >>= m_aNameBase);
    if( !bNameBaseOk )
    {
        ::rtl::OUString errorMsg("XInitialization::initialize: Expected NameBase string");
        throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 3 );
    }
    if( m_aNameBase.isEmpty() )
        m_aNameBase = aNameBaseDefaultStr;

    bool bCommentOk = (aArguments[4] >>= m_aComment);
    if( !bCommentOk )
    {
        ::rtl::OUString errorMsg("XInitialization::initialize: Expected Comment string");
        throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 4 );
    }

    implScanLocales();

    sal_Bool FindClosestMatch = true;
    sal_Bool bUseDefaultIfNoMatch = true;
    implSetCurrentLocale( aCurrentLocale, FindClosestMatch, bUseDefaultIfNoMatch );
}

// -----------------------------------------------------------------------------
// Forwarding calls to base class

// XModifyBroadcaster
void StringResourcePersistenceImpl::addModifyListener( const Reference< XModifyListener >& aListener )
    throw (RuntimeException)
{
    StringResourceImpl::addModifyListener( aListener );
}
void StringResourcePersistenceImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
    throw (RuntimeException)
{
    StringResourceImpl::removeModifyListener( aListener );
}

// XStringResourceResolver
::rtl::OUString StringResourcePersistenceImpl::resolveString( const ::rtl::OUString& ResourceID )
    throw (::com::sun::star::resource::MissingResourceException, RuntimeException)
{
    return StringResourceImpl::resolveString( ResourceID ) ;
}
::rtl::OUString StringResourcePersistenceImpl::resolveStringForLocale( const ::rtl::OUString& ResourceID, const Locale& locale )
    throw ( ::com::sun::star::resource::MissingResourceException, RuntimeException)
{
    return StringResourceImpl::resolveStringForLocale( ResourceID, locale );
}
sal_Bool StringResourcePersistenceImpl::hasEntryForId( const ::rtl::OUString& ResourceID )
    throw (RuntimeException)
{
    return StringResourceImpl::hasEntryForId( ResourceID ) ;
}
sal_Bool StringResourcePersistenceImpl::hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID,
    const Locale& locale )
        throw (RuntimeException)
{
    return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale );
}
Locale StringResourcePersistenceImpl::getCurrentLocale()
    throw (RuntimeException)
{
    return StringResourceImpl::getCurrentLocale();
}
Locale StringResourcePersistenceImpl::getDefaultLocale(  )
    throw (RuntimeException)
{
    return StringResourceImpl::getDefaultLocale();
}
Sequence< Locale > StringResourcePersistenceImpl::getLocales(  )
    throw (RuntimeException)
{
    return StringResourceImpl::getLocales();
}

// XStringResourceManager
sal_Bool StringResourcePersistenceImpl::isReadOnly()
    throw (RuntimeException)
{
    return StringResourceImpl::isReadOnly();
}
void StringResourcePersistenceImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
    throw (IllegalArgumentException, RuntimeException)
{
    StringResourceImpl::setCurrentLocale( locale, FindClosestMatch );
}
void StringResourcePersistenceImpl::setDefaultLocale( const Locale& locale )
    throw (IllegalArgumentException, RuntimeException,NoSupportException)
{
    StringResourceImpl::setDefaultLocale( locale );
}
Sequence< ::rtl::OUString > StringResourcePersistenceImpl::getResourceIDs(  )
    throw (RuntimeException)
{
    return StringResourceImpl::getResourceIDs();
}
void StringResourcePersistenceImpl::setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str )
    throw (NoSupportException, RuntimeException)
{
    StringResourceImpl::setString( ResourceID, Str );
}
void StringResourcePersistenceImpl::setStringForLocale
    ( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str, const Locale& locale )
        throw (NoSupportException, RuntimeException)
{
    StringResourceImpl::setStringForLocale( ResourceID, Str, locale );
}
Sequence< ::rtl::OUString > StringResourcePersistenceImpl::getResourceIDsForLocale
    ( const Locale& locale ) throw (::com::sun::star::uno::RuntimeException)
{
    return StringResourceImpl::getResourceIDsForLocale( locale );
}
void StringResourcePersistenceImpl::removeId( const ::rtl::OUString& ResourceID )
    throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException)
{
    StringResourceImpl::removeId( ResourceID );
}
void StringResourcePersistenceImpl::removeIdForLocale( const ::rtl::OUString& ResourceID, const Locale& locale )
    throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException)
{
    StringResourceImpl::removeIdForLocale( ResourceID, locale );
}
void StringResourcePersistenceImpl::newLocale( const Locale& locale )
    throw (ElementExistException, IllegalArgumentException, RuntimeException, NoSupportException)
{
    StringResourceImpl::newLocale( locale );
}
void StringResourcePersistenceImpl::removeLocale( const Locale& locale )
    throw (IllegalArgumentException, RuntimeException, NoSupportException)
{
    StringResourceImpl::removeLocale( locale );
}
sal_Int32 StringResourcePersistenceImpl::getUniqueNumericId(  )
    throw (RuntimeException, NoSupportException)
{
    return StringResourceImpl::getUniqueNumericId();
}

// -----------------------------------------------------------------------------
// XStringResourcePersistence

void StringResourcePersistenceImpl::store()
    throw (NoSupportException, Exception, RuntimeException)
{
}

sal_Bool StringResourcePersistenceImpl::isModified(  )
    throw (RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );

    return m_bModified;
}

void StringResourcePersistenceImpl::setComment( const ::rtl::OUString& Comment )
    throw (::com::sun::star::uno::RuntimeException)
{
    m_aComment = Comment;
}

void StringResourcePersistenceImpl::storeToStorage( const Reference< XStorage >& Storage,
    const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment )
        throw (Exception, RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );

    bool bUsedForStore = false;
    bool bStoreAll = true;
    implStoreAtStorage( NameBase, Comment, Storage, bUsedForStore, bStoreAll );
}

void StringResourcePersistenceImpl::implStoreAtStorage
(
    const ::rtl::OUString& aNameBase,
    const ::rtl::OUString& aComment,
    const Reference< ::com::sun::star::embed::XStorage >& Storage,
    bool bUsedForStore,
    bool bStoreAll
)
    throw (Exception, RuntimeException)
{
    // Delete files for deleted locales
    if( bUsedForStore )
    {
        while( m_aDeletedLocaleItemVector.size() > 0 )
        {
            LocaleItemVectorIt it = m_aDeletedLocaleItemVector.begin();
            LocaleItem* pLocaleItem = *it;
            if( pLocaleItem != NULL )
            {
                ::rtl::OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem, m_aNameBase );
                aStreamName += ::rtl::OUString(".properties");

                try
                {
                    Storage->removeElement( aStreamName );
                }
                catch( Exception& )
                {}

                m_aDeletedLocaleItemVector.erase( it );
                delete pLocaleItem;
            }
        }
    }

    for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); ++it )
    {
        LocaleItem* pLocaleItem = *it;
        if( pLocaleItem != NULL && (bStoreAll || pLocaleItem->m_bModified) &&
            loadLocale( pLocaleItem ) )
        {
            ::rtl::OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem, aNameBase );
            aStreamName += ::rtl::OUString(".properties");

            Reference< io::XStream > xElementStream =
                    Storage->openStreamElement( aStreamName, ElementModes::READWRITE );

            ::rtl::OUString aPropName("MediaType");
            ::rtl::OUString aMime("text/plain");

            uno::Reference< beans::XPropertySet > xProps( xElementStream, uno::UNO_QUERY );
            OSL_ENSURE( xProps.is(), "The StorageStream must implement XPropertySet interface!\n" );
            if ( xProps.is() )
            {
                xProps->setPropertyValue( aPropName, uno::makeAny( aMime ) );

                aPropName = ::rtl::OUString("UseCommonStoragePasswordEncryption");
                xProps->setPropertyValue( aPropName, uno::makeAny( sal_True ) );
            }

            Reference< io::XOutputStream > xOutputStream = xElementStream->getOutputStream();
            if( xOutputStream.is() )
                implWritePropertiesFile( pLocaleItem, xOutputStream, aComment );
            xOutputStream->closeOutput();

            if( bUsedForStore )
                pLocaleItem->m_bModified = false;
        }
    }

    // Delete files for changed defaults
    if( bUsedForStore )
    {
        for( LocaleItemVectorIt it = m_aChangedDefaultLocaleVector.begin();
             it != m_aChangedDefaultLocaleVector.end(); ++it )
        {
            LocaleItem* pLocaleItem = *it;
            if( pLocaleItem != NULL )
            {
                ::rtl::OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem, m_aNameBase );
                aStreamName += ::rtl::OUString(".default");

                try
                {
                    Storage->removeElement( aStreamName );
                }
                catch( Exception& )
                {}

                delete pLocaleItem;
            }
        }
        m_aChangedDefaultLocaleVector.clear();
    }

    // Default locale
    if( m_pDefaultLocaleItem != NULL && (bStoreAll || m_bDefaultModified) )
    {
        ::rtl::OUString aStreamName = implGetFileNameForLocaleItem( m_pDefaultLocaleItem, aNameBase );
        aStreamName += ::rtl::OUString(".default");

        Reference< io::XStream > xElementStream =
                Storage->openStreamElement( aStreamName, ElementModes::READWRITE );

        ::rtl::OUString aPropName("MediaType");
        ::rtl::OUString aMime("text/plain");

        // Only create stream without content
        Reference< io::XOutputStream > xOutputStream = xElementStream->getOutputStream();
        xOutputStream->closeOutput();

        if( bUsedForStore )
            m_bDefaultModified = false;
    }
}

void StringResourcePersistenceImpl::storeToURL( const ::rtl::OUString& URL,
    const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment,
    const Reference< ::com::sun::star::task::XInteractionHandler >& Handler )
        throw (Exception, RuntimeException)
{
    ::osl::MutexGuard aGuard( getMutex() );

    bool bUsedForStore = false;
    bool bStoreAll = true;

    Reference< XMultiComponentFactory > xMCF = getMultiComponentFactory();
    Reference< ucb::XSimpleFileAccess > xFileAccess;
    xFileAccess = Reference< ucb::XSimpleFileAccess >( xMCF->createInstanceWithContext
        ( ::rtl::OUString("com.sun.star.ucb.SimpleFileAccess"),
            m_xContext ), UNO_QUERY );
    if( xFileAccess.is() && Handler.is() )
        xFileAccess->setInteractionHandler( Handler );

    implStoreAtLocation( URL, NameBase, Comment, xFileAccess, bUsedForStore, bStoreAll );
}

void StringResourcePersistenceImpl::implKillRemovedLocaleFiles
(
    const ::rtl::OUString& Location,
    const ::rtl::OUString& aNameBase,
    const ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XSimpleFileAccess >& xFileAccess
)
    throw (Exception, RuntimeException)
{
    // Delete files for deleted locales
    while( m_aDeletedLocaleItemVector.size() > 0 )
    {
        LocaleItemVectorIt it = m_aDeletedLocaleItemVector.begin();
        LocaleItem* pLocaleItem = *it;
        if( pLocaleItem != NULL )
        {
            ::rtl::OUString aCompleteFileName =
                implGetPathForLocaleItem( pLocaleItem, aNameBase, Location );
            if( xFileAccess->exists( aCompleteFileName ) )
                xFileAccess->kill( aCompleteFileName );

            m_aDeletedLocaleItemVector.erase( it );
            delete pLocaleItem;
        }
    }
}

void StringResourcePersistenceImpl::implKillChangedDefaultFiles
(
    const ::rtl::OUString& Location,
    const ::rtl::OUString& aNameBase,
    const ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XSimpleFileAccess >& xFileAccess
)
    throw (Exception, RuntimeException)
{
    // Delete files for changed defaults
    for( LocaleItemVectorIt it = m_aChangedDefaultLocaleVector.begin();
         it != m_aChangedDefaultLocaleVector.end(); ++it )
    {
        LocaleItem* pLocaleItem = *it;
        if( pLocaleItem != NULL )
        {
            ::rtl::OUString aCompleteFileName =
                implGetPathForLocaleItem( pLocaleItem, aNameBase, Location, true );
            if( xFileAccess->exists( aCompleteFileName ) )
                xFileAccess->kill( aCompleteFileName );

            delete pLocaleItem;
        }
    }
    m_aChangedDefaultLocaleVector.clear();
}

void StringResourcePersistenceImpl::implStoreAtLocation
(
    const ::rtl::OUString& Location,
    const ::rtl::OUString& aNameBase,
    const ::rtl::OUString& aComment,
    const Reference< ucb::XSimpleFileAccess >& xFileAccess,
    bool bUsedForStore,
    bool bStoreAll,
    bool bKillAll
)
    throw (Exception, RuntimeException)
{
    // Delete files for deleted locales
    if( bUsedForStore || bKillAll )
        implKillRemovedLocaleFiles( Location, aNameBase, xFileAccess );

    for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); ++it )
    {
        LocaleItem* pLocaleItem = *it;
        if( pLocaleItem != NULL && (bStoreAll || bKillAll || pLocaleItem->m_bModified) &&
            loadLocale( pLocaleItem ) )
        {
            ::rtl::OUString aCompleteFileName =
                implGetPathForLocaleItem( pLocaleItem, aNameBase, Location );
            if( xFileAccess->exists( aCompleteFileName ) )
                xFileAccess->kill( aCompleteFileName );

            if( !bKillAll )
            {
                // Create Output stream
                Reference< io::XOutputStream > xOutputStream = xFileAccess->openFileWrite( aCompleteFileName );
                if( xOutputStream.is() )
                {
                    implWritePropertiesFile( pLocaleItem, xOutputStream, aComment );
                    xOutputStream->closeOutput();
                }
                if( bUsedForStore )
                    pLocaleItem->m_bModified = false;
            }
        }
    }

    // Delete files for changed defaults
    if( bUsedForStore || bKillAll )
        implKillChangedDefaultFiles( Location, aNameBase, xFileAccess );

    // Default locale
    if( m_pDefaultLocaleItem != NULL && (bStoreAll || bKillAll || m_bDefaultModified) )
    {
        ::rtl::OUString aCompleteFileName =
            implGetPathForLocaleItem( m_pDefaultLocaleItem, aNameBase, Location, true );
        if( xFileAccess->exists( aCompleteFileName ) )
            xFileAccess->kill( aCompleteFileName );

        if( !bKillAll )
        {
            // Create Output stream
            Reference< io::XOutputStream > xOutputStream = xFileAccess->openFileWrite( aCompleteFileName );
            if( xOutputStream.is() )
                xOutputStream->closeOutput();

            if( bUsedForStore )
                m_bDefaultModified = false;
        }
    }
}


// -----------------------------------------------------------------------------
// BinaryOutput, helper class for exportBinary

class BinaryOutput
{
    Reference< XMultiComponentFactory >     m_xMCF;
    Reference< XComponentContext >          m_xContext;
    Reference< XInterface >                 m_xTempFile;
    Reference< io::XOutputStream >          m_xOutputStream;

public:
    BinaryOutput( Reference< XMultiComponentFactory > xMCF,
        Reference< XComponentContext > xContext );

    Reference< io::XOutputStream > getOutputStream() const
        { return m_xOutputStream; }

    Sequence< ::sal_Int8 > closeAndGetData();

    // Template to be used with sal_Int16 and sal_Unicode
    template< class T >
    void write16BitInt( T n );
    void writeInt16( sal_Int16 n )
        { write16BitInt( n ); }
    void writeUnicodeChar( sal_Unicode n )
        { write16BitInt( n ); }
    void writeInt32( sal_Int32 n );
    void writeString( const ::rtl::OUString& aStr );
};

BinaryOutput::BinaryOutput( Reference< XMultiComponentFactory > xMCF,
    Reference< XComponentContext > xContext )
        : m_xMCF( xMCF )
        , m_xContext( xContext )
{
    m_xTempFile = m_xMCF->createInstanceWithContext
        ( ::rtl::OUString("com.sun.star.io.TempFile"), m_xContext );
    if( m_xTempFile.is() )
        m_xOutputStream = Reference< io::XOutputStream >( m_xTempFile, UNO_QUERY );
}

template< class T >
void BinaryOutput::write16BitInt( T n )
{
    if( !m_xOutputStream.is() )
        return;

    Sequence< sal_Int8 > aSeq( 2 );
    sal_Int8* p = aSeq.getArray();

    sal_Int8 nLow  = sal_Int8( n & 0xff );
    sal_Int8 nHigh = sal_Int8( n >> 8 );

    p[0] = nLow;
    p[1] = nHigh;
    m_xOutputStream->writeBytes( aSeq );
}

void BinaryOutput::writeInt32( sal_Int32 n )
{
    if( !m_xOutputStream.is() )
        return;

    Sequence< sal_Int8 > aSeq( 4 );
    sal_Int8* p = aSeq.getArray();

    for( sal_Int16 i = 0 ; i < 4 ; i++ )
    {
        p[i] = sal_Int8( n & 0xff );
        n >>= 8;
    }
    m_xOutputStream->writeBytes( aSeq );
}

void BinaryOutput::writeString( const ::rtl::OUString& aStr )
{
    sal_Int32 nLen = aStr.getLength();
    const sal_Unicode* pStr = aStr.getStr();

    for( sal_Int32 i = 0 ; i < nLen ; i++ )
        writeUnicodeChar( pStr[i] );

    writeUnicodeChar( 0 );
}

Sequence< ::sal_Int8 > BinaryOutput::closeAndGetData()
{
    Sequence< ::sal_Int8 > aRetSeq;
    if( !m_xOutputStream.is() )
        return aRetSeq;

    m_xOutputStream->closeOutput();

    Reference< io::XSeekable> xSeekable( m_xTempFile, UNO_QUERY );
    if( !xSeekable.is() )
        return aRetSeq;

    sal_Int32 nSize = (sal_Int32)xSeekable->getPosition();

    Reference< io::XInputStream> xInputStream( m_xTempFile, UNO_QUERY );
    if( !xInputStream.is() )
        return aRetSeq;

    xSeekable->seek( 0 );
    sal_Int32 nRead = xInputStream->readBytes( aRetSeq, nSize );
    (void)nRead;
    OSL_ENSURE( nRead == nSize, "BinaryOutput::closeAndGetData: nRead != nSize" );

    return aRetSeq;
}


// Binary format:

// Header
// Byte         Content
// 0 + 1        sal_Int16:  Version, currently 0, low byte first
// 2 + 3        sal_Int16:  Locale count = n, low byte first
// 4 + 5        sal_Int16:  Default Locale position in Locale list, == n if none
// 6 - 7        sal_Int32:  Start index locale block 0, lowest byte first
// (n-1) *      sal_Int32:  Start index locale block 1 to n, lowest byte first
// 6 + 4*n      sal_Int32:  "Start index" non existing locale block n+1,
//                          marks the first invalid index, kind of EOF

// Locale block
// All strings are stored as 2-Byte-0 terminated sequence
// of 16 bit Unicode characters, each with low byte first
// Empty strings only contain the 2-Byte-0

// Members of com.sun.star.lang.Locale
// with l1 = Locale.Language.getLength()
// with l2 = Locale.Country.getLength()
// with l3 = Locale.Variant.getLength()
// pos0 = 0                     Locale.Language
// pos1 = 2 * (l1 + 1)          Locale.Country
// pos2 = pos1 + 2 * (l2 + 1)   Locale.Variant
// pos3 = pos2 + 2 * (l3 + 1)
// pos3                         Properties file written by implWritePropertiesFile

Sequence< sal_Int8 > StringResourcePersistenceImpl::exportBinary(  )
    throw (RuntimeException)
{
    Reference< XMultiComponentFactory > xMCF = getMultiComponentFactory();
    BinaryOutput aOut( xMCF, m_xContext );

    sal_Int32 nLocaleCount = m_aLocaleItemVector.size();
    Sequence< sal_Int8 >* pLocaleDataSeq = new Sequence< sal_Int8 >[ nLocaleCount ];

    sal_Int32 iLocale = 0;
    sal_Int32 iDefault = 0;
    for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin();
         it != m_aLocaleItemVector.end(); ++it,++iLocale )
    {
        LocaleItem* pLocaleItem = *it;
        if( pLocaleItem != NULL && loadLocale( pLocaleItem ) )
        {
            if( m_pDefaultLocaleItem == pLocaleItem )
                iDefault = iLocale;

            BinaryOutput aLocaleOut( m_xMCF, m_xContext );
            implWriteLocaleBinary( pLocaleItem, aLocaleOut );

            pLocaleDataSeq[iLocale] = aLocaleOut.closeAndGetData();
        }
    }

    // Write header
    sal_Int16 nVersion = 0;
    sal_Int16 nLocaleCount16 = (sal_Int16)nLocaleCount;
    sal_Int16 iDefault16 = (sal_Int16)iDefault;
    aOut.writeInt16( nVersion );
    aOut.writeInt16( nLocaleCount16 );
    aOut.writeInt16( iDefault16 );

    // Write data positions
    sal_Int32 nDataPos = 6 + 4 * (nLocaleCount + 1);
    for( iLocale = 0; iLocale < nLocaleCount; iLocale++ )
    {
        aOut.writeInt32( nDataPos );

        Sequence< sal_Int8 >& rSeq = pLocaleDataSeq[iLocale];
        sal_Int32 nSeqLen = rSeq.getLength();
        nDataPos += nSeqLen;
    }
    // Write final position
    aOut.writeInt32( nDataPos );

    // Write data
    Reference< io::XOutputStream > xOutputStream = aOut.getOutputStream();
    if( xOutputStream.is() )
    {
        for( iLocale = 0; iLocale < nLocaleCount; iLocale++ …