extensions/source/plugin/base/nfuncs.cxx

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