libreoffice/svx/source/xml/xmlgrhlp.cxx

/*************************************************************************
 *
 *  $RCSfile: xmlgrhlp.cxx,v $
 *
 *  $Revision: 1.2 $
 *
 *  last change: $Author: ka $
 *
 *  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): _______________________________________
 *
 *
 ************************************************************************/

#ifndef _DEBUG_HXX
#include <tools/debug.hxx>
#endif
#ifndef _SV_CVTGRF_HXX
#include <vcl/cvtgrf.hxx>
#endif
#ifndef _SV_GFXLINK_HXX
#include <vcl/gfxlink.hxx>
#endif

#include "impgrf.hxx"
#include "xmlgrhlp.hxx"

// -----------
// - Defines -
// -----------

#define XML_GRAPHICSTORAGE_NAME     "Pictures"
#define XML_PACKAGE_URL_BASE        "vnd.sun.star.Package:"
#define XML_GRAPHICOBJECT_URL_BASE  "vnd.sun.star.GraphicObject:"

// ----------------------
// - SvXMLGraphicHelper -
// ----------------------

SvXMLGraphicHelper::SvXMLGraphicHelper() :
    ::cppu::WeakComponentImplHelper1< ::com::sun::star::container::XIndexContainer >( maMutex )
{
}

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

SvXMLGraphicHelper::~SvXMLGraphicHelper()
{
}

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

sal_Bool SvXMLGraphicHelper::ImplGetStreamNames( const ::rtl::OUString& rURLStr,
                                                 ::rtl::OUString& rPictureStorageName,
                                                 ::rtl::OUString& rPictureStreamName )
{
    String      aURLStr( rURLStr );
    sal_Bool    bRet = sal_False;

    if( aURLStr.Len() && ( aURLStr.GetTokenCount( ':' ) == 2 ) )
    {
        aURLStr = aURLStr.GetToken( aURLStr.GetTokenCount( ':' ) - 1, ':' );
        const sal_uInt32 nTokenCount = aURLStr.GetTokenCount( '/' );

        if( 1 == nTokenCount )
        {
            rPictureStorageName = String( RTL_CONSTASCII_USTRINGPARAM( XML_GRAPHICSTORAGE_NAME ) );
            rPictureStreamName = aURLStr;
            bRet = sal_True;
        }
        else if( 2 == nTokenCount )
        {
            rPictureStorageName = aURLStr.GetToken( 0, '/' );
            rPictureStreamName = aURLStr.GetToken( 1, '/' );
            bRet = sal_True;
        }
        else
        {
            DBG_ERROR( "SvXMLGraphicHelper::ImplInsertGraphicURL: invalid scheme" );
        }
    }

    return bRet;
}

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

SvStorageRef SvXMLGraphicHelper::ImplGetGraphicStorage( const ::rtl::OUString& rStorageName )
{
    if( !mxGraphicStorage.Is() || ( rStorageName != maCurStorageName ) )
        mxGraphicStorage = mpRootStorage->OpenStorage( maCurStorageName = rStorageName, STREAM_READ | STREAM_WRITE );

    return mxGraphicStorage;
}

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

SvStorageStreamRef SvXMLGraphicHelper::ImplGetGraphicStream( const ::rtl::OUString& rPictureStorageName,
                                                             const ::rtl::OUString& rPictureStreamName,
                                                             BOOL bTruncate )
{
    SvStorageStreamRef  xStm;
    SvStorageRef        xStorage( ImplGetGraphicStorage( rPictureStorageName ) );

    if( xStorage.Is() )
    {
        xStm = xStorage->OpenStream( rPictureStreamName,
                                     STREAM_READ |
                                     ( ( GRAPHICHELPER_MODE_WRITE == meCreateMode ) ?
                                       ( STREAM_WRITE | ( bTruncate ? STREAM_TRUNC : 0 ) ) : 0 ) );
    }

    return xStm;
}

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

Graphic SvXMLGraphicHelper::ImplReadGraphic( const ::rtl::OUString& rPictureStorageName,
                                             const ::rtl::OUString& rPictureStreamName )
{
    Graphic             aGraphic;
    SvStorageStreamRef  xStm( ImplGetGraphicStream( rPictureStorageName, rPictureStreamName, FALSE ) );

    if( xStm.Is() )
        GetGrfFilter()->ImportGraphic( aGraphic, String(), *xStm );

    return aGraphic;
}

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

void SvXMLGraphicHelper::ImplWriteGraphic( const ::rtl::OUString& rPictureStorageName,
                                           const ::rtl::OUString& rPictureStreamName )
{
    GraphicObject aGrfObject( ByteString( String( rPictureStreamName ), RTL_TEXTENCODING_ASCII_US ) );

    if( aGrfObject.GetType() != GRAPHIC_NONE )
    {
        SvStorageStreamRef xStm( ImplGetGraphicStream( rPictureStorageName, rPictureStreamName, TRUE ) );

        if( xStm.Is() )
        {
            Graphic         aGraphic( (Graphic&) aGrfObject.GetGraphic() );
            const GfxLink   aGfxLink( aGraphic.GetLink() );

            if( aGfxLink.GetDataSize() )
                xStm->Write( aGfxLink.GetData(), aGfxLink.GetDataSize() );
            else
            {
                if( aGraphic.GetType() == GRAPHIC_BITMAP )
                {
                    GraphicFilter*  pFilter = GetGrfFilter();
                    String          aFormat;

                    if( aGraphic.IsAnimated() )
                        aFormat = String( RTL_CONSTASCII_USTRINGPARAM( "GIF" ) );
                    else
                        aFormat = String( RTL_CONSTASCII_USTRINGPARAM( "PNG" ) );

                    pFilter->ExportGraphic( aGraphic, String(), *xStm,
                                            pFilter->GetExportFormatNumberForShortName( aFormat ) );
                }
                else if( aGraphic.GetType() == GRAPHIC_GDIMETAFILE )
                    ( (GDIMetaFile&) aGraphic.GetGDIMetaFile() ).Write( *xStm );
            }
        }
    }
}

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

void SvXMLGraphicHelper::ImplInsertGraphicURL( const ::rtl::OUString& rURLStr, sal_uInt32 nInsertPos )
{
    ::rtl::OUString aPictureStorageName, aPictureStreamName;

    if( ( maIdSet.find( rURLStr ) == maIdSet.end() ) &&
        ImplGetStreamNames( rURLStr, aPictureStorageName, aPictureStreamName ) )
    {
        const static ::rtl::OUString aBaseURL( RTL_CONSTASCII_USTRINGPARAM( XML_GRAPHICOBJECT_URL_BASE ) );

        if( GRAPHICHELPER_MODE_READ == meCreateMode )
        {
            const GraphicObject aObj( ImplReadGraphic( aPictureStorageName, aPictureStreamName ) );

            if( aObj.GetType() != GRAPHIC_NONE )
            {
                maGrfVector.push_back( aObj );
                ( maVector[ nInsertPos ] = aBaseURL ) += String( aObj.GetUniqueID().GetBuffer(), RTL_TEXTENCODING_ASCII_US );
            }
            else
                maVector[ nInsertPos ] = String();
        }
        else if( mbDirect )
            ImplWriteGraphic( aPictureStorageName, aPictureStreamName );

        maIdSet.insert( rURLStr );
    }
}

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

void SvXMLGraphicHelper::Init( SvStorage& rXMLStorage,
                               SvXMLGraphicHelperMode eCreateMode,
                               BOOL bDirect )
{
    mpRootStorage = &rXMLStorage;
    meCreateMode = eCreateMode;
    mbDirect = bDirect;
}

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

SvXMLGraphicHelper* SvXMLGraphicHelper::Create( SvStorage& rXMLStorage,
                                                SvXMLGraphicHelperMode eCreateMode,
                                                BOOL bDirect )
{
    SvXMLGraphicHelper* pThis = new SvXMLGraphicHelper;

    pThis->acquire();
    pThis->Init( rXMLStorage, eCreateMode, bDirect );

    return pThis;
}

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

void SvXMLGraphicHelper::Destroy( SvXMLGraphicHelper* pSvXMLGraphicHelper )
{
    if( pSvXMLGraphicHelper )
    {
        pSvXMLGraphicHelper->Flush();
        pSvXMLGraphicHelper->release();
    }
}

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

void SvXMLGraphicHelper::Flush()
{
    if( ( GRAPHICHELPER_MODE_WRITE == meCreateMode ) && !mbDirect )
    {
        ::_STL::set< ::rtl::OUString >::iterator aIter( maIdSet.begin() ), aEnd( maIdSet.end() );

        while( aIter != aEnd )
        {
            ::rtl::OUString aPictureStorageName, aPictureStreamName;

            if( ImplGetStreamNames( *aIter++, aPictureStorageName, aPictureStreamName ) )
                ImplWriteGraphic( aPictureStorageName, aPictureStreamName );
        }
    }
}

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

void SAL_CALL SvXMLGraphicHelper::insertByIndex( sal_Int32 nIndex, const ::com::sun::star::uno::Any& rElement )
    throw(  ::com::sun::star::lang::IllegalArgumentException,
            ::com::sun::star::lang::IndexOutOfBoundsException,
            ::com::sun::star::lang::WrappedTargetException,
            ::com::sun::star::uno::RuntimeException )
{
    ::osl::MutexGuard   aGuard( maMutex );
    ::rtl::OUString     aStr;

    rElement >>= aStr;

    if( aStr.getLength() )
    {
        if( nIndex == (sal_Int32) maVector.size() )
            maVector.push_back( aStr );
        else
        {
             if( nIndex > (sal_Int32) maVector.size() )
                maVector.resize( nIndex + 1 );

            maVector[ nIndex ] = aStr;
        }

        ImplInsertGraphicURL( aStr, nIndex );
    }
}

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

void SAL_CALL SvXMLGraphicHelper::removeByIndex( sal_Int32 nIndex )
    throw(  ::com::sun::star::lang::IndexOutOfBoundsException,
            ::com::sun::star::lang::WrappedTargetException,
            ::com::sun::star::uno::RuntimeException )
{
    ::osl::MutexGuard aGuard( maMutex );

    DBG_ASSERT( nIndex < getCount(), "invalid Index" );
    maVector.erase( maVector.begin() + nIndex );
}

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

void SAL_CALL SvXMLGraphicHelper::replaceByIndex( sal_Int32 nIndex, const ::com::sun::star::uno::Any& rElement )
    throw(  ::com::sun::star::lang::IllegalArgumentException,
            ::com::sun::star::lang::IndexOutOfBoundsException,
            ::com::sun::star::lang::WrappedTargetException,
            ::com::sun::star::uno::RuntimeException )
{
    ::osl::MutexGuard   aGuard( maMutex );
    ::rtl::OUString     aStr;

    rElement >>= aStr;

    if( aStr.getLength() )
    {
        DBG_ASSERT( nIndex < getCount(), "invalid Index" );
        maVector[ nIndex ] = aStr;
        ImplInsertGraphicURL( aStr, nIndex );
    }
}

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

sal_Int32 SAL_CALL SvXMLGraphicHelper::getCount()
    throw(  ::com::sun::star::uno::RuntimeException )
{
    ::osl::MutexGuard aGuard( maMutex );
    return maVector.size();
}

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

::com::sun::star::uno::Any SAL_CALL SvXMLGraphicHelper::getByIndex( sal_Int32 nIndex )
    throw(  ::com::sun::star::lang::IndexOutOfBoundsException,
            ::com::sun::star::lang::WrappedTargetException,
            ::com::sun::star::uno::RuntimeException )
{
    ::osl::MutexGuard           aGuard( maMutex );
    ::com::sun::star::uno::Any  aAny;

    DBG_ASSERT( nIndex < getCount(), "invalid Index" );
    aAny <<= maVector[ nIndex ];

    return aAny;
}

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

::com::sun::star::uno::Type SAL_CALL SvXMLGraphicHelper::getElementType()
    throw(  ::com::sun::star::uno::RuntimeException )
{
    ::osl::MutexGuard aGuard( maMutex );
    return ::getCppuType( (const ::rtl::OUString*) 0 );
}

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

sal_Bool SAL_CALL SvXMLGraphicHelper::hasElements()
    throw(  ::com::sun::star::uno::RuntimeException )
{
    ::osl::MutexGuard aGuard( maMutex );
    return maVector.size() > 0;
}