LCOV - code coverage report
Current view: top level - extensions/source/plugin/base - nfuncs.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 1 245 0.4 %
Date: 2014-11-03 Functions: 2 29 6.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*************************************************************************
       3             :  *
       4             :  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
       5             :  *
       6             :  * Copyright 2000, 2010 Oracle and/or its affiliates.
       7             :  *
       8             :  * OpenOffice.org - a multi-platform office productivity suite
       9             :  *
      10             :  * This file is part of OpenOffice.org.
      11             :  *
      12             :  * OpenOffice.org is free software: you can redistribute it and/or modify
      13             :  * it under the terms of the GNU Lesser General Public License version 3
      14             :  * only, as published by the Free Software Foundation.
      15             :  *
      16             :  * OpenOffice.org is distributed in the hope that it will be useful,
      17             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      18             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      19             :  * GNU Lesser General Public License version 3 for more details
      20             :  * (a copy is included in the LICENSE file that accompanied this code).
      21             :  *
      22             :  * You should have received a copy of the GNU Lesser General Public License
      23             :  * version 3 along with OpenOffice.org.  If not, see
      24             :  * <http://www.openoffice.org/license.html>
      25             :  * for a copy of the LGPLv3 License.
      26             :  *
      27             :  ************************************************************************/
      28             : 
      29             : 
      30             : #ifdef AIX
      31             : #define _LINUX_SOURCE_COMPAT
      32             : #include <sys/timer.h>
      33             : #undef _LINUX_SOURCE_COMPAT
      34             : #endif
      35             : 
      36             : #ifdef WNT
      37             : #include <prewin.h>
      38             : #include <postwin.h>
      39             : #endif
      40             : 
      41             : #include <cstdarg>
      42             : #include <list>
      43             : 
      44             : #include <plugin/impl.hxx>
      45             : #include <vcl/svapp.hxx>
      46             : #include <boost/scoped_array.hpp>
      47             : 
      48             : #if OSL_DEBUG_LEVEL > 1
      49             : #include <osl/thread.h>
      50             : #include <osl/thread.hxx>
      51             : #include <stdio.h>
      52             : static FILE * s_file = 0;
      53             : void TRACE( char const * s )
      54             : {
      55             :     if (! s_file)
      56             :         s_file = stderr;
      57             :     if (s_file)
      58             :     {
      59             :         oslThreadIdentifier t = osl::Thread::getCurrentIdentifier();
      60             :         fprintf( s_file, "log [t_id=%" SAL_PRIuUINT32 "]: %s\n", t, s );
      61             :         fflush( s_file );
      62             :     }
      63             : }
      64             : void TRACEN( char const * s, long n )
      65             : {
      66             :     if (! s_file)
      67             :         s_file = stderr;
      68             :     if (s_file)
      69             :     {
      70             :         oslThreadIdentifier t = osl::Thread::getCurrentIdentifier();
      71             :         fprintf( s_file, "log [t_id=%" SAL_PRIuUINT32 "]: %s%ld\n", t, s, n );
      72             :         fflush( s_file );
      73             :     }
      74             : }
      75             : void TRACES( char const* s, char const* s2 )
      76             : {
      77             :     if (! s_file)
      78             :         s_file = stderr;
      79             :     if (s_file)
      80             :     {
      81             :         oslThreadIdentifier t = osl::Thread::getCurrentIdentifier();
      82             :         fprintf( s_file, "log [t_id=%" SAL_PRIuUINT32 "]: %s %s\n", t, s, s2 );
      83             :         fflush( s_file );
      84             :     }
      85             : }
      86             : #else
      87             : #define TRACE(x)
      88             : #define TRACEN(x,n)
      89             : #define TRACES(x,s)
      90             : #endif
      91             : 
      92             : using namespace com::sun::star::lang;
      93             : 
      94             : 
      95             : // Move deprecated functions which no longer appear in npapi.h before
      96             : // their use to avoid errors that they're undeclared at point of use
      97             : extern "C"
      98             : {
      99           0 :     const JRIEnvInterface** SAL_CALL NP_LOADDS  NPN_GetJavaEnv()
     100             :     {
     101             :         TRACE( "NPN_GetJavaEnv" );
     102             :         // no java in this program
     103           0 :         return NULL;
     104             :     }
     105             : 
     106           0 :     jref SAL_CALL NP_LOADDS  NPN_GetJavaPeer( NPP /*instance*/ )
     107             :     {
     108             :         TRACE( "NPN_GetJavaPeer" );
     109           0 :         return NULL;
     110             :     }
     111             : }
     112             : 
     113             : NPNetscapeFuncs aNPNFuncs =
     114             : {
     115             :     sizeof( NPNetscapeFuncs ),
     116             :     (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR,
     117             :     NPN_GetURL,
     118             :     NPN_PostURL,
     119             :     NPN_RequestRead,
     120             :     NPN_NewStream,
     121             :     NPN_Write,
     122             :     NPN_DestroyStream,
     123             :     NPN_Status,
     124             :     NPN_UserAgent,
     125             :     NPN_MemAlloc,
     126             :     NPN_MemFree,
     127             :     NPN_MemFlush,
     128             :     NPN_ReloadPlugins,
     129             :     NPN_GetJavaEnv,
     130             :     NPN_GetJavaPeer,
     131             :     NPN_GetURLNotify,
     132             :     NPN_PostURLNotify,
     133             :     NPN_GetValue,
     134             :     NPN_SetValue,
     135             :     NPN_InvalidateRect,
     136             :     NPN_InvalidateRegion,
     137             :     NPN_ForceRedraw
     138             : };
     139             : 
     140           0 : static OString normalizeURL( XPlugin_Impl* plugin, const OString& url )
     141             : {
     142           0 :     OString aLoadURL;
     143           0 :     if( url.indexOf( ':' ) == -1 )
     144             :     {
     145           0 :         aLoadURL = OUStringToOString( plugin->getCreationURL(), plugin->getTextEncoding() );
     146             :         int nPos;
     147           0 :         if( ( nPos = aLoadURL.indexOf( "://" ) ) != -1 )
     148             :         {
     149           0 :             if( url.indexOf( '/' ) != -1 )
     150             :             {
     151             :                 // this means same server but new path
     152           0 :                 nPos = aLoadURL.indexOf( '/', nPos+3 );
     153             : 
     154           0 :                 if( nPos != -1 )
     155           0 :                     aLoadURL = aLoadURL.copy( 0, url.startsWith("/") ? nPos : nPos+1 );
     156             :             }
     157             :             else
     158             :             {
     159             :                 // same server but new file
     160           0 :                 nPos = aLoadURL.lastIndexOf( '/' );
     161           0 :                 aLoadURL = aLoadURL.copy( 0, nPos+1 );
     162             :             }
     163           0 :             aLoadURL += url;
     164             :         }
     165             :         else
     166           0 :             aLoadURL = url;
     167             :     }
     168           0 :     else if( url.indexOf( ":/" ) != -1 )
     169           0 :         aLoadURL = url;
     170             : 
     171           0 :     return aLoadURL;
     172             : }
     173             : 
     174           0 : struct AsynchronousGetURL
     175             : {
     176             :     OUString                        aUrl;
     177             :     OUString                        aTarget;
     178             :     Reference< XEventListener >     xListener;
     179             : 
     180             :     DECL_LINK( getURL, XPlugin_Impl* );
     181             : };
     182             : 
     183           0 : IMPL_LINK( AsynchronousGetURL, getURL, XPlugin_Impl*, pImpl )
     184             : {
     185             :     try
     186             :     {
     187           0 :         pImpl->enterPluginCallback();
     188           0 :         if( xListener.is() )
     189           0 :             pImpl->getPluginContext()->
     190             :                 getURLNotify( pImpl,
     191             :                               aUrl,
     192             :                               aTarget,
     193           0 :                               xListener );
     194             :         else
     195           0 :             pImpl->getPluginContext()->
     196             :                 getURL( pImpl,
     197             :                         aUrl,
     198           0 :                         aTarget );
     199             :     }
     200           0 :     catch(const ::com::sun::star::plugin::PluginException&)
     201             :     {
     202             :     }
     203           0 :     pImpl->leavePluginCallback();
     204           0 :     delete this;
     205           0 :     return 0;
     206             : }
     207             : 
     208             : 
     209             : extern "C" {
     210             : 
     211           0 :     void* SAL_CALL NP_LOADDS  NPN_MemAlloc( uint32_t nBytes )
     212             :     {
     213             :         TRACE( "NPN_MemAlloc" );
     214           0 :         void* pMem = malloc( nBytes );
     215           0 :         return pMem;
     216             :     }
     217             : 
     218           0 :     void SAL_CALL NP_LOADDS  NPN_MemFree( void* pMem )
     219             :     {
     220             :         TRACE( "NPN_MemFree" );
     221           0 :         free( pMem );
     222           0 :     }
     223             : 
     224           0 :     uint32_t SAL_CALL NP_LOADDS  NPN_MemFlush( uint32_t /*nSize*/ )
     225             :     {
     226             :         TRACE( "NPN_MemFlush" );
     227           0 :         return 0;
     228             :     }
     229             : 
     230           0 :     NPError SAL_CALL NP_LOADDS  NPN_DestroyStream( NPP instance, NPStream* stream, NPError /*reason*/ )
     231             :     {
     232             :         TRACE( "NPN_DestroyStream" );
     233           0 :         XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     234           0 :         if( ! pImpl )
     235           0 :             return NPERR_INVALID_INSTANCE_ERROR;
     236             : 
     237           0 :         PluginStream* pStream = pImpl->getStreamFromNPStream( stream );
     238           0 :         if( pStream )
     239             :         {
     240           0 :             if( pStream->getStreamType() == InputStream )
     241           0 :                 static_cast<PluginInputStream*>(pStream)->releaseSelf();
     242             :             else
     243           0 :                 delete pStream;
     244             :         }
     245             : 
     246           0 :         return NPERR_NO_ERROR;
     247             :     }
     248             : 
     249           0 :     NPError SAL_CALL NP_LOADDS  NPN_GetURL( NPP instance, const char* url, const char* window )
     250             :     {
     251             :         TRACES( "NPN_GetURL", url );
     252           0 :         XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     253           0 :         if( ! pImpl )
     254           0 :             return NPERR_INVALID_INSTANCE_ERROR;
     255             : 
     256           0 :         AsynchronousGetURL* pAsync = new AsynchronousGetURL();
     257             : 
     258           0 :         OString aLoadURL = normalizeURL( pImpl, url );
     259             :         TRACES( "NPN_GetURL", aLoadURL.getStr() );
     260           0 :         pAsync->aUrl = OStringToOUString( aLoadURL, pImpl->getTextEncoding() );
     261           0 :         pAsync->aTarget = OStringToOUString( window, pImpl->getTextEncoding() );
     262           0 :         pImpl->setLastGetUrl( aLoadURL );
     263           0 :         Application::PostUserEvent( LINK( pAsync, AsynchronousGetURL, getURL ), pImpl );
     264           0 :         return NPERR_NO_ERROR;
     265             :     }
     266             : 
     267           0 :     NPError SAL_CALL NP_LOADDS  NPN_GetURLNotify( NPP instance, const char* url, const char* target,
     268             :                           void* notifyData )
     269             :     {
     270             :         TRACES( "NPN_GetURLNotify", url );
     271           0 :         XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     272           0 :         if( ! pImpl )
     273           0 :             return NPERR_INVALID_INSTANCE_ERROR;
     274             : 
     275           0 :         OString aLoadURL = normalizeURL( pImpl, url );
     276           0 :         if( aLoadURL.isEmpty() )
     277           0 :             return NPERR_INVALID_URL;
     278             : 
     279           0 :         AsynchronousGetURL* pAsync = new AsynchronousGetURL();
     280             :         PluginEventListener* pListener =
     281           0 :             new PluginEventListener( pImpl, url, aLoadURL.getStr(), notifyData );
     282           0 :         if( ! target || ! *target )
     283             :         {
     284             :             // stream will be fed back to plugin,
     285             :             // notify immediately after destruction of stream
     286           0 :             pImpl->addPluginEventListener( pListener );
     287           0 :             pListener = NULL;
     288             :         }
     289           0 :         pAsync->aUrl        = OStringToOUString( aLoadURL, pImpl->getTextEncoding() );
     290           0 :         pAsync->aTarget     = OStringToOUString( target, pImpl->getTextEncoding() );
     291           0 :         pAsync->xListener   = pListener;
     292           0 :         pImpl->setLastGetUrl( aLoadURL );
     293           0 :         Application::PostUserEvent( LINK( pAsync, AsynchronousGetURL, getURL ), pImpl );
     294             : 
     295           0 :         return NPERR_NO_ERROR;
     296             :     }
     297             : 
     298           0 :     NPError SAL_CALL NP_LOADDS  NPN_NewStream( NPP instance, NPMIMEType type, const char* target,
     299             :                            NPStream** stream )
     300             :         // stream is a return value
     301             :     {
     302             :         TRACE( "NPN_NewStream" );
     303           0 :         XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     304           0 :         if( ! pImpl )
     305           0 :             return NPERR_INVALID_INSTANCE_ERROR;
     306             : 
     307             :         PluginOutputStream* pStream = new PluginOutputStream( pImpl,
     308           0 :                                                               "", 0, 0 );
     309           0 :         *stream = &pStream->getStream();
     310             : 
     311             :         try
     312             :         {
     313           0 :             pImpl->enterPluginCallback();
     314           0 :             pImpl->getPluginContext()->
     315             :                 newStream(
     316             :                     pImpl,
     317           0 :                     OStringToOUString( type, pImpl->getTextEncoding () ),
     318           0 :                     OStringToOUString( target, pImpl->getTextEncoding() ),
     319           0 :                     ::com::sun::star::uno::Reference< ::com::sun::star::io::XActiveDataSource > ( pStream->getOutputStream(), UNO_QUERY )
     320           0 :                     );
     321           0 :             pImpl->leavePluginCallback();
     322             :         }
     323           0 :         catch( const ::com::sun::star::plugin::PluginException& e )
     324             :         {
     325           0 :             pImpl->leavePluginCallback();
     326           0 :             return e.ErrorCode;
     327             :         }
     328             : 
     329           0 :         return NPERR_NO_ERROR;
     330             :     }
     331             : 
     332           0 :     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 )
     333             :     {
     334             :         TRACE( "NPN_PostURLNotify" );
     335           0 :         XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     336           0 :         if( ! pImpl )
     337           0 :             return NPERR_INVALID_INSTANCE_ERROR;
     338             : 
     339           0 :         ::com::sun::star::uno::Sequence<sal_Int8> Bytes( (sal_Int8*)buf, len );
     340             : 
     341           0 :         OString aPostURL = normalizeURL( pImpl, url );
     342             :         PluginEventListener* pListener =
     343           0 :             new PluginEventListener( pImpl, url, aPostURL.getStr(), notifyData );
     344             : 
     345           0 :         if( ! target || ! *target )
     346             :         {
     347             :             // stream will be fed back to plugin,
     348             :             // notify immediately after destruction of stream
     349           0 :             pImpl->addPluginEventListener( pListener );
     350           0 :             pListener = NULL;
     351             :         }
     352             : 
     353             :         try
     354             :         {
     355           0 :             pImpl->enterPluginCallback();
     356           0 :             pImpl->getPluginContext()->
     357             :                 postURLNotify( pImpl,
     358           0 :                                OStringToOUString( aPostURL, pImpl->getTextEncoding() ),
     359           0 :                                OStringToOUString( target, pImpl->getTextEncoding() ),
     360             :                                Bytes,
     361             :                                file,
     362           0 :                                ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > ( pListener ) );
     363           0 :             pImpl->leavePluginCallback();
     364             :         }
     365           0 :         catch( const ::com::sun::star::plugin::PluginException& e )
     366             :         {
     367           0 :             pImpl->leavePluginCallback();
     368           0 :             return e.ErrorCode;
     369             :         }
     370             : 
     371           0 :         return NPERR_NO_ERROR;
     372             :     }
     373             : 
     374           0 :     NPError SAL_CALL NP_LOADDS  NPN_PostURL( NPP instance, const char* url, const char* window, uint32_t len, const char* buf, NPBool file )
     375             :     {
     376             :         TRACE( "NPN_PostURL" );
     377           0 :         XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     378           0 :         if( ! pImpl )
     379           0 :             return NPERR_INVALID_INSTANCE_ERROR;
     380             : 
     381           0 :         ::com::sun::star::uno::Sequence<sal_Int8> Bytes( (sal_Int8*)buf, len );
     382           0 :         OString aPostURL = normalizeURL( pImpl, url );
     383             :         try
     384             :         {
     385           0 :             pImpl->enterPluginCallback();
     386           0 :             pImpl->getPluginContext()->
     387             :                 postURL( pImpl,
     388           0 :                          OStringToOUString( aPostURL, pImpl->getTextEncoding() ),
     389           0 :                          OStringToOUString( window, pImpl->getTextEncoding () ),
     390             :                          Bytes,
     391           0 :                          file );
     392           0 :             pImpl->leavePluginCallback();
     393             :         }
     394           0 :         catch( const ::com::sun::star::plugin::PluginException& e )
     395             :         {
     396           0 :             pImpl->leavePluginCallback();
     397           0 :             return e.ErrorCode;
     398             :         }
     399             : 
     400           0 :         return NPERR_NO_ERROR;
     401             :     }
     402             : 
     403           0 :     NPError SAL_CALL NP_LOADDS  NPN_RequestRead( NPStream* stream, NPByteRange* rangeList )
     404             :     {
     405             :         TRACE( "NPN_RequestRead" );
     406           0 :         if( ! rangeList )
     407           0 :             return NPERR_NO_ERROR;
     408             : 
     409           0 :         ::std::list<XPlugin_Impl*>& rList = PluginManager::get().getPlugins();
     410           0 :         ::std::list<XPlugin_Impl*>::iterator iter;
     411           0 :         XPlugin_Impl* pPlugin = NULL;
     412           0 :         PluginStream* pStream = NULL;
     413           0 :         for( iter = rList.begin(); iter!= rList.end(); ++iter )
     414             :         {
     415           0 :             pStream = (*iter)->getStreamFromNPStream( stream );
     416           0 :             if( pStream )
     417             :             {
     418           0 :                 pPlugin = *iter;
     419           0 :                 break;
     420             :             }
     421             :         }
     422           0 :         if( ! pPlugin )
     423           0 :             return NPERR_INVALID_INSTANCE_ERROR;
     424           0 :         if( ! pStream || pStream->getStreamType() != InputStream )
     425           0 :             return NPERR_FILE_NOT_FOUND;
     426             : 
     427           0 :         PluginInputStream* pInputStream = static_cast<PluginInputStream*>(pStream);
     428           0 :         boost::scoped_array<sal_Int8> pBytes;
     429           0 :         int   nBytes = 0;
     430           0 :         pPlugin->enterPluginCallback();
     431           0 :         while( rangeList )
     432             :         {
     433           0 :             if( pBytes && nBytes < (int)rangeList->length )
     434           0 :                 pBytes.reset();
     435           0 :             if( ! pBytes ) {
     436           0 :                 nBytes = rangeList->length;
     437           0 :                 pBytes.reset(new sal_Int8[ nBytes ]);
     438             :             }
     439             :             int nRead =
     440           0 :                 pInputStream->read( rangeList->offset, pBytes.get(), rangeList->length );
     441           0 :             int nPos = 0;
     442             :             int nNow;
     443           0 :             do
     444             :             {
     445           0 :                 nNow = pPlugin->getPluginComm()->
     446           0 :                     NPP_WriteReady( &pPlugin->getNPPInstance(),
     447           0 :                                     stream );
     448           0 :                 nNow = pPlugin->getPluginComm()->
     449           0 :                     NPP_Write( &pPlugin->getNPPInstance(),
     450             :                                stream,
     451             :                                rangeList->offset + nPos,
     452             :                                nNow,
     453           0 :                                pBytes.get()+nPos );
     454           0 :                 nPos += nNow;
     455           0 :                 nRead -= nNow;
     456           0 :             } while( nRead > 0 && nNow );
     457           0 :             rangeList = rangeList->next;
     458             :         }
     459           0 :         pPlugin->leavePluginCallback();
     460             : 
     461           0 :         return NPERR_NO_ERROR;
     462             :     }
     463             : 
     464           0 :     void SAL_CALL NP_LOADDS  NPN_Status( NPP instance, const char* message )
     465             :     {
     466             :         TRACE( "NPN_Status" );
     467           0 :         XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     468           0 :         if( ! pImpl )
     469           0 :             return;
     470             : 
     471             :         try
     472             :         {
     473           0 :             pImpl->enterPluginCallback();
     474           0 :             pImpl->getPluginContext()->
     475           0 :                 displayStatusText( pImpl, OStringToOUString( message, pImpl->getTextEncoding() ) );
     476           0 :             pImpl->leavePluginCallback();
     477             :         }
     478           0 :         catch( const ::com::sun::star::plugin::PluginException& )
     479             :         {
     480           0 :             pImpl->leavePluginCallback();
     481           0 :             return;
     482             :         }
     483             :     }
     484             : 
     485           0 :     const char* SAL_CALL NP_LOADDS  NPN_UserAgent( NPP instance )
     486             :     {
     487           0 :         static char* pAgent = strdup( "Mozilla 3.0" );
     488             : 
     489           0 :         XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     490           0 :         if( pImpl )
     491             :         {
     492           0 :             OUString UserAgent;
     493             :             try
     494             :             {
     495           0 :                 pImpl->enterPluginCallback();
     496           0 :                 UserAgent = pImpl->getPluginContext()->
     497           0 :                     getUserAgent( pImpl );
     498           0 :                 pImpl->leavePluginCallback();
     499           0 :                 if( pAgent )
     500           0 :                     free( pAgent );
     501           0 :                 pAgent = strdup( OUStringToOString( UserAgent, pImpl->getTextEncoding() ).getStr() );
     502             :             }
     503           0 :             catch( const ::com::sun::star::plugin::PluginException& )
     504             :             {
     505           0 :                 pImpl->leavePluginCallback();
     506           0 :             }
     507             :         }
     508             : 
     509             :         TRACES( "NPN_UserAgent: returning", pAgent );
     510             : 
     511           0 :         return pAgent;
     512             :     }
     513             : 
     514           0 : void SAL_CALL NP_LOADDS  NPN_Version( int* major, int* minor, int* net_major, int* net_minor )
     515             : {
     516             :     TRACE( "NPN_Version" );
     517           0 :     *major = 4;
     518           0 :     *minor = 0;
     519           0 :     *net_major = 4;
     520           0 :     *net_minor = 5;
     521           0 : }
     522             : 
     523           0 : int32_t SAL_CALL NP_LOADDS  NPN_Write( NPP instance, NPStream* stream, int32_t len,
     524             :                  void* buffer )
     525             : {
     526             :     TRACE( "NPN_Write" );
     527           0 :     XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     528           0 :     if( ! pImpl )
     529           0 :         return 0;
     530             : 
     531           0 :     PluginStream* pStream = pImpl->getStreamFromNPStream( stream );
     532           0 :     if( ! pStream || pStream->getStreamType() != OutputStream )
     533           0 :         return 0;
     534             : 
     535           0 :     pImpl->enterPluginCallback();
     536           0 :     ::com::sun::star::uno::Sequence<sal_Int8> Bytes( (sal_Int8*)buffer, len );
     537           0 :     static_cast<PluginOutputStream*>(pStream)->getOutputStream()->writeBytes( Bytes );
     538           0 :     pImpl->leavePluginCallback();
     539             : 
     540           0 :     return len;
     541             : }
     542             : 
     543             : 
     544           0 : NPError SAL_CALL NP_LOADDS  NPN_GetValue( NPP instance, NPNVariable variable, void* value )
     545             : {
     546             :     TRACEN( "NPN_GetValue: ", variable );
     547           0 :     XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );
     548             : 
     549           0 :     if( ! pImpl )
     550           0 :         return 0;
     551             : 
     552           0 :     NPError aResult( NPERR_NO_ERROR );
     553             : 
     554           0 :     switch( variable )
     555             :     {
     556             :         case NPNVxDisplay:
     557             :             // Unix only, handled in sysdep part
     558             :         case NPNVxtAppContext:
     559             :             // Unix only, handled in sysdep part
     560             :          default:
     561           0 :             aResult = NPERR_INVALID_PARAM;
     562           0 :             break;
     563             :         #ifdef MACOSX
     564             :         case 2000: // NPNVsupportsQuickDrawBool
     565             :             *(NPBool*)value = false;
     566             :             break;
     567             :         case 2001: // NPNVsupportsCoreGraphicsBool
     568             :             *(NPBool*)value = true;
     569             :             break;
     570             :         #endif
     571             :         case NPNVjavascriptEnabledBool:
     572             :             // no javascript
     573           0 :             *(NPBool*)value = false;
     574           0 :             break;
     575             :         case NPNVasdEnabledBool:
     576             :             // no SmartUpdate
     577           0 :             *(NPBool*)value = false;
     578           0 :             break;
     579             :         case NPNVisOfflineBool:
     580             :             // no offline browsing
     581           0 :             *(NPBool*)value = false;
     582           0 :             break;
     583             :     }
     584             : 
     585           0 :     return aResult;
     586             : }
     587             : 
     588           0 : void SAL_CALL NP_LOADDS  NPN_ReloadPlugins(NPBool /*reloadPages*/)
     589             : {
     590             :     TRACE( "NPN_ReloadPlugins" );
     591           0 : }
     592             : 
     593             : 
     594           0 : NPError SAL_CALL NP_LOADDS  NPN_SetValue( NPP instance,
     595             :                                           NPPVariable variable,
     596             :                                           void* value )
     597             : {
     598           0 :     NPError nError = NPERR_NO_ERROR;
     599             :     TRACEN( "NPN_SetValue ", variable );
     600             :     #ifdef MACOSX
     601             :     NPN_SetValue_Impl(instance, variable, value);
     602             :     #else
     603             :     (void)instance;
     604             :     (void)variable;
     605             :     (void)value;
     606             :     #endif
     607           0 :     return nError;
     608             : }
     609             : 
     610           0 : void SAL_CALL NP_LOADDS  NPN_InvalidateRect(NPP instance, NPRect* /*invalidRect*/)
     611             : {
     612             :     TRACE( "NPN_InvalidateRect" );
     613             : 
     614             :     #ifdef MACOSX
     615             :     NPN_ForceRedraw( instance );
     616             :     #else
     617             :     (void)instance;
     618             :     #endif
     619           0 : }
     620             : 
     621           0 : void SAL_CALL NP_LOADDS  NPN_InvalidateRegion(NPP instance, NPRegion /*invalidRegion*/)
     622             : {
     623             :     TRACE( "NPN_InvalidateRegion" );
     624             : 
     625             :     #ifdef MACOSX
     626             :     NPN_ForceRedraw( instance );
     627             :     #else
     628             :     (void)instance;
     629             :     #endif
     630           0 : }
     631             : 
     632           0 : void SAL_CALL NP_LOADDS  NPN_ForceRedraw(NPP instance)
     633             : {
     634             :     TRACE( "NPN_ForceRedraw" );
     635             :     #ifdef MACOSX
     636             :     NPN_ForceRedraw_Impl(instance);
     637             :     #else
     638             :     (void)instance;
     639             :     #endif
     640           0 : }
     641             : 
     642           6 : }
     643             : 
     644             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10