diff options
Diffstat (limited to 'extensions/source/plugin/base/nfuncs.cxx')
| -rw-r--r-- | extensions/source/plugin/base/nfuncs.cxx | 686 |
1 files changed, 686 insertions, 0 deletions
diff --git a/extensions/source/plugin/base/nfuncs.cxx b/extensions/source/plugin/base/nfuncs.cxx new file mode 100644 index 000000000000..b378795a92f1 --- /dev/null +++ b/extensions/source/plugin/base/nfuncs.cxx @@ -0,0 +1,686 @@ +/* -*- 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_extensions.hxx" + +#ifdef AIX +#define _LINUX_SOURCE_COMPAT +#include <sys/timer.h> +#undef _LINUX_SOURCE_COMPAT +#endif + +#if STLPORT_VERSION>=321 +#include <cstdarg> +#endif + +#include <list> + +#include <plugin/impl.hxx> +#include <vcl/svapp.hxx> + +#if OSL_DEBUG_LEVEL > 1 +#include <osl/thread.h> +#include <stdio.h> +static FILE * s_file = 0; +void TRACE( char const * s ) +{ + if (! s_file) + s_file = stderr; + if (s_file) + { + oslThreadIdentifier t = osl_getThreadIdentifier(0); + fprintf( s_file, "log [t_id=%"SAL_PRIuUINT32"]: %s\n", t, s ); + fflush( s_file ); + } +} +void TRACEN( char const * s, long n ) +{ + if (! s_file) + s_file = stderr; + if (s_file) + { + oslThreadIdentifier t = osl_getThreadIdentifier(0); + fprintf( s_file, "log [t_id=%"SAL_PRIuUINT32"]: %s%ld\n", t, s, n ); + fflush( s_file ); + } +} +void TRACES( char const* s, char const* s2 ) +{ + if (! s_file) + s_file = stderr; + if (s_file) + { + oslThreadIdentifier t = osl_getThreadIdentifier(0); + fprintf( s_file, "log [t_id=%"SAL_PRIuUINT32"]: %s %s\n", t, s, s2 ); + fflush( s_file ); + } +} +#else +#define TRACE(x) +#define TRACEN(x,n) +#define TRACES(x,s) +#endif + +using namespace rtl; +using namespace com::sun::star::lang; + +NPNetscapeFuncs aNPNFuncs = +{ + sizeof( NPNetscapeFuncs ), + (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR, + NPN_GetURL, + NPN_PostURL, + NPN_RequestRead, + NPN_NewStream, + NPN_Write, + NPN_DestroyStream, + NPN_Status, + NPN_UserAgent, + NPN_MemAlloc, + NPN_MemFree, + NPN_MemFlush, + NPN_ReloadPlugins, +#ifdef OJI + NPN_GetJavaEnv, + NPN_GetJavaPeer, +#else + 0, + 0, +#endif + NPN_GetURLNotify, + NPN_PostURLNotify, + NPN_GetValue, + NPN_SetValue, + NPN_InvalidateRect, + NPN_InvalidateRegion, + NPN_ForceRedraw +}; + +static ::rtl::OString normalizeURL( XPlugin_Impl* plugin, const ::rtl::OString& url ) +{ + ::rtl::OString aLoadURL; + if( url.indexOf( ":" ) == -1 ) + { + aLoadURL = ::rtl::OUStringToOString( plugin->getCreationURL(), plugin->getTextEncoding() ); + int nPos; + if( ( nPos = aLoadURL.indexOf( "://" ) ) != -1 ) + { + if( url.getLength() && (url.getStr()[ 0 ] == '/' || url.indexOf( '/' ) != -1) ) + { + // this means same server but new path + nPos = aLoadURL.indexOf( '/', nPos+3 ); + + if( nPos != -1 ) + aLoadURL = aLoadURL.copy( 0, url.getStr()[0] == '/' ? nPos : nPos+1 ); + } + else + { + // same server but new file + nPos = aLoadURL.lastIndexOf( '/' ); + aLoadURL = aLoadURL.copy( 0, nPos+1 ); + } + aLoadURL += url; + } + else + aLoadURL = url; + } + else if( url.indexOf( ":/" ) != -1 ) + aLoadURL = url; + + return aLoadURL; +} + +struct AsynchronousGetURL +{ + OUString aUrl; + OUString aTarget; + Reference< XEventListener > xListener; + + DECL_LINK( getURL, XPlugin_Impl* ); +}; + +IMPL_LINK( AsynchronousGetURL, getURL, XPlugin_Impl*, pImpl ) +{ + try + { + pImpl->enterPluginCallback(); + if( xListener.is() ) + pImpl->getPluginContext()-> + getURLNotify( pImpl, + aUrl, + aTarget, + xListener ); + else + pImpl->getPluginContext()-> + getURL( pImpl, + aUrl, + aTarget ); + } + catch( ::com::sun::star::plugin::PluginException& e ) + { + (void)e; + } + pImpl->leavePluginCallback(); + delete this; + return 0; +} + + +extern "C" { + + void* SAL_CALL NP_LOADDS NPN_MemAlloc( uint32 nBytes ) + { + TRACE( "NPN_MemAlloc" ); + void* pMem = malloc( nBytes ); + return pMem; + } + + void SAL_CALL NP_LOADDS NPN_MemFree( void* pMem ) + { + TRACE( "NPN_MemFree" ); + free( pMem ); + } + + uint32 SAL_CALL NP_LOADDS NPN_MemFlush( uint32 /*nSize*/ ) + { + TRACE( "NPN_MemFlush" ); + return 0; + } + + NPError SAL_CALL NP_LOADDS NPN_DestroyStream( NPP instance, NPStream* stream, NPError /*reason*/ ) + { + TRACE( "NPN_DestroyStream" ); + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( ! pImpl ) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginStream* pStream = pImpl->getStreamFromNPStream( stream ); + if( pStream ) + { + if( pStream->getStreamType() == InputStream ) + static_cast<PluginInputStream*>(pStream)->releaseSelf(); + else + delete pStream; + } + + return NPERR_NO_ERROR; + } + + #ifdef OJI + const JRIEnvInterface** SAL_CALL NP_LOADDS NPN_GetJavaEnv() + { + TRACE( "NPN_GetJavaEnv" ); + // no java in this program + return NULL; + } + + jref SAL_CALL NP_LOADDS NPN_GetJavaPeer( NPP /*instance*/ ) + { + TRACE( "NPN_GetJavaPeer" ); + return NULL; + } + #endif + + NPError SAL_CALL NP_LOADDS NPN_GetURL( NPP instance, const char* url, const char* window ) + { + TRACES( "NPN_GetURL", url ); + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( ! pImpl ) + return NPERR_INVALID_INSTANCE_ERROR; + + AsynchronousGetURL* pAsync = new AsynchronousGetURL(); + + OString aLoadURL = normalizeURL( pImpl, url ); + TRACES( "NPN_GetURL", aLoadURL.getStr() ); + pAsync->aUrl = OStringToOUString( aLoadURL, pImpl->getTextEncoding() ); + pAsync->aTarget = OStringToOUString( window, pImpl->getTextEncoding() ); + pImpl->setLastGetUrl( aLoadURL ); + Application::PostUserEvent( LINK( pAsync, AsynchronousGetURL, getURL ), pImpl ); + return NPERR_NO_ERROR; + } + + NPError SAL_CALL NP_LOADDS NPN_GetURLNotify( NPP instance, const char* url, const char* target, + void* notifyData ) + { + TRACES( "NPN_GetURLNotify", url ); + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( ! pImpl ) + return NPERR_INVALID_INSTANCE_ERROR; + + OString aLoadURL = normalizeURL( pImpl, url ); + if( !aLoadURL.getLength() ) + return NPERR_INVALID_URL; + + AsynchronousGetURL* pAsync = new AsynchronousGetURL(); + PluginEventListener* pListener = + new PluginEventListener( pImpl, url, aLoadURL.getStr(), notifyData ); + if( ! target || ! *target ) + { + // stream will be fed back to plugin, + // notify immediately after destruction of stream + pImpl->addPluginEventListener( pListener ); + pListener = NULL; + } + pAsync->aUrl = OStringToOUString( aLoadURL, pImpl->getTextEncoding() ); + pAsync->aTarget = OStringToOUString( target, pImpl->getTextEncoding() ); + pAsync->xListener = pListener; + pImpl->setLastGetUrl( aLoadURL ); + Application::PostUserEvent( LINK( pAsync, AsynchronousGetURL, getURL ), pImpl ); + + return NPERR_NO_ERROR; + } + + NPError SAL_CALL NP_LOADDS NPN_NewStream( NPP instance, NPMIMEType type, const char* target, + NPStream** stream ) + // stream is a return value + { + TRACE( "NPN_NewStream" ); + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( ! pImpl ) + return NPERR_INVALID_INSTANCE_ERROR; + + PluginOutputStream* pStream = new PluginOutputStream( pImpl, + "", 0, 0 ); + *stream = pStream->getStream(); + + try + { + pImpl->enterPluginCallback(); + pImpl->getPluginContext()-> + newStream( + pImpl, + ::rtl::OStringToOUString( type, pImpl->getTextEncoding () ), + ::rtl::OStringToOUString( target, pImpl->getTextEncoding() ), + ::com::sun::star::uno::Reference< ::com::sun::star::io::XActiveDataSource > ( pStream->getOutputStream(), UNO_QUERY ) + ); + pImpl->leavePluginCallback(); + } + catch( ::com::sun::star::plugin::PluginException& e ) + { + pImpl->leavePluginCallback(); + return e.ErrorCode; + } + + return NPERR_NO_ERROR; + } + + NPError SAL_CALL NP_LOADDS NPN_PostURLNotify( NPP instance, const char* url, const char* target, uint32 len, const char* buf, NPBool file, void* notifyData ) + { + TRACE( "NPN_PostURLNotify" ); + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( ! pImpl ) + return NPERR_INVALID_INSTANCE_ERROR; + + ::com::sun::star::uno::Sequence<sal_Int8> Bytes( (sal_Int8*)buf, len ); + + ::rtl::OString aPostURL = normalizeURL( pImpl, url ); + PluginEventListener* pListener = + new PluginEventListener( pImpl, url, aPostURL.getStr(), notifyData ); + + if( ! target || ! *target ) + { + // stream will be fed back to plugin, + // notify immediately after destruction of stream + pImpl->addPluginEventListener( pListener ); + pListener = NULL; + } + + try + { + pImpl->enterPluginCallback(); + pImpl->getPluginContext()-> + postURLNotify( pImpl, + ::rtl::OStringToOUString( aPostURL, pImpl->getTextEncoding() ), + ::rtl::OStringToOUString( target, pImpl->getTextEncoding() ), + Bytes, + file, + ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > ( pListener ) ); + pImpl->leavePluginCallback(); + } + catch( ::com::sun::star::plugin::PluginException& e ) + { + pImpl->leavePluginCallback(); + return e.ErrorCode; + } + + return NPERR_NO_ERROR; + } + + NPError SAL_CALL NP_LOADDS NPN_PostURL( NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file ) + { + TRACE( "NPN_PostURL" ); + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( ! pImpl ) + return NPERR_INVALID_INSTANCE_ERROR; + + ::com::sun::star::uno::Sequence<sal_Int8> Bytes( (sal_Int8*)buf, len ); + ::rtl::OString aPostURL = normalizeURL( pImpl, url ); + try + { + pImpl->enterPluginCallback(); + pImpl->getPluginContext()-> + postURL( pImpl, + ::rtl::OStringToOUString( aPostURL, pImpl->getTextEncoding() ), + ::rtl::OStringToOUString( window, pImpl->getTextEncoding () ), + Bytes, + file ); + pImpl->leavePluginCallback(); + } + catch( ::com::sun::star::plugin::PluginException& e ) + { + pImpl->leavePluginCallback(); + return e.ErrorCode; + } + + return NPERR_NO_ERROR; + } + + NPError SAL_CALL NP_LOADDS NPN_RequestRead( NPStream* stream, NPByteRange* rangeList ) + { + TRACE( "NPN_RequestRead" ); + if( ! rangeList ) + return NPERR_NO_ERROR; + + ::std::list<XPlugin_Impl*>& rList = PluginManager::get().getPlugins(); + ::std::list<XPlugin_Impl*>::iterator iter; + XPlugin_Impl* pPlugin = NULL; + PluginStream* pStream = NULL; + for( iter = rList.begin(); iter!= rList.end(); ++iter ) + { + pStream = (*iter)->getStreamFromNPStream( stream ); + if( pStream ) + { + pPlugin = *iter; + break; + } + } + if( ! pPlugin ) + return NPERR_INVALID_INSTANCE_ERROR; + if( ! pStream || pStream->getStreamType() != InputStream ) + return NPERR_FILE_NOT_FOUND; + + PluginInputStream* pInputStream = (PluginInputStream*)pStream; + sal_Int8* pBytes = NULL; + int nBytes = 0; + pPlugin->enterPluginCallback(); + while( rangeList ) + { + if( pBytes && nBytes < (int)rangeList->length ) + { + delete [] pBytes; + pBytes = NULL; + } + if( ! pBytes ) + pBytes = new sal_Int8[ nBytes = rangeList->length ]; + int nRead = + pInputStream->read( rangeList->offset, pBytes, rangeList->length ); + int nPos = 0; + int nNow; + do + { + nNow = pPlugin->getPluginComm()-> + NPP_WriteReady( pPlugin->getNPPInstance(), + stream ); + nNow = pPlugin->getPluginComm()-> + NPP_Write( pPlugin->getNPPInstance(), + stream, + rangeList->offset + nPos, + nNow, + pBytes+nPos ); + nPos += nNow; + nRead -= nNow; + } while( nRead > 0 && nNow ); + rangeList = rangeList->next; + } + pPlugin->leavePluginCallback(); + + return NPERR_NO_ERROR; + } + + void SAL_CALL NP_LOADDS NPN_Status( NPP instance, const char* message ) + { + TRACE( "NPN_Status" ); + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( ! pImpl ) + return; + + try + { + pImpl->enterPluginCallback(); + pImpl->getPluginContext()-> + displayStatusText( pImpl, ::rtl::OStringToOUString( message, pImpl->getTextEncoding() ) ); + pImpl->leavePluginCallback(); + } + catch( ::com::sun::star::plugin::PluginException& ) + { + pImpl->leavePluginCallback(); + return; + } + } + + const char* SAL_CALL NP_LOADDS NPN_UserAgent( NPP instance ) + { + static char* pAgent = strdup( "Mozilla 3.0" ); + + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( pImpl ) + { + rtl::OUString UserAgent; + try + { + pImpl->enterPluginCallback(); + UserAgent = pImpl->getPluginContext()-> + getUserAgent( pImpl ); + pImpl->leavePluginCallback(); + if( pAgent ) + free( pAgent ); + pAgent = strdup( ::rtl::OUStringToOString( UserAgent, pImpl->getTextEncoding() ).getStr() ); + } + catch( ::com::sun::star::plugin::PluginException& ) + { + pImpl->leavePluginCallback(); + } + } + + TRACES( "NPN_UserAgent: returning", pAgent ); + + return pAgent; + } + +void SAL_CALL NP_LOADDS NPN_Version( int* major, int* minor, int* net_major, int* net_minor ) +{ + TRACE( "NPN_Version" ); + *major = 4; + *minor = 0; + *net_major = 4; + *net_minor = 5; +} + +int32 SAL_CALL NP_LOADDS NPN_Write( NPP instance, NPStream* stream, int32 len, + void* buffer ) +{ + TRACE( "NPN_Write" ); + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( ! pImpl ) + return 0; + + PluginStream* pStream = pImpl->getStreamFromNPStream( stream ); + if( ! pStream || pStream->getStreamType() != OutputStream ) + return 0; + + pImpl->enterPluginCallback(); + ::com::sun::star::uno::Sequence<sal_Int8> Bytes( (sal_Int8*)buffer, len ); + ((PluginOutputStream*)pStream)->getOutputStream()->writeBytes( Bytes ); + pImpl->leavePluginCallback(); + + return len; +} + + +NPError SAL_CALL NP_LOADDS NPN_GetValue( NPP instance, NPNVariable variable, void* value ) +{ + TRACEN( "NPN_GetValue: ", variable ); + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + + if( ! pImpl ) + return 0; + + NPError aResult( NPERR_NO_ERROR ); + + switch( variable ) + { + case NPNVxDisplay: + // Unix only, handled in sysdep part + case NPNVxtAppContext: + // Unix only, handled in sysdep part + default: + aResult = NPERR_INVALID_PARAM; + break; + #ifdef QUARTZ + case 2000: // NPNVsupportsQuickDrawBool + *(NPBool*)value = false; + break; + case 2001: // NPNVsupportsCoreGraphicsBool + *(NPBool*)value = true; + break; + #endif + case NPNVjavascriptEnabledBool: + // no javascript + *(NPBool*)value = false; + break; + case NPNVasdEnabledBool: + // no SmartUpdate + *(NPBool*)value = false; + break; + case NPNVisOfflineBool: + // no offline browsing + *(NPBool*)value = false; + break; + } + /* + provisional code should there ever be NPNVariables that we actually + want to query from the PluginContext + ::rtl::OUString aValue; + try + { + pImpl->enterPluginCallback(); + aValue = pImpl->getPluginContext()-> + getValue( pImpl, (::com::sun::star::plugin::PluginVariable)variable ); + pImpl->leavePluginCallback(); + } + catch( ::com::sun::star::plugin::PluginException& e ) + { + pImpl->leavePluginCallback(); + return e.ErrorCode; + } + */ + + return aResult; +} + +void SAL_CALL NP_LOADDS NPN_ReloadPlugins(NPBool /*reloadPages*/) +{ + TRACE( "NPN_ReloadPlugins" ); +} + + +NPError SAL_CALL NP_LOADDS NPN_SetValue( NPP instance, + NPPVariable variable, + void* value ) +{ + NPError nError = NPERR_NO_ERROR; + TRACEN( "NPN_SetValue ", variable ); + switch( variable ) + { + #ifdef QUARTZ + case (NPPVariable)1000: // NPNVpluginDrawingModel + { + int nDrawingModel = (int)value; // ugly, but that's the way we need to do it + + TRACEN( "drawing model: ", nDrawingModel ); + + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( pImpl ) + pImpl->getSysPlugData().m_nDrawingModel = nDrawingModel; + } + break; + #endif + case NPPVpluginNameString: // make the windows compiler happy, it needs at least one case statement + break; + default: + break; + } + #ifndef QUARTZ + (void)instance; + (void)value; + #endif + return nError; +} + +void SAL_CALL NP_LOADDS NPN_InvalidateRect(NPP instance, NPRect* /*invalidRect*/) +{ + TRACE( "NPN_InvalidateRect" ); + + #ifdef QUARTZ + NPN_ForceRedraw( instance ); + #else + (void)instance; + #endif +} + +void SAL_CALL NP_LOADDS NPN_InvalidateRegion(NPP instance, NPRegion /*invalidRegion*/) +{ + TRACE( "NPN_InvalidateRegion" ); + + #ifdef QUARTZ + NPN_ForceRedraw( instance ); + #else + (void)instance; + #endif +} + +void SAL_CALL NP_LOADDS NPN_ForceRedraw(NPP instance) +{ + TRACE( "NPN_ForceRedraw" ); + #ifdef QUARTZ + XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance ); + if( pImpl ) + { + SysPlugData& rPlugData( pImpl->getSysPlugData() ); + if( rPlugData.m_pPlugView ) + [rPlugData.m_pPlugView setNeedsDisplay: YES]; + } + #else + (void)instance; + #endif +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |