645 lines
19 KiB
C++
645 lines
19 KiB
C++
/* -*- 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.
|
|
*
|
|
************************************************************************/
|
|
|
|
|
|
#ifdef AIX
|
|
#define _LINUX_SOURCE_COMPAT
|
|
#include <sys/timer.h>
|
|
#undef _LINUX_SOURCE_COMPAT
|
|
#endif
|
|
|
|
#ifdef WNT
|
|
#include <prewin.h>
|
|
#include <postwin.h>
|
|
#endif
|
|
|
|
#include <cstdarg>
|
|
#include <list>
|
|
|
|
#include <plugin/impl.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <memory>
|
|
|
|
#if OSL_DEBUG_LEVEL > 1
|
|
#include <osl/thread.h>
|
|
#include <osl/thread.hxx>
|
|
#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::Thread::getCurrentIdentifier();
|
|
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::Thread::getCurrentIdentifier();
|
|
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::Thread::getCurrentIdentifier();
|
|
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 com::sun::star::lang;
|
|
|
|
|
|
// Move deprecated functions which no longer appear in npapi.h before
|
|
// their use to avoid errors that they're undeclared at point of use
|
|
extern "C"
|
|
{
|
|
const JRIEnvInterface** SAL_CALL NP_LOADDS NPN_GetJavaEnv()
|
|
{
|
|
TRACE( "NPN_GetJavaEnv" );
|
|
// no java in this program
|
|
return nullptr;
|
|
}
|
|
|
|
jref SAL_CALL NP_LOADDS NPN_GetJavaPeer( NPP /*instance*/ )
|
|
{
|
|
TRACE( "NPN_GetJavaPeer" );
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
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,
|
|
NPN_GetJavaEnv,
|
|
NPN_GetJavaPeer,
|
|
NPN_GetURLNotify,
|
|
NPN_PostURLNotify,
|
|
NPN_GetValue,
|
|
NPN_SetValue,
|
|
NPN_InvalidateRect,
|
|
NPN_InvalidateRegion,
|
|
NPN_ForceRedraw
|
|
};
|
|
|
|
static OString normalizeURL( XPlugin_Impl* plugin, const OString& url )
|
|
{
|
|
OString aLoadURL;
|
|
if( url.indexOf( ':' ) == -1 )
|
|
{
|
|
aLoadURL = OUStringToOString( plugin->getCreationURL(), plugin->getTextEncoding() );
|
|
int nPos;
|
|
if( ( nPos = aLoadURL.indexOf( "://" ) ) != -1 )
|
|
{
|
|
if( url.indexOf( '/' ) != -1 )
|
|
{
|
|
// this means same server but new path
|
|
nPos = aLoadURL.indexOf( '/', nPos+3 );
|
|
|
|
if( nPos != -1 )
|
|
aLoadURL = aLoadURL.copy( 0, url.startsWith("/") ? 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_TYPED( getURL, void*, void );
|
|
};
|
|
|
|
IMPL_LINK_TYPED( AsynchronousGetURL, getURL, void*, p, void )
|
|
{
|
|
XPlugin_Impl* pImpl = static_cast<XPlugin_Impl*>(p);
|
|
try
|
|
{
|
|
pImpl->enterPluginCallback();
|
|
if( xListener.is() )
|
|
pImpl->getPluginContext()->
|
|
getURLNotify( pImpl,
|
|
aUrl,
|
|
aTarget,
|
|
xListener );
|
|
else
|
|
pImpl->getPluginContext()->
|
|
getURL( pImpl,
|
|
aUrl,
|
|
aTarget );
|
|
}
|
|
catch(const css::plugin::PluginException&)
|
|
{
|
|
}
|
|
pImpl->leavePluginCallback();
|
|
delete this;
|
|
}
|
|
|
|
|
|
extern "C" {
|
|
|
|
void* SAL_CALL NP_LOADDS NPN_MemAlloc( uint32_t 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_t SAL_CALL NP_LOADDS NPN_MemFlush( uint32_t /*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;
|
|
}
|
|
|
|
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.isEmpty() )
|
|
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 = nullptr;
|
|
}
|
|
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,
|
|
OStringToOUString( type, pImpl->getTextEncoding () ),
|
|
OStringToOUString( target, pImpl->getTextEncoding() ),
|
|
css::uno::Reference< css::io::XActiveDataSource > ( pStream->getOutputStream(), UNO_QUERY )
|
|
);
|
|
pImpl->leavePluginCallback();
|
|
}
|
|
catch( const css::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_t 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;
|
|
|
|
css::uno::Sequence<sal_Int8> Bytes( reinterpret_cast<sal_Int8 const *>(buf), len );
|
|
|
|
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 = nullptr;
|
|
}
|
|
|
|
try
|
|
{
|
|
pImpl->enterPluginCallback();
|
|
pImpl->getPluginContext()->
|
|
postURLNotify( pImpl,
|
|
OStringToOUString( aPostURL, pImpl->getTextEncoding() ),
|
|
OStringToOUString( target, pImpl->getTextEncoding() ),
|
|
Bytes,
|
|
file,
|
|
css::uno::Reference< css::lang::XEventListener > ( pListener ) );
|
|
pImpl->leavePluginCallback();
|
|
}
|
|
catch( const css::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_t len, const char* buf, NPBool file )
|
|
{
|
|
TRACE( "NPN_PostURL" );
|
|
XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
|
|
if( ! pImpl )
|
|
return NPERR_INVALID_INSTANCE_ERROR;
|
|
|
|
css::uno::Sequence<sal_Int8> Bytes( reinterpret_cast<sal_Int8 const *>(buf), len );
|
|
OString aPostURL = normalizeURL( pImpl, url );
|
|
try
|
|
{
|
|
pImpl->enterPluginCallback();
|
|
pImpl->getPluginContext()->
|
|
postURL( pImpl,
|
|
OStringToOUString( aPostURL, pImpl->getTextEncoding() ),
|
|
OStringToOUString( window, pImpl->getTextEncoding () ),
|
|
Bytes,
|
|
file );
|
|
pImpl->leavePluginCallback();
|
|
}
|
|
catch( const css::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 = nullptr;
|
|
PluginStream* pStream = nullptr;
|
|
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 = static_cast<PluginInputStream*>(pStream);
|
|
std::unique_ptr<sal_Int8[]> pBytes;
|
|
int nBytes = 0;
|
|
pPlugin->enterPluginCallback();
|
|
while( rangeList )
|
|
{
|
|
if( pBytes && nBytes < (int)rangeList->length )
|
|
pBytes.reset();
|
|
if( ! pBytes ) {
|
|
nBytes = rangeList->length;
|
|
pBytes.reset(new sal_Int8[ nBytes ]);
|
|
}
|
|
int nRead =
|
|
pInputStream->read( rangeList->offset, pBytes.get(), 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.get()+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, OStringToOUString( message, pImpl->getTextEncoding() ) );
|
|
pImpl->leavePluginCallback();
|
|
}
|
|
catch( const css::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 )
|
|
{
|
|
OUString UserAgent;
|
|
try
|
|
{
|
|
pImpl->enterPluginCallback();
|
|
UserAgent = pImpl->getPluginContext()->
|
|
getUserAgent( pImpl );
|
|
pImpl->leavePluginCallback();
|
|
if( pAgent )
|
|
free( pAgent );
|
|
pAgent = strdup( OUStringToOString( UserAgent, pImpl->getTextEncoding() ).getStr() );
|
|
}
|
|
catch( const css::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_t SAL_CALL NP_LOADDS NPN_Write( NPP instance, NPStream* stream, int32_t 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();
|
|
css::uno::Sequence<sal_Int8> Bytes( static_cast<sal_Int8*>(buffer), len );
|
|
static_cast<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 MACOSX
|
|
case 2000: // NPNVsupportsQuickDrawBool
|
|
*(NPBool*)value = false;
|
|
break;
|
|
case 2001: // NPNVsupportsCoreGraphicsBool
|
|
*(NPBool*)value = true;
|
|
break;
|
|
#endif
|
|
case NPNVjavascriptEnabledBool:
|
|
// no javascript
|
|
*static_cast<NPBool*>(value) = false;
|
|
break;
|
|
case NPNVasdEnabledBool:
|
|
// no SmartUpdate
|
|
*static_cast<NPBool*>(value) = false;
|
|
break;
|
|
case NPNVisOfflineBool:
|
|
// no offline browsing
|
|
*static_cast<NPBool*>(value) = false;
|
|
break;
|
|
}
|
|
|
|
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 );
|
|
#ifdef MACOSX
|
|
NPN_SetValue_Impl(instance, variable, value);
|
|
#else
|
|
(void)instance;
|
|
(void)variable;
|
|
(void)value;
|
|
#endif
|
|
return nError;
|
|
}
|
|
|
|
void SAL_CALL NP_LOADDS NPN_InvalidateRect(NPP instance, NPRect* /*invalidRect*/)
|
|
{
|
|
TRACE( "NPN_InvalidateRect" );
|
|
|
|
#ifdef MACOSX
|
|
NPN_ForceRedraw( instance );
|
|
#else
|
|
(void)instance;
|
|
#endif
|
|
}
|
|
|
|
void SAL_CALL NP_LOADDS NPN_InvalidateRegion(NPP instance, NPRegion /*invalidRegion*/)
|
|
{
|
|
TRACE( "NPN_InvalidateRegion" );
|
|
|
|
#ifdef MACOSX
|
|
NPN_ForceRedraw( instance );
|
|
#else
|
|
(void)instance;
|
|
#endif
|
|
}
|
|
|
|
void SAL_CALL NP_LOADDS NPN_ForceRedraw(NPP instance)
|
|
{
|
|
TRACE( "NPN_ForceRedraw" );
|
|
#ifdef MACOSX
|
|
NPN_ForceRedraw_Impl(instance);
|
|
#else
|
|
(void)instance;
|
|
#endif
|
|
}
|
|
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|