ex  extensions\source\plugin\workben            get     -   all ex_plwkb ex_inc NULL

ex  extensions\source\plugin\inc\plugin\win     get     -   all ex_piwi ex_inc NULL

ex  extensions\source\plugin\inc\plugin\unx     get     -   all ex_piux ex_inc NULL

ex  extensions\source\plugin\aqua               nmake   -   u   ex_plaqua ex_plbase NULL

ex  extensions\source\plugin\base               nmake   -   all ex_plbase ex_inc NULL

ex  extensions\source\plugin\win                nmake   -   w   ex_plwin ex_plbase ex_inc NULL

ex  extensions\source\plugin\unx                nmake   -   u   ex_plunx ex_inc NULL

ex  extensions\source\plugin\util               nmake   -   all ex_plutil ex_plbase ex_plunx.u ex_plwin.w ex_plaqua.u ex_inc NULL

..\%__SRC%\bin\pluginapp.bin %_DEST%\bin%_EXT%\pluginapp.bin

..\%__SRC%\misc\pl.component %_DEST%\xml%_EXT%\pl.component

/**************************************************************

 * 

 * Licensed to the Apache Software Foundation (ASF) under one

 * or more contributor license agreements.  See the NOTICE file

 * distributed with this work for additional information

 * regarding copyright ownership.  The ASF licenses this file

 * to you under the Apache License, Version 2.0 (the

 * "License"); you may not use this file except in compliance

 * with the License.  You may obtain a copy of the License at

 * 

 *   http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing,

 * software distributed under the License is distributed on an

 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

 * KIND, either express or implied.  See the License for the

 * specific language governing permissions and limitations

 * under the License.

 * 

 *************************************************************/

#include "rtl/ustrbuf.hxx"

#include "rtl/strbuf.hxx"

#include "plugin/impl.hxx"

#include "osl/file.h"

#include "osl/module.hxx"

using namespace rtl;

using rtl::OUStringBuffer;

using rtl::OUStringToOString;

using rtl::OString;

using rtl::OStringBuffer;

using rtl::OStringToOUString

using namespace std;

using namespace com::sun::star::uno;

using namespace com::sun::star::plugin;

namespace plugstringhelper

{

OUString getString( CFStringRef i_xString )

{

    OUStringBuffer aBuf;

    if( i_xString )

    {

        CFIndex nChars = CFStringGetLength( i_xString );

        CFRange aRange = { 0, nChars };

        aBuf.setLength( nChars );

        CFStringGetCharacters( i_xString, aRange, static_cast< UniChar* >(const_cast<sal_Unicode*>(aBuf.getStr())) );

    }

    return aBuf.makeStringAndClear();

}

OUString getString( CFURLRef i_xURL )

{

    CFStringRef xString = CFURLGetString( i_xURL );

    return getString( xString );

}

CFMutableStringRef createString( const OUString& i_rString )

{

    CFMutableStringRef xString = CFStringCreateMutable( NULL, 0 );

    if( xString )

        CFStringAppendCharacters( xString, i_rString.getStr(), i_rString.getLength() );

    return xString;

}

CFURLRef createURL( const OUString& i_rString )

{

    CFMutableStringRef xMutableString = createString( i_rString );

    CFURLRef xURL = CFURLCreateWithString( NULL, xMutableString, NULL );

    CFRelease( xMutableString );

    return xURL;

}

OUString getURLFromPath( const OUString& i_rPath )

{

    CFMutableStringRef xMutableString = createString( i_rPath );

    CFURLRef xURL = CFURLCreateWithFileSystemPath( NULL, xMutableString, kCFURLPOSIXPathStyle, true );

    CFRelease( xMutableString );

    CFStringRef xString = CFURLGetString( xURL );

    OUString aRet = getString( xString );

    CFRelease( xURL );

    return aRet;

}

CFURLRef createURLFromPath( const OUString& i_rPath )

{

    CFMutableStringRef xMutableString = createString( i_rPath );

    CFURLRef xURL = CFURLCreateWithFileSystemPath( NULL, xMutableString, kCFURLPOSIXPathStyle, true );

    return xURL;

}

OUString CFURLtoOSLURL( CFURLRef i_xURL )

{

    // make URL absolute

    CFURLRef xAbsURL = CFURLCopyAbsoluteURL( i_xURL );

    // copy system path

    CFStringRef xSysPath = CFURLCopyFileSystemPath( xAbsURL ? xAbsURL : i_xURL, kCFURLPOSIXPathStyle );

    if( xAbsURL )

        CFRelease( xAbsURL );

    OUString aSysPath( getString( xSysPath ) );

    CFRelease( xSysPath );

    OUString aFileURL;

    osl_getFileURLFromSystemPath( aSysPath.pData, &aFileURL.pData );

    return aFileURL;

}

}

using namespace plugstringhelper;

static int parsePlist( CFBundleRef i_xBundle, const OUString& i_rBundleURL , list< PluginDescription* >& io_rDescriptions )

{

    CFTypeRef xMimeDict = CFBundleGetValueForInfoDictionaryKey( i_xBundle, CFSTR("WebPluginMIMETypes"));

    int nMimetypes = 0;

    if( xMimeDict == 0 ||

        CFGetTypeID(xMimeDict) != CFDictionaryGetTypeID() ||

        (nMimetypes = CFDictionaryGetCount( static_cast<CFDictionaryRef>(xMimeDict))) <= 0 )

    {

        return 0;

    }

    // prepare an array of key and value refs

    std::vector< CFTypeRef > aKeys( nMimetypes, CFTypeRef(NULL) );

    std::vector< CFTypeRef > aValues( nMimetypes, CFTypeRef(NULL) );

    CFDictionaryGetKeysAndValues(static_cast<CFDictionaryRef>(xMimeDict), &aKeys[0], &aValues[0] );

    int nAdded = 0;

    for( int i = 0; i < nMimetypes; i++ )

    {

        // get the mimetype

        CFTypeRef xKey = aKeys[i];

        if( ! xKey || CFGetTypeID(xKey) != CFStringGetTypeID() )

            continue;

        OUString aMimetype = getString( (CFStringRef)xKey );

        // the correspoding value should be a dictionary

        CFTypeRef xDict = aValues[i];

        if( ! xDict || CFGetTypeID( xDict ) != CFDictionaryGetTypeID() )

            continue;

        // get the extension list

        CFTypeRef xExtArray = CFDictionaryGetValue( (CFDictionaryRef)xDict,  CFSTR("WebPluginExtensions" ) );

        if( !xExtArray || CFGetTypeID( xExtArray ) != CFArrayGetTypeID() )

            continue;

        OUStringBuffer aExtBuf;

        int nExtensions = CFArrayGetCount( (CFArrayRef)xExtArray );

        for( int n = 0; n < nExtensions; n++ )

        {

            CFTypeRef xExt = CFArrayGetValueAtIndex( (CFArrayRef)xExtArray, n );

            if( xExt && CFGetTypeID( xExt ) == CFStringGetTypeID() )

            {

                if( aExtBuf.getLength() > 0 )

                    aExtBuf.append( sal_Unicode(';') );

                OUString aExt( getString( (CFStringRef)xExt ) );

                if( aExt.indexOfAsciiL( "*.", 2 ) != 0 )

                    aExtBuf.appendAscii( "*." );

                aExtBuf.append( aExt );

            }

        }

        // get the description string

        CFTypeRef xDescString = CFDictionaryGetValue( (CFDictionaryRef)xDict,  CFSTR("WebPluginTypeDescription" ) );

        if( !xDescString || CFGetTypeID( xDescString ) != CFStringGetTypeID() )

            continue;

        OUString aDescription = getString( (CFStringRef)xDescString );

        PluginDescription* pNew = new PluginDescription;

        // set plugin name (path to library)

        pNew->PluginName	= i_rBundleURL;

        // set mimetype

        pNew->Mimetype 	= aMimetype;

        // set extension line

        pNew->Extension	= aExtBuf.makeStringAndClear();

        // set description

        pNew->Description= aDescription;

        io_rDescriptions.push_back( pNew );

        nAdded++;

#if OSL_DEBUG_LEVEL > 1

        fprintf( stderr,

                 "Inserting from PList:\n"

                 "    Mimetype: %s\n"

                 "    Extension: %s\n"

                 "    Description: %s\n",

                 OUStringToOString( pNew->Mimetype, RTL_TEXTENCODING_UTF8 ).getStr(),

                 OUStringToOString( pNew->Extension, RTL_TEXTENCODING_UTF8 ).getStr(),

                 OUStringToOString( pNew->Description, RTL_TEXTENCODING_UTF8 ).getStr()

                 );

#endif

    }

    return nAdded;

}

static int parseMimeString( const OUString& i_rBundleURL , list< PluginDescription* >& io_rDescriptions, const char* i_pMime )

{

    if( ! i_pMime )

        return 0;

    rtl_TextEncoding aEncoding = osl_getThreadTextEncoding();

    OStringBuffer aMIME;

    aMIME.append( i_pMime );

    if( aMIME.getLength() < 1 )

        return 0;

    OString aLine = aMIME.makeStringAndClear();

    int nAdded = 0;

    sal_Int32 nIndex = 0;

    while( nIndex != -1 )

    {

        OString aType = aLine.getToken( 0, ';', nIndex );

        sal_Int32 nTypeIndex = 0;

        OString aMimetype	= aType.getToken( 0, ':', nTypeIndex );

        OString aExtLine	= aType.getToken( 0, ':', nTypeIndex );

        if( nTypeIndex < 0 ) // ensure at least three tokens

            continue;

        OString aDesc		= aType.getToken( 0, ':', nTypeIndex );

        // create extension list string

        sal_Int32 nExtIndex = 0;

        OStringBuffer aExtension;

        while( nExtIndex != -1 )

        {

            OString aExt = aExtLine.getToken( 0, ',', nExtIndex);

            if( aExt.indexOf( "*." ) != 0 )

                aExtension.append( "*." );

            aExtension.append( aExt );

            if( nExtIndex != -1 )

                aExtension.append( ';' );

        }

        PluginDescription* pNew = new PluginDescription;

        // set plugin name (path to library)

        pNew->PluginName	= i_rBundleURL;

        // set mimetype

        pNew->Mimetype 	= OStringToOUString( aMimetype, aEncoding );

        // set extension line

        pNew->Extension	= OStringToOUString( aExtension.makeStringAndClear(), aEncoding );

        // set description

        pNew->Description= OStringToOUString( aDesc, aEncoding );

        io_rDescriptions.push_back( pNew );

        nAdded++;

#if OSL_DEBUG_LEVEL > 1

        fprintf( stderr,

                 "Inserting from mime string:\n"

                 "    Mimetype: %s\n"

                 "    Extension: %s\n"

                 "    Description: %s\n",

                 OUStringToOString( pNew->Mimetype, aEncoding ).getStr(),

                 OUStringToOString( pNew->Extension, aEncoding ).getStr(),

                 OUStringToOString( pNew->Description, aEncoding ).getStr()

                 );

#endif

    }

    return nAdded;

}

// this is so ugly it you want to tear your eyes out

static OUString GetNextPluginStringFromHandle(Handle h, short *index)

{

    char* pPascalBytes = (*h + *index);

    sal_uInt32 nLen = (unsigned char)pPascalBytes[0];

    OStringBuffer aBuf( nLen );

    aBuf.append( pPascalBytes+1, nLen );

    *index += nLen + 1;

    return OStringToOUString( aBuf.makeStringAndClear(), RTL_TEXTENCODING_UTF8 );

}

static int parseMimeResource( CFBundleRef i_xBundle,

                              oslModule& i_rMod,

                              const OUString& i_rBundleURL,

                              list< PluginDescription* >& io_rDescriptions )

{

    int nAdded = 0;

    // just to hurt our eyes more there is an alternative mimetype function plus the possibility

    // of a resource fork. Must be a case of think different.

    #if __LP64__

    int

    #else

    SInt16

    #endif

    xRes = 0;

    BPSupportedMIMETypes aMIMETypesStrangeStruct = {kBPSupportedMIMETypesStructVers_1, NULL, NULL};

    BP_GetSupportedMIMETypesUPP pBPGetSupp = (BP_GetSupportedMIMETypesUPP)osl_getAsciiFunctionSymbol( i_rMod, "BP_GetSupportedMIMETypes" );

    if( pBPGetSupp &&

        noErr == pBPGetSupp( &aMIMETypesStrangeStruct, 0 ) &&

        aMIMETypesStrangeStruct.typeStrings )

    {

        HLock( aMIMETypesStrangeStruct.typeStrings );

        if( aMIMETypesStrangeStruct.infoStrings )  // it's possible some plugins have infoStrings missing

            HLock( aMIMETypesStrangeStruct.infoStrings );

    }

    else // Try to get data from the resource fork

    {

        xRes = CFBundleOpenBundleResourceMap( i_xBundle );

        if( xRes > 0 )

        {

            aMIMETypesStrangeStruct.typeStrings = Get1Resource('STR#', 128);

            if( aMIMETypesStrangeStruct.typeStrings )

            {

                DetachResource( aMIMETypesStrangeStruct.typeStrings );

                HLock( aMIMETypesStrangeStruct.typeStrings );

                aMIMETypesStrangeStruct.infoStrings = Get1Resource('STR#', 127);

                if( aMIMETypesStrangeStruct.infoStrings )

                {

                    DetachResource( aMIMETypesStrangeStruct.infoStrings );

                    HLock( aMIMETypesStrangeStruct.infoStrings );

                }

            }

        }

    }

    if( aMIMETypesStrangeStruct.typeStrings && aMIMETypesStrangeStruct.infoStrings )

    {

        short nVariantCount = (**(short**)aMIMETypesStrangeStruct.typeStrings) / 2;

        // Fill in the info struct based on the data in the BPSupportedMIMETypes struct

        // this is an array of pascal string of unknown (!) encoding

        // whoever thought of this deserves a fair beating

        short mimeIndex = 2;

        short descriptionIndex = 2;

        for( int i = 0; i < nVariantCount; i++ )

        {

            OUString aMimetype = GetNextPluginStringFromHandle( aMIMETypesStrangeStruct.typeStrings, &mimeIndex );

            OUString aExtLine = GetNextPluginStringFromHandle( aMIMETypesStrangeStruct.typeStrings, &mimeIndex );

            OUString aDescription;

            if( aMIMETypesStrangeStruct.infoStrings )

                aDescription = GetNextPluginStringFromHandle( aMIMETypesStrangeStruct.infoStrings, &descriptionIndex );

            // create extension list string

            sal_Int32 nExtIndex = 0;

            OUStringBuffer aExtension;

            while( nExtIndex != -1 )

            {

                OUString aExt = aExtLine.getToken( 0, ',', nExtIndex);

                if( aExt.indexOfAsciiL( "*.", 2 ) != 0 )

                    aExtension.appendAscii( "*." );

                aExtension.append( aExt );

                if( nExtIndex != -1 )

                    aExtension.append( sal_Unicode(';') );

            }

            PluginDescription* pNew = new PluginDescription;

            // set plugin name (path to library)

            pNew->PluginName	= i_rBundleURL;

            // set mimetype

            pNew->Mimetype 	= aMimetype;

            // set extension line

            pNew->Extension	= aExtension.makeStringAndClear();

            // set description

            pNew->Description= aDescription;

            io_rDescriptions.push_back( pNew );

            nAdded++;

            #if OSL_DEBUG_LEVEL > 1

            fprintf( stderr,

                     "Inserting from resource:\n"

                     "    Mimetype: %s\n"

                     "    Extension: %s\n"

                     "    Description: %s\n",

                     OUStringToOString( pNew->Mimetype, RTL_TEXTENCODING_UTF8 ).getStr(),

                     OUStringToOString( pNew->Extension, RTL_TEXTENCODING_UTF8 ).getStr(),

                     OUStringToOString( pNew->Description, RTL_TEXTENCODING_UTF8 ).getStr()

                     );

            #endif

        }

    }

    // clean up

    if( aMIMETypesStrangeStruct.typeStrings )

    {

        HUnlock( aMIMETypesStrangeStruct.typeStrings );

        DisposeHandle( aMIMETypesStrangeStruct.typeStrings );

    }

    if( aMIMETypesStrangeStruct.infoStrings )

    {

        HUnlock( aMIMETypesStrangeStruct.infoStrings );

        DisposeHandle( aMIMETypesStrangeStruct.infoStrings );

    }

    if( xRes )

        CFBundleCloseBundleResourceMap( i_xBundle, xRes );

    return nAdded;

}

// check some known bad plugins to avoid crashes

static bool checkBlackList( CFBundleRef i_xBundle )

{

    OUString aBundleName;

    CFTypeRef bundlename = CFBundleGetValueForInfoDictionaryKey( i_xBundle, CFSTR("CFBundleName"));

    if( bundlename && CFGetTypeID(bundlename) == CFStringGetTypeID() )

        aBundleName = getString( static_cast<CFStringRef>(bundlename) );

    OUString aBundleVersion;

    CFTypeRef bundleversion = CFBundleGetValueForInfoDictionaryKey( i_xBundle, CFSTR("CFBundleVersion"));

    if( bundleversion && CFGetTypeID(bundleversion) == CFStringGetTypeID() )

        aBundleVersion = getString( static_cast<CFStringRef>(bundleversion) );

    bool bReject = false;

    // #i102735# VLC plugin prior to 1.0 tends to crash 

    if( aBundleName.equalsAscii( "VLC Plug-in" ) )

    {

        sal_Int32 nIndex = 0;

        OUString aMajor( aBundleVersion.getToken( 0, '.', nIndex ) );

        if( aMajor.toInt32() < 1 )

        {

            bReject = true;

        }

    }

    // #i103674# Garmin Communicator Plugin crashes

    else if( aBundleName.equalsAscii( "Garmin Communicator Plugin" ) )

    {

        bReject = true;

    }

    #if OSL_DEBUG_LEVEL > 1

    if( bReject )

        fprintf( stderr, "rejecting plugin \"%s\" version %s\n",

                 OUStringToOString( aBundleName, RTL_TEXTENCODING_UTF8 ).getStr(),

                 OUStringToOString( aBundleVersion, RTL_TEXTENCODING_UTF8 ).getStr()

                 );

    #endif

    return bReject;

}

static int getPluginDescriptions( CFBundleRef i_xBundle , list< PluginDescription* >& io_rDescriptions )

{

    int nDescriptions = 0;

    if( ! i_xBundle )

        return nDescriptions;

    if( checkBlackList( i_xBundle ) )

        return 0;

    OUString aPlugURL;

    CFURLRef xURL = CFBundleCopyBundleURL( i_xBundle );

    aPlugURL = getString( xURL );

    CFRelease( xURL );

    #if OSL_DEBUG_LEVEL > 1

    OUString aPlugName, aPlugDescription;

    CFTypeRef name = CFBundleGetValueForInfoDictionaryKey( i_xBundle, CFSTR("WebPluginName"));

    if( name && CFGetTypeID(name) == CFStringGetTypeID() )

      aPlugName = getString( static_cast<CFStringRef>(name) );

    CFTypeRef description = CFBundleGetValueForInfoDictionaryKey( i_xBundle, CFSTR("WebPluginDescription"));

    if( description && CFGetTypeID(description) == CFStringGetTypeID() )

        aPlugDescription = getString( static_cast<CFStringRef>(description) );

    fprintf( stderr, "URL: %s\nname: %s\ndescription: %s\n",

        OUStringToOString( aPlugURL, RTL_TEXTENCODING_UTF8 ).getStr(),

        OUStringToOString( aPlugName, RTL_TEXTENCODING_UTF8 ).getStr(),

        OUStringToOString( aPlugDescription, RTL_TEXTENCODING_UTF8 ).getStr()

        );

    #endif

    // get location of plugin library

    CFURLRef xLibURL = CFBundleCopyExecutableURL( i_xBundle );

    if( ! xLibURL )

        return 0;

    // get the file system path

    OUString aModuleURL( CFURLtoOSLURL( xLibURL ) );

    CFRelease( xLibURL );

    #if OSL_DEBUG_LEVEL > 1

    fprintf( stderr, "exec URL = %s\n", OUStringToOString( aModuleURL, RTL_TEXTENCODING_UTF8 ).getStr() );

    #endif

    /* TODO: originally the C++ wrapper for oslModule was used here, but that led to

       mysterious crashes in the event loop (pointing to heap corruption). Why using

       the C style oslModule should fix this is completely unknown. It may be that

       we have just hidden the heap corruption a little more.

    */

    oslModule aMod = osl_loadModule( aModuleURL.pData, SAL_LOADMODULE_DEFAULT );

    if( ! aMod )

        return 0;

    // check for at least the init function of a plugin

    if( ! osl_getAsciiFunctionSymbol( aMod, "NP_Initialize") &&

        ! osl_getAsciiFunctionSymbol( aMod, "NP_GetEntryPoints" ) )

    {

        return 0;

    }

    // ask the plist of the bundle for mimetypes

    nDescriptions = parsePlist( i_xBundle, aPlugURL, io_rDescriptions );

    if( nDescriptions )

    {

        osl_unloadModule( aMod );

        return nDescriptions;

    }

    // resolve the symbol that might get us the mimetypes

    const char* (*pGetMimeDescription)() = (const char*(*)())osl_getAsciiFunctionSymbol( aMod, "_NP_GetMIMEDescription" );

    if( pGetMimeDescription )

    {

        const char* pMime = pGetMimeDescription();

        if( pMime )

        {

            nDescriptions = parseMimeString( aPlugURL, io_rDescriptions, pMime );

            if( nDescriptions )

            {

                osl_unloadModule( aMod );

                return nDescriptions;

            }

        }

    }

    // and as last resort check the resource of the bundle

    nDescriptions = parseMimeResource( i_xBundle, aMod, aPlugURL, io_rDescriptions );

    osl_unloadModule( aMod );

    return nDescriptions;

}

// Unix specific implementation

static bool CheckPlugin( const OUString& rPath, list< PluginDescription* >& rDescriptions )

{

#if OSL_DEBUG_LEVEL > 1

    fprintf( stderr, "Trying path %s ... ", OUStringToOString( rPath, RTL_TEXTENCODING_UTF8 ).getStr() );

#endif

    CFURLRef xURL = createURL( rPath );    

    CFArrayRef xBundles = CFBundleCreateBundlesFromDirectory( NULL, xURL, CFSTR("plugin") );

    if( ! xBundles )

        return false;

    CFIndex nBundles = CFArrayGetCount( xBundles );

#if OSL_DEBUG_LEVEL > 1

    fprintf( stderr, "got %d bundles\n", (int)nBundles );

#endif

    int nDescriptions = 0;

    for( CFIndex i = 0; i < nBundles; i++ )

    {

        CFBundleRef xBundle = (CFBundleRef)CFArrayGetValueAtIndex( xBundles, i );

        nDescriptions += getPluginDescriptions( xBundle, rDescriptions );

        CFRelease( xBundle );

    }

    CFRelease( xBundles );

	return nDescriptions > 0;

}

static OUString FindFolderURL(  FSVolumeRefNum vRefNum, OSType folderType )

{

    OUString aRet;

    FSRef aFSRef;

    OSErr err = FSFindFolder( vRefNum, folderType, kDontCreateFolder, &aFSRef );

    if( err == noErr )

    {

        CFURLRef xURL = CFURLCreateFromFSRef( NULL, &aFSRef );

        aRet = getString( xURL );

        CFRelease( xURL );

    }

    return aRet;

}

Sequence<PluginDescription> XPluginManager_Impl::impl_getPluginDescriptions() throw()

{

	static Sequence<PluginDescription> aDescriptions;

	static sal_Bool bHavePlugins = sal_False;

	if( ! bHavePlugins )

	{

        std::list<PluginDescription*> aPlugins;

        static const char* pNPXPluginPath = getenv( "MOZ_PLUGIN_PATH" );

        // get directories

        std::list< OUString > aPaths;

        if( pNPXPluginPath )

        {

            CFMutableStringRef xMutableString = CFStringCreateMutable( NULL, 0 );

            CFStringAppendCString( xMutableString, pNPXPluginPath, kCFStringEncodingUTF8 );

            CFURLRef xURL = CFURLCreateWithFileSystemPath( NULL, xMutableString, kCFURLPOSIXPathStyle, true );

            CFRelease( xMutableString );

            aPaths.push_back( getString( xURL ) );

            CFRelease( xURL );

        }

        OUString aPath = FindFolderURL( kUserDomain, kInternetPlugInFolderType );

        if( aPath.getLength() )

            aPaths.push_back( aPath );

        aPath = FindFolderURL( kLocalDomain, kInternetPlugInFolderType );

        if( aPath.getLength() )

            aPaths.push_back( aPath );

        aPath = FindFolderURL( kOnAppropriateDisk, kInternetPlugInFolderType );

        if( aPath.getLength() )

            aPaths.push_back( aPath );

		const Sequence< ::OUString >& rPaths( PluginManager::getAdditionalSearchPaths() );

		for( sal_Int32 i = 0; i < rPaths.getLength(); i++ )

        {

            aPaths.push_back( getURLFromPath( rPaths.getConstArray()[i] ) );

        }

		for( std::list< OUString >::const_iterator it = aPaths.begin(); it != aPaths.end(); ++it )

		{

            OUString aPath( *it );

#if OSL_DEBUG_LEVEL > 1

            fprintf( stderr, "check path %s\n", OUStringToOString( *it, RTL_TEXTENCODING_UTF8 ).getStr() );

#endif

            CheckPlugin( aPath, aPlugins );

		}

        // create return value

		aDescriptions = Sequence<PluginDescription>( aPlugins.size() );

#if OSL_DEBUG_LEVEL > 1

        fprintf( stderr, "found %d plugins\n", (int)aPlugins.size() );

#endif

		list<PluginDescription*>::iterator iter;

        sal_Int32 nPlug = 0;

		for( iter = aPlugins.begin(); iter != aPlugins.end(); ++iter )

		{

			aDescriptions.getArray()[ nPlug++ ] = **iter;

			delete *iter;

		}

		aPlugins.clear();

		bHavePlugins = sal_True;

	}

	return aDescriptions;

}

#**************************************************************

#  

#  Licensed to the Apache Software Foundation (ASF) under one

#  or more contributor license agreements.  See the NOTICE file

#  distributed with this work for additional information

#  regarding copyright ownership.  The ASF licenses this file

#  to you under the Apache License, Version 2.0 (the

#  "License"); you may not use this file except in compliance

#  with the License.  You may obtain a copy of the License at

#  

#    http://www.apache.org/licenses/LICENSE-2.0

#  

#  Unless required by applicable law or agreed to in writing,

#  software distributed under the License is distributed on an

#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

#  KIND, either express or implied.  See the License for the

#  specific language governing permissions and limitations

#  under the License.

#  

#**************************************************************

PRJ=..$/..$/..

PRJNAME=extensions

TARGET=plaqua

#ENABLE_EXCEPTIONS=TRUE

#TARGETTYPE=CUI

.INCLUDE :  ..$/util$/makefile.pmk

.IF "$(GUIBASE)"!="aqua" || "$(WITH_MOZILLA)"=="NO"

dummy:

	@echo "Nothing to build for GUIBASE $(GUIBASE)."

.ELSE

# --- Files --------------------------------------------------------

INCPRE+=-I$(SOLARINCDIR)$/mozilla$/plugin

.IF "$(SOLAR_JAVA)" != ""

INCPRE+=-I$(SOLARINCDIR)$/mozilla$/java

INCPRE+=-I$(SOLARINCDIR)$/mozilla$/nspr

INCPRE+=-I$(SOLARINCDIR)$/npsdk

CDEFS+=-DOJI

.ENDIF

.IF "$(GUIBASE)"=="aqua"

CFLAGSCXX+=$(OBJCXXFLAGS)

.ENDIF  # "$(GUIBASE)"=="aqua"

SLOFILES=\

	$(SLO)$/macmgr.obj      \

    $(SLO)$/sysplug.obj

#APP1TARGET=pluginapp.bin

#APP1OBJS=$(OBJFILES)

#APP1STDLIBS=\

#	$(TOOLSLIB) 				\

#	$(VOSLIB)					\

#	$(SALLIB)

#APP1DEF=	$(MISC)$/$(TARGET).def

# --- Targets ------------------------------------------------------

.INCLUDE :	target.mk

.ENDIF # $(GUIBASE)==aqua

/**************************************************************

 * 

 * Licensed to the Apache Software Foundation (ASF) under one

 * or more contributor license agreements.  See the NOTICE file

 * distributed with this work for additional information

 * regarding copyright ownership.  The ASF licenses this file

 * to you under the Apache License, Version 2.0 (the

 * "License"); you may not use this file except in compliance

 * with the License.  You may obtain a copy of the License at

 * 

 *   http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing,

 * software distributed under the License is distributed on an

 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

 * KIND, either express or implied.  See the License for the

 * specific language governing permissions and limitations

 * under the License.

 * 

 *************************************************************/

#include <cstdarg>

#include <sys/types.h>

#include <signal.h>

#include <sys/wait.h>

#include <osl/thread.h>

#include <plugin/impl.hxx>

extern NPNetscapeFuncs aNPNFuncs;

#include <tools/debug.hxx>

using namespace rtl;

using namespace plugstringhelper;

#if OSL_DEBUG_LEVEL > 1

void TRACE( char const * s );

void TRACEN( char const * s, long n );

#else

#define TRACE(x)

#define TRACEN(x,n)

#endif

struct FakeEventRecord : public EventRecord

{

    FakeEventRecord()

    {

        memset( this, 0, sizeof(EventRecord) );

        ::GetGlobalMouse( &where );

        when = ::TickCount();

        modifiers = ::GetCurrentEventKeyModifiers();

    }

};

@interface OOoPluginView : NSView

{

    XPlugin_Impl*   m_pImpl;

    MacPluginComm*  m_pCom;

}

-(id)initWithInstance: (XPlugin_Impl*)i_pImpl pluginComm: (MacPluginComm*)i_pCom frame: (NSRect)i_aRect;

-(void)drawRect: (NSRect)i_aRect;

-(BOOL)isOpaque;

-(BOOL)isFlipped;

// NSResponder

-(void)mouseMoved:   (NSEvent*)i_pEvent;

-(void)mouseDown:    (NSEvent*)i_pEvent;

-(void)mouseDragged: (NSEvent*)i_pEvent;

-(void)mouseUp:      (NSEvent*)i_pEvent;

-(void)rightMouseDown:    (NSEvent*)i_pEvent;

-(void)rightMouseDragged: (NSEvent*)i_pEvent;

-(void)rightMouseUp:      (NSEvent*)i_pEvent;

-(void)otherMouseDown:    (NSEvent*)i_pEvent;

-(void)otherMouseDragged: (NSEvent*)i_pEvent;

-(void)otherMouseUp:      (NSEvent*)i_pEvent;

-(void)mouseEntered: (NSEvent*)i_pEvent;

-(void)mouseExited:  (NSEvent*)i_pEvent;

@end

@implementation OOoPluginView

-(id)initWithInstance: (XPlugin_Impl*)i_pImpl pluginComm: (MacPluginComm*)i_pCom frame: (NSRect) i_aRect

{

    if( (self = [super initWithFrame: i_aRect]) )

    {

        m_pImpl = i_pImpl;

        m_pCom = i_pCom;

    }

    return self;

}

-(void)drawRect: (NSRect) i_aRect

{

    m_pCom->drawView( m_pImpl );

}

-(BOOL)isOpaque

{

    return NO;

}

-(BOOL)isFlipped

{

    return YES;

}

// NSResponder

-(void)mouseMoved:   (NSEvent*)i_pEvent

{

    FakeEventRecord aRec;

    aRec.what = osEvt + 18; // NPEventType_AdjustCursorEvent

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)mouseDown:    (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = mouseDown;

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)mouseDragged: (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = aRec.what = osEvt + 18; // NPEventType_AdjustCursorEvent

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)mouseUp:      (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = mouseUp;

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)rightMouseDown:    (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = mouseDown;

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)rightMouseDragged: (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = aRec.what = osEvt + 18; // NPEventType_AdjustCursorEvent

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)rightMouseUp:      (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = mouseUp;

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)otherMouseDown:    (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = mouseDown;

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)otherMouseDragged: (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = aRec.what = osEvt + 18; // NPEventType_AdjustCursorEvent

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)otherMouseUp:      (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = mouseUp;

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)mouseEntered: (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = aRec.what = osEvt + 18; // NPEventType_AdjustCursorEvent

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

-(void)mouseExited:  (NSEvent*)i_pEvent;

{

    FakeEventRecord aRec;

    aRec.what = aRec.what = osEvt + 18; // NPEventType_AdjustCursorEvent

    m_pCom->NPP_HandleEvent( m_pImpl->getNPPInstance(), &aRec );

}

@end

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

MacPluginComm::MacPluginComm( const rtl::OUString& i_rMimetype, const rtl::OUString& i_rBundle, NSView* i_pParent )

	: PluginComm( OUStringToOString( i_rBundle, RTL_TEXTENCODING_UTF8 ) ),

      m_xBundle( NULL ),

      m_hPlugLib( NULL ),

      m_pNullTimer( NULL )

{

	// initialize plugin function table

	memset( &m_aNPPfuncs, 0, sizeof( m_aNPPfuncs ) );

    // load the bundle

    CFURLRef xURL = createURL( i_rBundle );

    m_xBundle = CFBundleCreate( NULL, xURL );

    CFRelease( xURL );

    if( m_xBundle )

    {

        // ask the plugin library

        // first get its location

        CFURLRef xLibURL = CFBundleCopyExecutableURL( m_xBundle );

        if( xLibURL )

        {

            // get the file system path

            rtl::OUString aModuleURL( CFURLtoOSLURL( xLibURL ) );

            CFRelease( xLibURL );

            m_hPlugLib = osl_loadModule( aModuleURL.pData, SAL_LOADMODULE_DEFAULT );

            #if OSL_DEBUG_LEVEL > 1

            if( ! m_hPlugLib )

                fprintf( stderr, "module %s could not be loaded\n", OUStringToOString( aModuleURL, RTL_TEXTENCODING_UTF8 ).getStr() );

            #endif

        }

        #if OSL_DEBUG_LEVEL > 1

        else

            fprintf( stderr, "bundle %s has no exectutable URL\n", OUStringToOString( i_rBundle, RTL_TEXTENCODING_UTF8 ).getStr() );

        #endif

    }

    else

    {

        #if OSL_DEBUG_LEVEL > 1

        fprintf( stderr, "bundle %s could not be loaded\n", OUStringToOString( i_rBundle, RTL_TEXTENCODING_UTF8 ).getStr() );

        #endif

    }

    DBG_ASSERT( m_xBundle && m_hPlugLib, "loading plugin bundle failed!" );

    m_aNPPfuncs.size = sizeof( m_aNPPfuncs );

    m_aNPPfuncs.version = 0;

	m_eCall = eNP_Initialize;

	execute();

}

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

MacPluginComm::~MacPluginComm()

{

	if( m_hPlugLib )

	{

		// NPP_Shutdown();

		NPError (*pShutdown)();

		if( retrieveFunction( "NP_Shutdown", (void**)&pShutdown ) )

		{

            NPError nErr = (*pShutdown)(); (void)nErr;

			DBG_ASSERT( nErr == NPERR_NO_ERROR, "NP_Shutdown() failed!" );

		}

        osl_unloadModule( m_hPlugLib );

	}

    if( m_xBundle )

        CFRelease( m_xBundle );

}

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

sal_Bool MacPluginComm::retrieveFunction( const char* i_pName, void** o_ppFunc ) const

{

	if( ! m_hPlugLib || ! o_ppFunc )

		return sal_False;

	*o_ppFunc = (void*)osl_getAsciiFunctionSymbol( m_hPlugLib, i_pName );

    if( ! *o_ppFunc && m_xBundle )

    {

        rtl::OUString aName( OUString::createFromAscii( *i_pName == '_' ? i_pName+1 : i_pName ) );

        CFStringRef xName = createString( aName );

        if( xName )

        {

            *o_ppFunc =  CFBundleGetFunctionPointerForName( m_xBundle, xName );

            CFRelease( xName );

        }

    }

	return (*o_ppFunc != NULL);

}

IMPL_LINK( MacPluginComm, NullTimerHdl, void*, EMPTYARG )

{

    // note: this is a Timer handler, we are already protected by the SolarMutex

    FakeEventRecord aRec;

    aRec.what = nullEvent;

    aRec.where.h = aRec.where.v = 20000;

    for( std::list< XPlugin_Impl* >::iterator it = m_aNullEventClients.begin();

         it != m_aNullEventClients.end(); ++it )

    {

        SysPlugData& rPlugData( (*it)->getSysPlugData() );

        if( rPlugData.m_pPlugView ) // for safety do not dispatch null events before first NPP_SetWindow

            (*m_aNPPfuncs.event)( (*it)->getNPPInstance(), &aRec );

    }

    return 0;

}

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

long MacPluginComm::doIt()

{

	long nRet = 0;

	switch( m_eCall )

	{

	case eNP_Initialize:

	{

        TRACE( "eNP_Initialize" );

        NPError (*pInit)( NPNetscapeFuncs* );

        if( retrieveFunction( "NP_Initialize", (void**)&pInit ) )

        {

            nRet = (*pInit)( &aNPNFuncs );

            NPError nErr = NPERR_NO_ERROR;

            NPError (*pEntry)( NPPluginFuncs* );

            retrieveFunction( "NP_GetEntryPoints", (void**)&pEntry );

            nErr = (*pEntry)( &m_aNPPfuncs );

            DBG_ASSERT( nErr == NPERR_NO_ERROR, "NP_GetEntryPoints() failed!" );            

        }

        else

        {

            nRet = NPERR_GENERIC_ERROR;

        }

        DBG_ASSERT( nRet == NPERR_NO_ERROR, "### NP_Initialize() failed!" );

	}

	break;

	case eNPP_Destroy:

        if( m_aNullEventClients.empty() )

            delete m_pNullTimer, m_pNullTimer = NULL;

        TRACE( "eNPP_Destroy" );

		nRet = (m_aNPPfuncs.destroy

				? (*m_aNPPfuncs.destroy)(

					(NPP)m_aArgs[0],

					(NPSavedData**)m_aArgs[1] )

				: NPERR_GENERIC_ERROR);

		break;

	case eNPP_DestroyStream:

        TRACE( "eNPP_DestroyStream" );

		nRet =  (m_aNPPfuncs.destroystream

				 ? (*m_aNPPfuncs.destroystream)(

					 (NPP)m_aArgs[0],

					 (NPStream*)m_aArgs[1],

					 (NPError)(sal_IntPtr)m_aArgs[2] )

				 : NPERR_GENERIC_ERROR);

		break;

	case eNPP_New:

        TRACE( "eNPP_New" );

		nRet = (m_aNPPfuncs.newp

				? (*m_aNPPfuncs.newp)(

					(NPMIMEType)m_aArgs[0],

					(NPP)m_aArgs[1],

					(uint16)(sal_IntPtr)m_aArgs[2],

					(int16)(sal_IntPtr)m_aArgs[3],

					(char**)m_aArgs[4],

					(char**)m_aArgs[5],

					(NPSavedData*)m_aArgs[6] )

				: NPERR_GENERIC_ERROR);

        if( ! m_pNullTimer && m_aNPPfuncs.event )

        {

            m_pNullTimer = new AutoTimer();

            m_pNullTimer->SetTimeout( 50 );

            m_pNullTimer->SetTimeoutHdl( LINK( this, MacPluginComm, NullTimerHdl ) );

            m_pNullTimer->Start();

        }

		break;

	case eNPP_NewStream:

        TRACE( "eNPP_NewStream" );

		nRet = (m_aNPPfuncs.newstream

				? (*m_aNPPfuncs.newstream)(

					(NPP)m_aArgs[0],

					(NPMIMEType)m_aArgs[1],

					(NPStream*)m_aArgs[2],

					(NPBool)(sal_IntPtr)m_aArgs[3],

					(uint16*)m_aArgs[4] )

				: NPERR_GENERIC_ERROR);

		break;

	case eNPP_Print:

        TRACE( "eNPP_Print" );

		if (m_aNPPfuncs.print)

			(*m_aNPPfuncs.print)(

				(NPP)m_aArgs[0],

				(NPPrint*)m_aArgs[1] );

		break;

	case eNPP_SetWindow:

    {

        TRACE( "eNPP_SetWindow" );

        nRet = (m_aNPPfuncs.setwindow

				? (*m_aNPPfuncs.setwindow)(

					(NPP)m_aArgs[0],

                    (NPWindow*)m_aArgs[1] )

				: NPERR_GENERIC_ERROR);

		break;

    }

	case eNPP_HandleEvent:

    {

        TRACE( "eNPP_HandleEvent" );

        nRet = (m_aNPPfuncs.event

				? (*m_aNPPfuncs.event)(

					(NPP)m_aArgs[0],

                    m_aArgs[1] )

				: NPERR_GENERIC_ERROR);

		break;

    }

	case eNPP_StreamAsFile:

        TRACE( "eNPP_StreamAsFile" );

		if (m_aNPPfuncs.asfile)

			(*m_aNPPfuncs.asfile)(

				(NPP)m_aArgs[0],

				(NPStream*)m_aArgs[1],

				(char*)m_aArgs[2] );

		break;

	case eNPP_URLNotify:

        TRACE( "eNPP_URLNotify" );

		if (m_aNPPfuncs.urlnotify)

			(*m_aNPPfuncs.urlnotify)(

				(NPP)m_aArgs[0],

				(char*)m_aArgs[1],

				(NPReason)(sal_IntPtr)m_aArgs[2],

				m_aArgs[3] );

		break;

	case eNPP_Write:

        TRACEN( "eNPP_Write n=", (int32)m_aArgs[3] );

		nRet = (m_aNPPfuncs.write

				? (*m_aNPPfuncs.write)(

					(NPP)m_aArgs[0],

					(NPStream*)m_aArgs[1],

					(int32)m_aArgs[2],

					(int32)m_aArgs[3],

					m_aArgs[4] )

				: 0);

		break;

	case eNPP_WriteReady:

        TRACE( "eNPP_WriteReady" );

		nRet = (m_aNPPfuncs.writeready

				? (*m_aNPPfuncs.writeready)(

					(NPP)m_aArgs[0],

					(NPStream*)m_aArgs[1] )

				: 0);

		break;

	case eNPP_GetValue:

        TRACE( "eNPP_GetValue" );

		nRet = (m_aNPPfuncs.getvalue

				? (*m_aNPPfuncs.getvalue)(

					(NPP)m_aArgs[0],

					(NPPVariable)(int)m_aArgs[1],

					m_aArgs[2] )

				: NPERR_GENERIC_ERROR);

		break;

	case eNPP_SetValue:

        TRACE( "eNPP_SetValue" );

		nRet = (m_aNPPfuncs.setvalue

				? (*m_aNPPfuncs.setvalue)(

					(NPP)m_aArgs[0],

					(NPNVariable)(int)m_aArgs[1],

					m_aArgs[2] )

				: NPERR_GENERIC_ERROR);

		break;

	case eNPP_Shutdown:

	{

        TRACE( "eNPP_Shutdown" );

		NPP_ShutdownUPP pFunc;

		if (retrieveFunction( "NPP_Shutdown", (void**)&pFunc ))

			(*pFunc)();

	}

	break;

    case eNPP_Initialize:

        TRACE( "eNPP_Initialize" );

        OSL_ENSURE( false, "NPP_Initialize: not implemented!" );

	    break;

    case eNPP_GetJavaClass:

        TRACE( "eNPP_GetJavaClass" );

        OSL_ENSURE( false, "NPP_GetJavaClass: not implemented!" );

	    break;

	}

	return nRet;

}

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

NPError MacPluginComm::NPP_Destroy( XPlugin_Impl* i_pImpl, NPSavedData** save )

{

    // remove from NullEvent timer

    m_aNullEventClients.remove( i_pImpl );

    NPError nErr = NPP_Destroy( i_pImpl->getNPPInstance(), save );

    // release plugin view

    SysPlugData& rPlugData( i_pImpl->getSysPlugData() );

    if( rPlugData.m_pPlugView )

    {

        [rPlugData.m_pPlugView removeFromSuperview];

        [rPlugData.m_pPlugView release];

        rPlugData.m_pPlugView = nil;

    }

    return nErr;

}

NPError MacPluginComm::NPP_Destroy( NPP instance, NPSavedData** save )

{

	DBG_ASSERT( m_aNPPfuncs.destroy, "### NPP_Destroy(): null pointer in NPP functions table!" );

	m_eCall = eNPP_Destroy;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)save;

	return (NPError)execute();

}

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

NPError MacPluginComm::NPP_DestroyStream( NPP instance, NPStream* stream, NPError reason )

{

	DBG_ASSERT( m_aNPPfuncs.destroystream, "### NPP_DestroyStream(): null pointer in NPP functions table!" );

	m_eCall = eNPP_DestroyStream;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)stream;

	m_aArgs[2] = (void*)reason;

	return (NPError)execute();

}

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

NPError MacPluginComm::NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,

								  char* argn[], char* argv[], NPSavedData *saved )

{

    XPlugin_Impl* pImpl = XPluginManager_Impl::getXPluginFromNPP( instance );

    DBG_ASSERT( pImpl, "no instance found" );

    if( pImpl ) // sanity check

        m_aNullEventClients.push_back( pImpl );

	DBG_ASSERT( m_aNPPfuncs.newp, "### NPP_New(): null pointer in NPP functions table!" );

    #if OSL_DEBUG_LEVEL > 1

    fprintf( stderr, "NPP_New( %s. %p, %d, %d",

             pluginType, instance, (int)mode, (int)argc );

    for( int16 i = 0; i < argc; i++ )

    fprintf( stderr, "\n%s = %s", argn[i], argv[i] );

    fprintf( stderr, ", %p )\n", saved );

    #endif

	m_eCall = eNPP_New;

	m_aArgs[0] = (void*)pluginType;

	m_aArgs[1] = (void*)instance;

	m_aArgs[2] = (void*)mode;

	m_aArgs[3] = (void*)argc;

	m_aArgs[4] = (void*)argn;

	m_aArgs[5] = (void*)argv;

	m_aArgs[6] = (void*)saved;

    return (NPError)execute();

}

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

NPError MacPluginComm::NPP_NewStream( NPP instance, NPMIMEType type, NPStream* stream,

										NPBool seekable, uint16* stype )

{

	DBG_ASSERT( m_aNPPfuncs.newstream, "### NPP_NewStream(): null pointer in NPP functions table!" );

	m_eCall = eNPP_NewStream;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)type;

	m_aArgs[2] = (void*)stream;

	m_aArgs[3] = (void*)seekable;

	m_aArgs[4] = (void*)stype;

	return (NPError)execute();

}

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

void MacPluginComm::NPP_Print( NPP instance, NPPrint* platformPrint )

{

	DBG_ASSERT( m_aNPPfuncs.print, "### NPP_Print(): null pointer in NPP functions table!" );

	m_eCall = eNPP_Print;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)platformPrint;

	execute();

}

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

NPError MacPluginComm::NPP_SetWindow( NPP instance, NPWindow* window )

{

	DBG_ASSERT( m_aNPPfuncs.setwindow, "### NPP_SetWindow(): null pointer in NPP functions table!" );

	m_eCall = eNPP_SetWindow;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)window;

	return (NPError)execute();

}

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

NPError MacPluginComm::NPP_HandleEvent( NPP instance, void* event )

{

	DBG_ASSERT( m_aNPPfuncs.event, "### NPP_HandleEvent(): null pointer in NPP functions table!" );

	m_eCall = eNPP_HandleEvent;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = event;

	return (NPError)execute();

}

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

void MacPluginComm::NPP_StreamAsFile( NPP instance, NPStream* stream, const char* fname )

{

	DBG_ASSERT( m_aNPPfuncs.asfile, "### NPP_StreamAsFile(): null pointer in NPP functions table!" );

	m_eCall = eNPP_StreamAsFile;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)stream;

	m_aArgs[2] = (void*)fname;

	execute();

}

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

void MacPluginComm::NPP_URLNotify( NPP instance, const char* url, NPReason reason, void* notifyData )

{

	DBG_ASSERT( m_aNPPfuncs.urlnotify, "### NPP_URLNotify(): null pointer in NPP functions table!" );

	m_eCall = eNPP_URLNotify;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)url;

	m_aArgs[2] = (void*)reason;

	m_aArgs[3] = notifyData;

	execute();

}

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

int32 MacPluginComm::NPP_Write( NPP instance, NPStream* stream, int32 offset, int32 len, void* buffer )

{

	DBG_ASSERT( m_aNPPfuncs.write, "### NPP_Write(): null pointer in NPP functions table!" );

	m_eCall = eNPP_Write;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)stream;

	m_aArgs[2] = (void*)offset;

	m_aArgs[3] = (void*)len;

	m_aArgs[4] = buffer;

	return (NPError)execute();

}

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

int32 MacPluginComm::NPP_WriteReady( NPP instance, NPStream* stream )

{

	DBG_ASSERT( m_aNPPfuncs.writeready, "### NPP_WriteReady(): null pointer in NPP functions table!" );

	m_eCall = eNPP_WriteReady;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)stream;

	return execute();

}

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

NPError MacPluginComm::NPP_GetValue( NPP instance, NPPVariable variable, void *ret_value )

{

	DBG_ASSERT( m_aNPPfuncs.getvalue, "### NPP_GetValue(): null pointer in NPP functions table!" );

	m_eCall = eNPP_GetValue;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)variable;

	m_aArgs[2] = ret_value;

	return (NPError)execute();

}

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

NPError MacPluginComm::NPP_SetValue( NPP instance, NPNVariable variable, void *set_value )

{

	DBG_ASSERT( m_aNPPfuncs.setvalue, "### NPP_SetValue(): null pointer in NPP functions table!" );

	m_eCall = eNPP_SetValue;

	m_aArgs[0] = (void*)instance;

	m_aArgs[1] = (void*)variable;

	m_aArgs[2] = set_value;

	return (NPError)execute();

}

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

void * MacPluginComm::NPP_GetJavaClass()

{

	DBG_ERROR( "no java class available!" );

	return 0;

}

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

NPError MacPluginComm::NPP_Initialize()

{

	return NPERR_NO_ERROR;

}

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

void MacPluginComm::NPP_Shutdown()

{

	m_eCall = eNPP_Shutdown;

	execute();

}

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

NPError MacPluginComm::NPP_SetWindow( XPlugin_Impl* i_pImpl )

{

    // update window NPWindow from view

    SysPlugData& rPlugData( i_pImpl->getSysPlugData() );        

    // update plug view

    NSRect aPlugRect = [rPlugData.m_pParentView frame];

    aPlugRect.origin.x = aPlugRect.origin.y = 0;

    if( ! rPlugData.m_pPlugView )

    {

        rPlugData.m_pPlugView = [[OOoPluginView alloc] initWithInstance: i_pImpl pluginComm: this frame: aPlugRect];

        [rPlugData.m_pParentView addSubview: rPlugData.m_pPlugView];

    }

    else

        [rPlugData.m_pPlugView setFrame: aPlugRect];

    NPWindow* pNPWin = i_pImpl->getNPWindow();

    NSWindow* pWin = [rPlugData.m_pPlugView window];

    NSRect aWinRect = [pWin frame];

    NSRect aBounds = [rPlugData.m_pPlugView frame];

    NSRect aVisibleBounds = [rPlugData.m_pPlugView visibleRect];

    #if OSL_DEBUG_LEVEL > 1

    fprintf( stderr, "visible bounds = %d+%d+%dx%d\n",

             (int)aVisibleBounds.origin.x, (int)aVisibleBounds.origin.y,

             (int)aVisibleBounds.size.width, (int)aVisibleBounds.size.height );

    #endif

    NSPoint aViewOrigin = [rPlugData.m_pPlugView convertPoint: NSZeroPoint toView: nil];

    // save view origin so we can notice movement of the view in drawView

    // in case of a moved view we need to reset the port/context

    rPlugData.m_aLastPlugViewOrigin = aViewOrigin;

    // convert view origin to topdown coordinates

    aViewOrigin.y = aWinRect.size.height - aViewOrigin.y;

    // same for clipping

    NSPoint aClipOrigin = [rPlugData.m_pPlugView convertPoint: aVisibleBounds.origin toView: nil];

    aClipOrigin.y = aWinRect.size.height - aClipOrigin.y;

    #if OSL_DEBUG_LEVEL > 1

    fprintf( stderr, "view origin: %d+%d, clip origin = %d+%d\n",

             (int)aViewOrigin.x, (int)aViewOrigin.y,

             (int)aClipOrigin.x, (int)aClipOrigin.y );

    #endif

    pNPWin->x                = aViewOrigin.x;

    pNPWin->y                = aViewOrigin.y;

    pNPWin->width            = aBounds.size.width;

    pNPWin->height           = aBounds.size.height;

    pNPWin->clipRect.left    = aClipOrigin.x;

    pNPWin->clipRect.top     = aClipOrigin.y;

    pNPWin->clipRect.right   = aClipOrigin.x + aVisibleBounds.size.width;

    pNPWin->clipRect.bottom  = aClipOrigin.y + aVisibleBounds.size.height;

    if( rPlugData.m_nDrawingModel == 1 )

    {        

        rPlugData.m_aCGContext.window = reinterpret_cast<WindowRef>([pWin windowRef]);

        pNPWin->window = &rPlugData.m_aCGContext;

        rPlugData.m_aCGContext.context = reinterpret_cast<CGContextRef>([[pWin graphicsContext] graphicsPort]);

        #if OSL_DEBUG_LEVEL > 1

        fprintf( stderr, "window is %p, context is %p\n",

                 rPlugData.m_aCGContext.window, rPlugData.m_aCGContext.context );

        #endif

    }

    else

    {

        rPlugData.m_aNPPort.port = GetWindowPort( reinterpret_cast<WindowRef>([pWin windowRef]) );

        rPlugData.m_aNPPort.portx = aClipOrigin.x;

        rPlugData.m_aNPPort.porty = aClipOrigin.y;

        pNPWin->window = &rPlugData.m_aNPPort;

        #if OSL_DEBUG_LEVEL > 1

        fprintf( stderr, "port is %p at (%d,%d)\n",

                 rPlugData.m_aNPPort.port, (int)rPlugData.m_aNPPort.portx, (int)rPlugData.m_aNPPort.porty );

        #endif

    }

    if( pNPWin->width == 0 || pNPWin->height == 0 || [rPlugData.m_pPlugView isHiddenOrHasHiddenAncestor] )

        rPlugData.m_bSetWindowOnDraw = true;

    NPError nErr = NPP_SetWindow( i_pImpl->getNPPInstance(), i_pImpl->getNPWindow() );

    return nErr;

}

void MacPluginComm::drawView( XPlugin_Impl* i_pImpl )

{

    SysPlugData& rPlugData( i_pImpl->getSysPlugData() );

    // check if the view was moved since the last SetWindow

    NSPoint aViewOrigin = [rPlugData.m_pPlugView convertPoint: NSZeroPoint toView: nil];

    if( rPlugData.m_bSetWindowOnDraw ||

        aViewOrigin.x != rPlugData.m_aLastPlugViewOrigin.x ||

        aViewOrigin.y != rPlugData.m_aLastPlugViewOrigin.y )

    {

        NPP_SetWindow( i_pImpl );

        rPlugData.m_bSetWindowOnDraw = false;

    }

    // send a paint event

    NSWindow* pWin = [rPlugData.m_pPlugView window];

    FakeEventRecord aRec;

    aRec.what       =  updateEvt;

    aRec.message    = (UInt32)[pWin windowRef];

    this->NPP_HandleEvent( i_pImpl->getNPPInstance(), &aRec );

}

/**************************************************************

 * 

 * Licensed to the Apache Software Foundation (ASF) under one

 * or more contributor license agreements.  See the NOTICE file

 * distributed with this work for additional information

 * regarding copyright ownership.  The ASF licenses this file

 * to you under the Apache License, Version 2.0 (the

 * "License"); you may not use this file except in compliance

 * with the License.  You may obtain a copy of the License at

 * 

 *   http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing,

 * software distributed under the License is distributed on an

 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

 * KIND, either express or implied.  See the License for the

 * specific language governing permissions and limitations

 * under the License.

 * 

 *************************************************************/

// MARKER(update_precomp.py): autogen include statement, do not remove

#include "precompiled_extensions.hxx"

#if STLPORT_VERSION>=321

#include <cstdarg>

#include <cstdio>

#endif

#include <plugin/impl.hxx>

#ifndef _COM_SUN_STAR_FRAME_FRAMESEARCHFLAGS_HPP_

#include <com/sun/star/frame/FrameSearchFlag.hpp>

#endif

#include <com/sun/star/frame/XComponentLoader.hpp>

#include <tools/fsys.hxx>

#include <tools/urlobj.hxx>

#include <cppuhelper/implbase1.hxx>

using namespace com::sun::star::io;

using rtl::OUString;

namespace ext_plug {

class FileSink : public ::cppu::WeakAggImplHelper1< ::com::sun::star::io::XOutputStream >

{

private:

	Reference< ::com::sun::star::uno::XComponentContext > 	m_xContext;

	FILE*					fp;

	Reference< ::com::sun::star::plugin::XPlugin > 				m_xPlugin;

	::rtl::OUString					m_aMIMEType;

	::rtl::OUString					m_aTarget;

	::rtl::OUString					m_aFileName;

public:

	FileSink( const Reference< ::com::sun::star::uno::XComponentContext > 	&,

			  const Reference< ::com::sun::star::plugin::XPlugin > & plugin,

			  const ::rtl::OUString& mimetype,

			  const ::rtl::OUString& target,

			  const Reference< ::com::sun::star::io::XActiveDataSource > & source );

	virtual ~FileSink();

	// ::com::sun::star::io::XOutputStream

	virtual void SAL_CALL writeBytes( const Sequence<sal_Int8>& ) throw();

	virtual void SAL_CALL flush() throw();

	virtual void SAL_CALL closeOutput() throw();

};

}

using namespace ext_plug;

class XPluginContext_Impl : public ::cppu::WeakAggImplHelper1< ::com::sun::star::plugin::XPluginContext >

{

	Reference< ::com::sun::star::uno::XComponentContext > 	m_xContext;

	rtl_TextEncoding										m_aEncoding;

public:

	XPluginContext_Impl( const Reference< ::com::sun::star::uno::XComponentContext >  & );

	virtual ~XPluginContext_Impl();

    virtual ::rtl::OUString SAL_CALL getValue(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, ::com::sun::star::plugin::PluginVariable variable) throw( ::com::sun::star::plugin::PluginException, RuntimeException );

    virtual void SAL_CALL getURLNotify(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& url, const ::rtl::OUString& target, const Reference< ::com::sun::star::lang::XEventListener > & listener) throw( ::com::sun::star::plugin::PluginException, RuntimeException );

    virtual void SAL_CALL getURL(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& url, const ::rtl::OUString& target) throw( ::com::sun::star::plugin::PluginException, RuntimeException );

    virtual void SAL_CALL postURLNotify(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& url, const ::rtl::OUString& target, const Sequence< sal_Int8 >& buf, sal_Bool file, const Reference< ::com::sun::star::lang::XEventListener > & listener) throw( ::com::sun::star::plugin::PluginException, RuntimeException );

    virtual void SAL_CALL postURL(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& url, const ::rtl::OUString& target, const Sequence< sal_Int8 >& buf, sal_Bool file) throw( ::com::sun::star::plugin::PluginException, RuntimeException );

    virtual void SAL_CALL newStream(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& mimetype, const ::rtl::OUString& target, const Reference< ::com::sun::star::io::XActiveDataSource > & source) throw( ::com::sun::star::plugin::PluginException, RuntimeException );

    virtual void SAL_CALL displayStatusText(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& message) throw( ::com::sun::star::plugin::PluginException, RuntimeException );

    virtual ::rtl::OUString SAL_CALL getUserAgent(const Reference< ::com::sun::star::plugin::XPlugin > & plugin) throw( ::com::sun::star::plugin::PluginException, RuntimeException );

};

Reference< ::com::sun::star::plugin::XPluginContext >  XPluginManager_Impl::createPluginContext() throw()

{

	return new XPluginContext_Impl( m_xContext );

}

XPluginContext_Impl::XPluginContext_Impl( const Reference< ::com::sun::star::uno::XComponentContext >  & rxContext )

	: m_xContext( rxContext ),

	  m_aEncoding( gsl_getSystemTextEncoding() )

{

}

XPluginContext_Impl::~XPluginContext_Impl()

{

}

::rtl::OUString XPluginContext_Impl::getValue( const Reference< ::com::sun::star::plugin::XPlugin > & /*plugin*/, ::com::sun::star::plugin::PluginVariable /*variable*/ )

	throw( ::com::sun::star::plugin::PluginException, RuntimeException )

{

	return ::rtl::OUString();

}

void XPluginContext_Impl::getURL(

    const Reference< ::com::sun::star::plugin::XPlugin > & plugin,

    const ::rtl::OUString& url,

    const ::rtl::OUString& target)

throw( ::com::sun::star::plugin::PluginException,

       RuntimeException )

{

    Reference< ::com::sun::star::frame::XComponentLoader >  xLoader(

        m_xContext->getServiceManager()->createInstanceWithContext(

            OUString( RTL_CONSTASCII_USTRINGPARAM(

                "com.sun.star.frame.Desktop" )), m_xContext ), UNO_QUERY );

	if( ! xLoader.is() )

		return;

	if( ! target.getLength() )

	{

		INetURLObject aURL;

		aURL.SetSmartProtocol( INET_PROT_FILE );

		aURL.SetSmartURL( ::rtl::OUStringToOString( url, m_aEncoding ) );

        rtl::OUString aUrl = aURL.GetMainURL(INetURLObject::DECODE_TO_IURI);

		// the mimetype cannot be specified

		plugin->provideNewStream( ::rtl::OUString(),

								  Reference< XActiveDataSource >(),

								  aUrl,

								  0, 0, (sal_Bool)(aUrl.compareToAscii( "file:", 5 ) == 0) );

		return;

	}

	XPlugin_Impl* pPlugin = XPluginManager_Impl::getPluginImplementation( plugin );

	if( pPlugin )

	{

        try

        {

            ::com::sun::star::beans::PropertyValue aValue;

            aValue.Name		= ::rtl::OUString::createFromAscii( "Referer" );

            aValue.Value <<= pPlugin->getRefererURL();

            Sequence< ::com::sun::star::beans::PropertyValue > aArgs( &aValue, 1 );

            Reference< ::com::sun::star::lang::XComponent >  xComp =

                xLoader->loadComponentFromURL(

                                              url,

                                              target,

                                              ::com::sun::star::frame::FrameSearchFlag::PARENT          |

                                              ::com::sun::star::frame::FrameSearchFlag::SELF            |

                                              ::com::sun::star::frame::FrameSearchFlag::CHILDREN        |

                                              ::com::sun::star::frame::FrameSearchFlag::SIBLINGS        |

                                              ::com::sun::star::frame::FrameSearchFlag::TASKS           |

                                              ::com::sun::star::frame::FrameSearchFlag::CREATE,

                                              aArgs

                                              );

        }

        catch(...)

        {

            throw ::com::sun::star::plugin::PluginException();

        }

	}

}

void XPluginContext_Impl::getURLNotify(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& url, const ::rtl::OUString& target, const Reference< ::com::sun::star::lang::XEventListener > & listener )

	throw( ::com::sun::star::plugin::PluginException, RuntimeException )

{

	getURL( plugin, url, target );

	if( listener.is() )

		listener->disposing( ::com::sun::star::lang::EventObject() );

}

::rtl::OUString XPluginContext_Impl::getUserAgent(const Reference< ::com::sun::star::plugin::XPlugin > & /*plugin*/)

	throw( ::com::sun::star::plugin::PluginException, RuntimeException )

{

	return ::rtl::OUString::createFromAscii( "Mozilla 3.0" );

}

void XPluginContext_Impl::displayStatusText(const Reference< ::com::sun::star::plugin::XPlugin > & /*plugin*/, const ::rtl::OUString& /*message*/)

	throw( ::com::sun::star::plugin::PluginException, RuntimeException )

{

}

void XPluginContext_Impl::postURL(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& url, const ::rtl::OUString& target, const Sequence< sal_Int8 >& buf, sal_Bool file)

	throw( ::com::sun::star::plugin::PluginException, RuntimeException )

{

	Sequence< sal_Int8 > aBuf;

	if( file )

	{

		String aFileName( (char*)buf.getConstArray(), m_aEncoding );

		INetURLObject aFilePath( aFileName );

		aFileName = aFilePath.PathToFileName();

		SvFileStream aStream( aFileName, STREAM_READ );

		if( aStream.IsOpen() )

		{

			int nBytes = 0;

			aStream.Seek( STREAM_SEEK_TO_END );

			aBuf = Sequence<sal_Int8>( nBytes = aStream.Tell() );

			aStream.Seek( STREAM_SEEK_TO_BEGIN );

			aStream.Read( aBuf.getArray(), nBytes );

			aStream.Close();

			DirEntry( aFileName ).Kill();

		}

	}

    Reference< ::com::sun::star::frame::XComponentLoader >  xLoader(

        m_xContext->getServiceManager()->createInstanceWithContext(

            OUString( RTL_CONSTASCII_USTRINGPARAM(

                "com.sun.star.frame.Desktop" )), m_xContext ), UNO_QUERY );

	if( ! xLoader.is() )

		return ;

	XPlugin_Impl* pPlugin = XPluginManager_Impl::getPluginImplementation( plugin );

	if( pPlugin )

	{

        try

        {

            ::com::sun::star::beans::PropertyValue aValues[2];

            aValues[0].Name	= ::rtl::OUString::createFromAscii( "Referer" );

            aValues[0].Value <<= pPlugin->getRefererURL();

            aValues[1].Name	= ::rtl::OUString::createFromAscii( "PostString" );

            aValues[1].Value <<= ::rtl::OStringToOUString( (char*)( file ? aBuf : buf ).getConstArray(), m_aEncoding );

            Sequence< ::com::sun::star::beans::PropertyValue > aArgs( aValues, 2 );

            Reference< ::com::sun::star::lang::XComponent >  xComp =

                xLoader->loadComponentFromURL(

                                              url,

                                              target,

                                              ::com::sun::star::frame::FrameSearchFlag::PARENT          |

                                              ::com::sun::star::frame::FrameSearchFlag::SELF            |

                                              ::com::sun::star::frame::FrameSearchFlag::CHILDREN        |

                                              ::com::sun::star::frame::FrameSearchFlag::SIBLINGS        |

                                              ::com::sun::star::frame::FrameSearchFlag::TASKS           |

                                              ::com::sun::star::frame::FrameSearchFlag::CREATE,

                                              aArgs

                                              );

        }

        catch( ... )

        {

            throw ::com::sun::star::plugin::PluginException();

        }

	}

}

void XPluginContext_Impl::postURLNotify(const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& url, const ::rtl::OUString& target, const Sequence< sal_Int8 >& buf, sal_Bool file, const Reference< ::com::sun::star::lang::XEventListener > & listener )

	throw( ::com::sun::star::plugin::PluginException, RuntimeException )

{

	postURL( plugin, url, target, buf, file );

	if( listener.is() )

		listener->disposing( ::com::sun::star::lang::EventObject() );

}

void XPluginContext_Impl::newStream( const Reference< ::com::sun::star::plugin::XPlugin > & plugin, const ::rtl::OUString& mimetype, const ::rtl::OUString& target, const Reference< ::com::sun::star::io::XActiveDataSource > & source )

	throw( ::com::sun::star::plugin::PluginException, RuntimeException )

{

	FileSink*  pNewSink = new FileSink( m_xContext, plugin, mimetype, target, source );

	pNewSink->acquire();

}

FileSink::FileSink( const Reference< ::com::sun::star::uno::XComponentContext >  & rxContext, const Reference< ::com::sun::star::plugin::XPlugin > & plugin,

				    const ::rtl::OUString& mimetype,

					const ::rtl::OUString& target, const Reference< ::com::sun::star::io::XActiveDataSource > & source ) :

		m_xContext( rxContext ),

		m_xPlugin( plugin ),

		m_aMIMEType( mimetype ),

		m_aTarget( target )

{

	DirEntry aEntry;

	m_aFileName = aEntry.TempName().GetFull();

	::rtl::OString aFile = ::rtl::OUStringToOString( m_aFileName, gsl_getSystemTextEncoding() );

	fp = fopen( aFile.getStr() , "wb" );

	Reference< ::com::sun::star::io::XActiveDataControl >  xControl( source, UNO_QUERY );

	source->setOutputStream( Reference< ::com::sun::star::io::XOutputStream > ( this ) );

	if( xControl.is() )

		xControl->start();

}

FileSink::~FileSink()

{

	DirEntry aEntry( m_aFileName );

	aEntry.Kill();

}

void FileSink::closeOutput() throw()

{

	if( fp )

		fclose( fp );

    Reference< ::com::sun::star::frame::XComponentLoader >  xLoader(

        m_xContext->getServiceManager()->createInstanceWithContext(

            OUString( RTL_CONSTASCII_USTRINGPARAM(

                "com.sun.star.frame.Desktop" )), m_xContext ), UNO_QUERY );

	XPlugin_Impl* pPlugin = XPluginManager_Impl::getPluginImplementation( m_xPlugin );

	if( xLoader.is() && pPlugin )

	{

        try

        {

            ::com::sun::star::beans::PropertyValue aValue;

            aValue.Name = ::rtl::OUString::createFromAscii( "Referer" );

            aValue.Value <<= pPlugin->getRefererURL();

            Sequence< ::com::sun::star::beans::PropertyValue > aArgs( &aValue, 1 );

            Reference< ::com::sun::star::lang::XComponent >  xComp =

                xLoader->loadComponentFromURL(

                                              m_aFileName,

                                              m_aTarget,

                                              ::com::sun::star::frame::FrameSearchFlag::PARENT          |

                                              ::com::sun::star::frame::FrameSearchFlag::SELF            |

                                              ::com::sun::star::frame::FrameSearchFlag::CHILDREN        |

                                              ::com::sun::star::frame::FrameSearchFlag::SIBLINGS        |

                                              ::com::sun::star::frame::FrameSearchFlag::TASKS           |

                                              ::com::sun::star::frame::FrameSearchFlag::CREATE,

                                              aArgs

                                              );

        }

        catch( ... )

        {

        }

	}

	release();

}

void FileSink::writeBytes( const Sequence<sal_Int8>& Buffer ) throw()

{

	if( fp )

		fwrite( Buffer.getConstArray(), 1, Buffer.getLength(), fp );

}

void FileSink::flush() throw()

{

	if( fp )

		fflush( fp );

}

/**************************************************************

 * 

 * Licensed to the Apache Software Foundation (ASF) under one

 * or more contributor license agreements.  See the NOTICE file

 * distributed with this work for additional information

 * regarding copyright ownership.  The ASF licenses this file

 * to you under the Apache License, Version 2.0 (the

 * "License"); you may not use this file except in compliance

 * with the License.  You may obtain a copy of the License at

 * 

 *   http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing,

 * software distributed under the License is distributed on an

 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

 * KIND, either express or implied.  See the License for the

 * specific language governing permissions and limitations

 * under the License.

 * 

 *************************************************************/

// MARKER(update_precomp.py): autogen include statement, do not remove

#include "precompiled_extensions.hxx"

#if STLPORT_VERSION>=321

#include <cstdarg>

#endif

#include <plugin/impl.hxx>

PluginEventListener::PluginEventListener( XPlugin_Impl* pPlugin,