AOO410/main/sd/source/filter/grf/sdgrffilter.cxx

/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"

#ifdef _MSC_VER
#pragma warning (disable:4190)
#endif
#include <com/sun/star/graphic/XGraphicProvider.hpp>
#include <com/sun/star/graphic/GraphicType.hpp>
#include <com/sun/star/ucb/XSimpleFileAccess2.hpp>

#include <unotools/localfilehelper.hxx>
#include <tools/errinf.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/metaact.hxx>
#include <vcl/virdev.hxx>
#include <sfx2/docfile.hxx>
#include <sfx2/docfilt.hxx>
#include <sfx2/frame.hxx>
#include <svx/svdograf.hxx>
#include <svx/svdpagv.hxx>

#include "../../ui/inc/strings.hrc"
#include "../../ui/inc/DrawViewShell.hxx"
#include "../../ui/inc/DrawDocShell.hxx"
#include "../../ui/inc/ClientView.hxx"
#include "../../ui/inc/FrameView.hxx"

#include "comphelper/anytostring.hxx"
#include "cppuhelper/exc_hlp.hxx"

// --
#include <comphelper/processfactory.hxx>
#include <unotools/pathoptions.hxx>
#include <com/sun/star/ui/dialogs/XFilePicker.hpp>
#include <com/sun/star/ui/dialogs/XFilterManager.hpp>
#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
#include <sfx2/filedlghelper.hxx>
#include <tools/urlobj.hxx>
#include <svtools/filter.hxx>
#include <svx/xoutbmp.hxx>

// --

#include "sdpage.hxx"
#include "drawdoc.hxx"
#include "sdresid.hxx"
#include "sdgrffilter.hxx"
#include "../../ui/inc/ViewShellBase.hxx"
#include <com/sun/star/uno/Sequence.h>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/PropertyValues.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/lang/XComponent.hpp>
#include <com/sun/star/document/XFilter.hpp>
#include <com/sun/star/document/XExporter.hpp>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/view/XSelectionSupplier.hpp>
#include <com/sun/star/drawing/XDrawView.hpp>
#include "../../ui/inc/DrawController.hxx"
#include <cppuhelper/implbase2.hxx>
#include <com/sun/star/drawing/XShape.hpp>
#include <com/sun/star/task/XInteractionHandler.hpp>
#include <com/sun/star/task/XInteractionRequest.hpp>
#include <com/sun/star/drawing/GraphicFilterRequest.hpp>

using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::graphic;
using namespace ::com::sun::star::io;
using namespace ::com::sun::star::ucb;
using namespace com::sun::star::ui::dialogs;
using rtl::OUString;
using namespace ::sfx2;


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

class SdGRFFilter_ImplInteractionHdl : public ::cppu::WeakImplHelper1< com::sun::star::task::XInteractionHandler >
{
    com::sun::star::uno::Reference< com::sun::star::task::XInteractionHandler > m_xInter;
	sal_uInt16 nFilterError;

	public:

    SdGRFFilter_ImplInteractionHdl( com::sun::star::uno::Reference< com::sun::star::task::XInteractionHandler > xInteraction ) :
		m_xInter( xInteraction ),
		nFilterError( GRFILTER_OK )
        {}

    ~SdGRFFilter_ImplInteractionHdl();

	sal_uInt16 GetErrorCode() const { return nFilterError; };

	virtual void SAL_CALL	handle( const com::sun::star::uno::Reference< com::sun::star::task::XInteractionRequest >& )
								throw( com::sun::star::uno::RuntimeException );
};

SdGRFFilter_ImplInteractionHdl::~SdGRFFilter_ImplInteractionHdl()
{
}

void SdGRFFilter_ImplInteractionHdl::handle( const com::sun::star::uno::Reference< com::sun::star::task::XInteractionRequest >& xRequest )
        throw( com::sun::star::uno::RuntimeException )
{
	if( !m_xInter.is() )
		return;

	com::sun::star::drawing::GraphicFilterRequest aErr;
    if ( xRequest->getRequest() >>= aErr )
		nFilterError = (sal_uInt16)aErr.ErrCode;
	else
        m_xInter->handle( xRequest );
}


// ---------------
// - SdPPTFilter -
// ---------------

SdGRFFilter::SdGRFFilter( SfxMedium& rMedium, ::sd::DrawDocShell& rDocShell ) :
	SdFilter( rMedium, rDocShell, sal_True )
{
}

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

SdGRFFilter::~SdGRFFilter()
{
}

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

void SdGRFFilter::HandleGraphicFilterError( sal_uInt16 nFilterError, sal_uLong nStreamError )
{
	sal_uInt16 nId;

	switch( nFilterError )
	{
		case GRFILTER_OPENERROR:
			nId = STR_IMPORT_GRFILTER_OPENERROR;
			break;
		case GRFILTER_IOERROR:
			nId = STR_IMPORT_GRFILTER_IOERROR;
			break;
		case GRFILTER_FORMATERROR:
			nId = STR_IMPORT_GRFILTER_FORMATERROR;
			break;
		case GRFILTER_VERSIONERROR:
			nId = STR_IMPORT_GRFILTER_VERSIONERROR;
			break;
		case GRFILTER_TOOBIG:
			nId = STR_IMPORT_GRFILTER_TOOBIG;
			break;
		case 0 :
			nId = 0;
			break;

		default:
		case GRFILTER_FILTERERROR:
			nId = STR_IMPORT_GRFILTER_FILTERERROR;
			break;
	}

	if( ERRCODE_NONE != nStreamError )
		ErrorHandler::HandleError( nStreamError );
	else if( STR_IMPORT_GRFILTER_IOERROR == nId )
		ErrorHandler::HandleError( ERRCODE_IO_GENERAL );
	else
	{
		ErrorBox aErrorBox( NULL, WB_OK, String( SdResId( nId ) ) );
		aErrorBox.Execute();
	}
}

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

sal_Bool SdGRFFilter::Import()
{
	Graphic         aGraphic;
	const String    aFileName( mrMedium.GetURLObject().GetMainURL( INetURLObject::NO_DECODE ) );
	GraphicFilter*  pGraphicFilter = GraphicFilter::GetGraphicFilter();
	const sal_uInt16    nFilter = pGraphicFilter->GetImportFormatNumberForTypeName( mrMedium.GetFilter()->GetTypeName() );
	sal_Bool		bRet = sal_False;

	// ggf. Filterdialog ausfuehren
	if ( !pGraphicFilter->HasImportDialog( nFilter ) || pGraphicFilter->DoImportDialog( NULL, nFilter ) )
	{
		SvStream*		pIStm = mrMedium.GetInStream();
		sal_uInt16			nReturn = pIStm ? pGraphicFilter->ImportGraphic( aGraphic, aFileName, *pIStm, nFilter ) : 1;

		if( nReturn )
			HandleGraphicFilterError( nReturn, pGraphicFilter->GetLastError().nStreamError );
		else
		{
			if( mrDocument.GetPageCount() == 0L )
				mrDocument.CreateFirstPages();

			SdPage*		pPage = mrDocument.GetSdPage( 0, PK_STANDARD );
			Point		aPos;
			Size		aPagSize( pPage->GetSize() );
			Size		aGrfSize( OutputDevice::LogicToLogic( aGraphic.GetPrefSize(),
								  aGraphic.GetPrefMapMode(), MAP_100TH_MM ) );

			aPagSize.Width() -= pPage->GetLftBorder() + pPage->GetRgtBorder();
			aPagSize.Height() -= pPage->GetUppBorder() + pPage->GetLwrBorder();

			// scale to fit page
			if ( ( ( aGrfSize.Height() > aPagSize.Height() ) || ( aGrfSize.Width() > aPagSize.Width() ) ) &&
				 aGrfSize.Height() && aPagSize.Height() )
			{
				double fGrfWH =	(double) aGrfSize.Width() / aGrfSize.Height();
				double fWinWH =	(double) aPagSize.Width() / aPagSize.Height();

				// Grafik an Pagesize anpassen (skaliert)
				if( fGrfWH < fWinWH )
				{
					aGrfSize.Width() = (long) ( aPagSize.Height() * fGrfWH );
					aGrfSize.Height() = aPagSize.Height();
				}
				else if( fGrfWH > 0.F )
				{
					aGrfSize.Width() = aPagSize.Width();
					aGrfSize.Height()= (long) ( aPagSize.Width() / fGrfWH );
				}
			}

			// Ausgaberechteck fuer Grafik setzen
			aPos.X() = ( ( aPagSize.Width() - aGrfSize.Width() ) >> 1 ) + pPage->GetLftBorder();
			aPos.Y() = ( ( aPagSize.Height() - aGrfSize.Height() ) >> 1 )  + pPage->GetUppBorder();

			pPage->InsertObject( new SdrGrafObj( aGraphic, Rectangle( aPos, aGrfSize ) ) );
			bRet = sal_True;
		}
	}
	return bRet;
}

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

sal_Bool SdGRFFilter::Export()
{
	// SJ: todo: error handling, the GraphicExportFilter does not support proper errorhandling

    sal_Bool bRet = sal_False;

 	uno::Reference< lang::XMultiServiceFactory >
        xSMgr( ::comphelper::getProcessServiceFactory() );
    uno::Reference< uno::XInterface > xComponent
        ( xSMgr->createInstance( rtl::OUString::createFromAscii( "com.sun.star.drawing.GraphicExportFilter" ) ),
            uno::UNO_QUERY );
	if ( xComponent.is() )
	{
		uno::Reference< document::XExporter > xExporter
			( xComponent, uno::UNO_QUERY );
		uno::Reference< document::XFilter > xFilter
			( xComponent, uno::UNO_QUERY );
		if ( xExporter.is() && xFilter.is() )
		{
			SdPage*	pPage = NULL;
			sd::DrawViewShell*	pDrawViewShell = static_cast< ::sd::DrawViewShell* >
				( ( ( mrDocShell.GetViewShell() && mrDocShell.GetViewShell()->ISA(::sd::DrawViewShell ) ) ? mrDocShell.GetViewShell() : NULL ) );

			PageKind ePageKind = PK_STANDARD;
			if( pDrawViewShell )
			{
				ePageKind = pDrawViewShell->GetPageKind();
				if( PK_HANDOUT == ePageKind )
					pPage = mrDocument.GetSdPage( 0, PK_HANDOUT );
				else
					pPage = pDrawViewShell->GetActualPage();
			}
			else
				pPage = mrDocument.GetSdPage( 0, PK_STANDARD );

			if ( pPage )
			{
				// taking the 'correct' page number, seems that there might exist a better method to archive this
				pPage = mrDocument.GetSdPage( pPage->GetPageNum() ? ( pPage->GetPageNum() - 1 ) >> 1 : 0, ePageKind );
				if ( pPage )
				{
					uno::Reference< lang::XComponent > xSource( pPage->getUnoPage(), uno::UNO_QUERY );
					SfxItemSet* pSet = mrMedium.GetItemSet();
                	GraphicFilter*  pGraphicFilter = GraphicFilter::GetGraphicFilter();
					if ( pSet && pGraphicFilter && xSource.is() )
					{
						const String aTypeName( mrMedium.GetFilter()->GetTypeName() );
						const sal_uInt16 nFilter = pGraphicFilter->GetExportFormatNumberForTypeName( aTypeName );
						if ( nFilter != GRFILTER_FORMAT_NOTFOUND )
						{
							uno::Reference< task::XInteractionHandler > mXInteractionHandler;

							beans::PropertyValues aArgs;
							TransformItems( SID_SAVEASDOC, *pSet, aArgs );

							rtl::OUString sInteractionHandler( RTL_CONSTASCII_USTRINGPARAM( "InteractionHandler" ) );
							rtl::OUString sFilterName( RTL_CONSTASCII_USTRINGPARAM( "FilterName" ) );
							rtl::OUString sShortName( pGraphicFilter->GetExportFormatShortName( nFilter ) );

							sal_Bool	bFilterNameFound = sal_False;
							sal_Int32	i, nCount;
							for ( i = 0, nCount = aArgs.getLength(); i < nCount; i++ )
							{
								rtl::OUString& rStr = aArgs[ i ].Name;
								if ( rStr == sFilterName )
								{
									bFilterNameFound = sal_True;
									aArgs[ i ].Name = sFilterName;
									aArgs[ i ].Value <<= sShortName;
								}
								else if ( rStr == sInteractionHandler )
								{
									uno::Reference< task::XInteractionHandler > xHdl;
									if ( aArgs[ i ].Value >>= xHdl )
									{
										mXInteractionHandler = new SdGRFFilter_ImplInteractionHdl( xHdl );
										aArgs[ i ].Value <<= mXInteractionHandler;
									}
								}
							}
							if ( !bFilterNameFound )
							{
								aArgs.realloc( ++nCount );
								aArgs[ i ].Name = sFilterName;
								aArgs[ i ].Value <<= sShortName;
							}

							// take selection if needed
							if( ( SFX_ITEM_SET == pSet->GetItemState( SID_SELECTION ) )
								&& static_cast< const SfxBoolItem& >( pSet->Get( SID_SELECTION ) ).GetValue()
								&& pDrawViewShell )
							{
								uno::Reference< view::XSelectionSupplier > xSelectionSupplier(
									pDrawViewShell->GetViewShellBase().GetController(), uno::UNO_QUERY );
								if ( xSelectionSupplier.is() )
								{
									uno::Any aSelection( xSelectionSupplier->getSelection() );
									uno::Reference< lang::XComponent > xSelection;
									if ( aSelection >>= xSelection )
										xSource = xSelection;
								}
							}
							xExporter->setSourceDocument( xSource );
							bRet = xFilter->filter( aArgs );
							if ( !bRet && mXInteractionHandler.is() )
								SdGRFFilter::HandleGraphicFilterError(
									static_cast< SdGRFFilter_ImplInteractionHdl* >( mXInteractionHandler.get() )->GetErrorCode(),
													pGraphicFilter->GetLastError().nStreamError );
						}
 					}
				}
			}
		}
	}
    return bRet;
}

void SdGRFFilter::SaveGraphic( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& xShape )
{
	try
	{
		Reference< XMultiServiceFactory > xSM( ::comphelper::getProcessServiceFactory(), UNO_QUERY_THROW );

		Reference< XGraphicProvider > xProvider( xSM->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.graphic.GraphicProvider" ) ) ), UNO_QUERY_THROW );
		Reference< XPropertySet > xShapeSet( xShape, UNO_QUERY_THROW );

		// detect mime type of graphic
		OUString aMimeType;
        OUString sGraphicURL;

		// first try to detect from graphic object
		Reference< XPropertySet > xGraphicSet( xShapeSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Graphic" ) ) ), UNO_QUERY_THROW );
        xShapeSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "GraphicURL" ) ) ) >>= sGraphicURL;

        bool bIsLinked = (sGraphicURL.getLength() != 0) && (sGraphicURL.compareToAscii( RTL_CONSTASCII_STRINGPARAM("vnd.sun.star.GraphicObject:") ) != 0);

        if( !bIsLinked )
       		xGraphicSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "MimeType" ) ) ) >>= aMimeType;

		if( bIsLinked || aMimeType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "image/x-vclgraphic" ) ) || !aMimeType.getLength() )
		{
			// this failed, try to detect it from graphic stream and URL
			OUString aURL( sGraphicURL );

			if( aURL.getLength() == 0 )
				xShapeSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "GraphicStreamURL" ) ) ) >>= aURL;

			{
				Reference< XInputStream > xGraphStream( xShapeSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "GraphicStream" ) ) ), UNO_QUERY );
				PropertyValues aDesc(2);
				aDesc[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) );
				aDesc[0].Value <<= aURL;
				aDesc[1].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "InputStream" ) );
				aDesc[1].Value <<= xGraphStream;

				Reference< XPropertySet > xDescSet( xProvider->queryGraphicDescriptor( aDesc ), UNO_QUERY_THROW );

				xDescSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "MimeType" ) ) ) >>= aMimeType;
			}
		}

		if( aMimeType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "image/x-vclgraphic" ) ) || !aMimeType.getLength() )
		{
			// this also failed, now set a mimetype that fits graphic best

			// gif for animated pixel
			// png for non animated pixel
			// svm for vector format
			sal_Int8 nGraphicType = 0;
			xGraphicSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "GraphicType" ) ) ) >>= nGraphicType;
			switch( nGraphicType )
			{
			case ::com::sun::star::graphic::GraphicType::VECTOR:
				aMimeType = OUString::createFromAscii( "image/x-svm" );
				break;

			case ::com::sun::star::graphic::GraphicType::PIXEL:
				{
					sal_Bool bAnimated = sal_False;
					xGraphicSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Animated" ) ) ) >>= bAnimated;

					if( bAnimated )
					{
						aMimeType = OUString::createFromAscii( "image/gif" );
						break;
					}
				}
				// Fallthrough!
//			case ::com::sun::star::graphic::GraphicType::EMPTY:
			default:
				aMimeType = OUString::createFromAscii( "image/png" );
				break;
			}
		}

		// init dialog
		SvtPathOptions aPathOpt;
		String sGrfPath( aPathOpt.GetGraphicPath() );

		FileDialogHelper aDlgHelper( TemplateDescription::FILESAVE_AUTOEXTENSION, 0 );
		Reference < XFilePicker > xFP = aDlgHelper.GetFilePicker();

		String aTitle( SdResId( STR_TITLE_SAVE_AS_PICTURE ) );
		aDlgHelper.SetTitle( aTitle );

		INetURLObject aPath;
		aPath.SetSmartURL( sGrfPath);
	    xFP->setDisplayDirectory( aPath.GetMainURL(INetURLObject::DECODE_TO_IURI) );

		// populate filter dialog filter list and select default filter to match graphic mime type

		GraphicFilter& rGF = *GraphicFilter::GetGraphicFilter();
		Reference<XFilterManager> xFltMgr(xFP, UNO_QUERY);
		OUString aDefaultFormatName;
		sal_uInt16 nCount = rGF.GetExportFormatCount();

		std::map< OUString, OUString > aMimeTypeMap;

		for ( sal_uInt16 i = 0; i < nCount; i++ )
		{
			const OUString aExportFormatName( rGF.GetExportFormatName( i ) );
			const OUString aFilterMimeType( rGF.GetExportFormatMediaType( i ) );
			xFltMgr->appendFilter( aExportFormatName, rGF.GetExportWildcard( i ) );
			aMimeTypeMap[ aExportFormatName ] = aFilterMimeType;
			if( aMimeType == aFilterMimeType )
				aDefaultFormatName = aExportFormatName;
		}

		if( aDefaultFormatName.getLength() == 0 )
		{
			nCount = rGF.GetImportFormatCount();
			for( sal_uInt16 i = 0; i < nCount; i++ )
			{
				const OUString aFilterMimeType( rGF.GetImportFormatMediaType( i ) );
				if( aMimeType == aFilterMimeType )
				{
					aDefaultFormatName = rGF.GetImportFormatName( i );
					xFltMgr->appendFilter( aDefaultFormatName,  rGF.GetImportWildcard( i ) );
					aMimeTypeMap[ aDefaultFormatName ] = aFilterMimeType;
					break;
				}
			}
		}

		if( aDefaultFormatName.getLength() == 0 )
			aDefaultFormatName = OUString( RTL_CONSTASCII_USTRINGPARAM( "PNG - Portable Network Graphic" ) );

		xFltMgr->setCurrentFilter( aDefaultFormatName );

		// execute dialog

		if( aDlgHelper.Execute() == ERRCODE_NONE )
		{
			OUString sPath( xFP->getFiles().getConstArray()[0] );
			aPath.SetSmartURL( sPath);
			sGrfPath = aPath.GetPath();

			OUString aExportMimeType( aMimeTypeMap[xFltMgr->getCurrentFilter()] );

			Reference< XInputStream > xGraphStream;
			if( aMimeType == aExportMimeType )
				xShapeSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "GraphicStream" ) ) ) >>= xGraphStream;

			if( xGraphStream.is() )
			{
				Reference< XSimpleFileAccess2 > xFileAccess( xSM->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ucb.SimpleFileAccess" ) ) ), UNO_QUERY_THROW );
				xFileAccess->writeFile( sPath, xGraphStream );
			}
			else
			{
				PropertyValues aDesc(2);
				aDesc[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) );
				aDesc[0].Value <<= sPath;
				aDesc[1].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "MimeType" ) );
				aDesc[1].Value <<= aExportMimeType;
				Reference< XGraphic > xGraphic( xShapeSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Graphic" ) ) ), UNO_QUERY_THROW );
				xProvider->storeGraphic( xGraphic, aDesc );
			}
		}
	}
	catch( Exception& )
	{
		DBG_ERROR(
			(rtl::OString("SdGRFFilter::SaveGraphic(), "
					"exception caught: ") +
			rtl::OUStringToOString(
				comphelper::anyToString( cppu::getCaughtException() ),
				RTL_TEXTENCODING_UTF8 )).getStr() );
	}
}