bool convert_js_to_mrb_hash(NPP npp, const NPVariant &variant, mrb_state *mrb, mrb_value *result)
{
NPIdentifier *id_list = NULL;
uint32_t count;
NPN_Enumerate(npp, NPVARIANT_TO_OBJECT(variant), &id_list, &count);
mrb_value ret_hash = mrb_hash_new_capa(mrb, count);
for (uint32_t i=0; i<count; i++){
NPVariant item;
NPN_GetProperty(npp, NPVARIANT_TO_OBJECT(variant), id_list[i], &item);
mrb_value mrb_item;
if (!convert_js_to_mrb(npp, item, mrb, &mrb_item)){
NPN_MemFree(id_list);
NPN_ReleaseVariantValue(&item);
return false;
}
NPN_ReleaseVariantValue(&item);
NPUTF8 *key = NPN_UTF8FromIdentifier(id_list[i]);
mrb_hash_set(mrb, ret_hash, mrb_str_new2(mrb, key), mrb_item);
NPN_MemFree(key);
}
NPN_MemFree(id_list);
*result = ret_hash;
return true;
}
NPError
NPP_Destroy(NPP instance, NPSavedData** save)
{
PluginInstance* This;
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
This = (PluginInstance*) instance->pdata;
if (This != NULL) {
if (This->dialogBox)
destroyWidget(This);
if (This->type)
NPN_MemFree(This->type);
if (This->pluginsPageUrl)
NPN_MemFree(This->pluginsPageUrl);
if (This->pluginsFileUrl)
NPN_MemFree(This->pluginsFileUrl);
NPN_MemFree(instance->pdata);
instance->pdata = NULL;
}
return NPERR_NO_ERROR;
}
void CPlugin::SetURLCookie(const CString& strURL, const CString& strCookie)
{
char* url = CStringToNPStringCharacters(strURL);
char* cookie = CStringToNPStringCharacters(strCookie);
if (NPN_SetValueForURL(m_pNPInstance, NPNURLVCookie, url, cookie, (uint32_t)strlen(cookie)) != NPERR_NO_ERROR)
{
TRACE(_T("[CPlugin::SetURLCookie] NPN_SetValueForURL failed! URL: %s"), strURL);
}
NPN_MemFree(cookie);
NPN_MemFree(url);
}
CPluginInstancePeer::~CPluginInstancePeer(void)
{
if (attribute_list != NULL && values_list != NULL) {
for (int i = 0; i < attribute_cnt; i++) {
NPN_MemFree(attribute_list[i]);
NPN_MemFree(values_list[i]);
}
NPN_MemFree(attribute_list);
NPN_MemFree(values_list);
}
}
/* callback function for the OK button */
static void
DialogOKClicked (GtkButton *button, gpointer data)
{
PluginInstance* This = (PluginInstance*) data;
GtkWidget* dialogWindow = g_object_get_data(GTK_OBJECT(button), DIALOGID);
char *url;
g_object_set_data(GTK_OBJECT(button), DIALOGID, NULL);
if (This->pluginsFileUrl != NULL)
{
/* Get the JavaScript command string */
static const char buf[] =
"javascript:netscape.softupdate.Trigger.StartSoftwareUpdate(\"%s\")";
url = NPN_MemAlloc(strlen(This->pluginsFileUrl) + (sizeof(buf) - 2));
if (url != NULL)
{
/* Insert the file URL into the JavaScript command */
sprintf(url, buf, This->pluginsFileUrl);
NPN_GetURL(This->instance, url, TARGET);
NPN_MemFree(url);
}
}
else
{
/* If necessary, get the default plug-ins page resource */
char* address = This->pluginsPageUrl;
if (address == NULL || *address == 0)
{
address = PLUGINSPAGE_URL;
}
url = NPN_MemAlloc(strlen(address) + 1 + strlen(This->type)+1);
if (url != NULL)
{
NPN_PushPopupsEnabledState(This->instance, TRUE);
/* Append the MIME type to the URL */
sprintf(url, "%s?%s", address, This->type);
if (strcmp (This->type, JVM_MINETYPE) == 0)
{
NPN_GetURL(This->instance, JVM_SMARTUPDATE_URL , TARGET);
}
else
{
NPN_GetURL(This->instance, url, TARGET);
}
NPN_MemFree(url);
NPN_PopPopupsEnabledState(This->instance);
}
}
destroyWidget(This);
}
static void
PostUrl(SqueakPlugin *plugin)
{
char *url, *target, *data;
int id, urlSize, targetSize, dataSize;
errno= 0;
Receive(plugin, &id, 4);
/* Read URL from pipe */
Receive(plugin, &urlSize, 4);
if (urlSize > 0) {
url= NPN_MemAlloc(urlSize+1);
Receive(plugin, url, urlSize);
url[urlSize]= 0;
} else url= NULL;
/* Read target from pipe */
Receive(plugin, &targetSize, 4);
if (targetSize > 0) {
target= NPN_MemAlloc(targetSize+1);
Receive(plugin, target, targetSize);
target[targetSize]= 0;
} else target= NULL;
/* Read post data from pipe */
Receive(plugin, &dataSize, 4);
if (dataSize > 0) {
data= NPN_MemAlloc(dataSize);
Receive(plugin, data, dataSize);
} else data= NULL;
if (errno) {
perror("Squeak Plugin (PostUrl)");
} else {
SqueakStream* notifyData=
(SqueakStream*) NPN_MemAlloc(sizeof(SqueakStream));
if (!notifyData) {
fprintf(stderr, "Squeak Plugin (PostUrl): alloc failed\n");
} else {
DPRINT("NP: PostURLNotify(%s, id=%i)\n", url, id);
notifyData->id= id;
NPN_PostURLNotify(plugin->instance, url, target,
dataSize, data, FALSE, notifyData);
}
}
if (url) NPN_MemFree(url);
if (target) NPN_MemFree(target);
if (data) NPN_MemFree(data);
}
static void
GetUrl(SqueakPlugin *plugin)
{
char *url, *target;
int id, urlSize, targetSize;
errno= 0;
Receive(plugin, &id, 4);
/* Read URL from pipe */
Receive(plugin, &urlSize, 4);
if (urlSize > 0) {
url= NPN_MemAlloc(urlSize+1);
Receive(plugin, url, urlSize);
url[urlSize]= 0;
} else url= NULL;
/* Read target from pipe */
Receive(plugin, &targetSize, 4);
if (targetSize > 0) {
target= NPN_MemAlloc(targetSize+1);
Receive(plugin, target, targetSize);
target[targetSize]= 0;
} else target= NULL;
if (errno) {
perror("Squeak Plugin (GetUrl)");
} else {
DPRINT("NP: GetUrl(%s, %s)\n", url, target ? target : "NULL");
if (strcmp(url, plugin->srcUrl)==0) {
if (plugin->srcFilename)
DeliverFile(plugin, id, plugin->srcFilename);
else
plugin->srcId= id;
} else {
SqueakStream* notifyData=
(SqueakStream*) NPN_MemAlloc(sizeof(SqueakStream));
if (!notifyData) {
fprintf(stderr, "Squeak Plugin (GetUrl): alloc failed\n");
} else {
DPRINT("NP: GetURLNotify(%s, id=%i)\n", url, id);
notifyData->id= id;
NPN_GetURLNotify(plugin->instance, url, target, notifyData);
}
}
}
if (url) NPN_MemFree(url);
if (target) NPN_MemFree(target);
}
static NPError
post_data(NPP instance, const char *url, const char *target, uint32 len,
const char *buf, const char *tag)
{
NPError rv;
char headers[256], *sendbuf;
char *content;
unsigned int content_len, hdrlen, taglen;
taglen = strlen(tag);
content_len = taglen + len + 1;
content = (char *) NPN_MemAlloc(content_len);
if (content == NULL)
return NPERR_OUT_OF_MEMORY_ERROR;
memcpy(content, tag, taglen);
content[taglen] = '=';
memcpy(content+taglen+1, buf, len);
sprintf(headers, "Content-type: application/x-www-form-urlencoded\r\n"
"Content-Length: %u\r\n\r\n", (unsigned int) content_len);
hdrlen = strlen(headers);
sendbuf = (char *) NPN_MemAlloc(hdrlen + content_len);
if (sendbuf == NULL)
return NPERR_OUT_OF_MEMORY_ERROR;
memcpy(sendbuf, headers, hdrlen);
memcpy(sendbuf + hdrlen, content, content_len);
sendbuf[hdrlen + content_len] = 0;
NPN_MemFree(content);
printf("Sending:\n---\n%s---\n", sendbuf);
printf("Url: '%s', target: '%s', len: %ld\n", url, target, hdrlen + len);
rv = NPN_PostURL(instance, url, target, hdrlen + content_len, sendbuf, FALSE);
return rv;
}
NPError
NPP_Destroy(NPP instance, NPSavedData** save)
{
PluginInstance* This;
printf("NPP_Destroy()\n");
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
This = (PluginInstance*) instance->pdata;
/* PLUGIN DEVELOPERS:
* If desired, call NP_MemAlloc to create a
* NPSavedDate structure containing any state information
* that you want restored if this plugin instance is later
* recreated.
*/
if (This == NULL)
return NPERR_NO_ERROR;
NPN_MemFree(instance->pdata);
instance->pdata = NULL;
return NPERR_NO_ERROR;
}
NS_METHOD
CPluginManager::MemFree(void* ptr)
{
assert( ptr != NULL );
NPN_MemFree(ptr);
}
static mrb_value mrb_js_obj_get(mrb_state *mrb, mrb_value klass)
{
mrb_value str;
mrb_get_args(mrb, "S", &str);
NPObject *window;
NPN_GetValue(MRB_UD_NPP(mrb), NPNVWindowNPObject, &window);
NPUTF8 *s = (NPUTF8 *)NPN_MemAlloc(RSTRING_LEN(str));
std::copy(RSTRING_PTR(str), RSTRING_END(str), s);
NPString evaluated_str = { s, RSTRING_LEN(str) };
NPVariant result;
std::string js_str(RSTRING_PTR(str), RSTRING_LEN(str));
NPN_Evaluate(MRB_UD_NPP(mrb), window, &evaluated_str, &result);
NPN_ReleaseObject(window);
NPN_MemFree(s);
mrb_value ret;
if (!convert_js_to_mrb(MRB_UD_NPP(mrb), result, mrb, &ret)){
return mrb_nil_value();
}
return ret;
}
bool JsObjectWrapper::getInfo(NPIdentifier name, TypeMemberInfo& info) {
if(!getTypeInfo())
return false;
if(NPN_IdentifierIsString(name)) {
NPUTF8* id = NPN_UTF8FromIdentifier(name);
MembersByName_t::const_iterator it = m_byName.find(id);
NPN_MemFree(id);
if(it == m_byName.end())
return false;
info = it->second;
return true;
}
else if(m_indexerLength >= 0) {
uint32_t index = NPN_IntFromIdentifier(name);
if(index < m_indexerLength) {
info.dispatchType = DT_PropertyGet | DT_PropertySet;
//info.memberId = index;
return true;
}
}
return false;
}
static gboolean
delFromList(MimeTypeElement **typelist, PluginInstance *This)
{
if (typelist && This)
{
MimeTypeElement *ele_prev;
MimeTypeElement *ele = *typelist;
while (ele)
{
if (isEqual(ele->pinst->type, This->type))
{
if (*typelist == ele)
{
*typelist = ele->next;
} else {
ele_prev->next = ele->next;
}
NPN_MemFree(ele);
return(TRUE);
}
ele_prev = ele;
ele = ele->next;
}
}
return(FALSE);
}
CString NPIdentifierToCString(NPIdentifier npid)
{
NPUTF8* putf8IdName = NPN_UTF8FromIdentifier(npid);
NPString npstrIdName = { putf8IdName, (uint32_t)strlen(putf8IdName) };
CString idName = NPStringToCString(npstrIdName);
NPN_MemFree(putf8IdName);
return idName;
}
//-----------------------------------------------------------------------------
// NPP_Destroy:
//-----------------------------------------------------------------------------
NPError NP_LOADDS
NPP_Destroy(NPP instance, NPSavedData** save) {
if ( instance == 0 ) return NPERR_INVALID_INSTANCE_ERROR;
PluginInstance* This = (PluginInstance*) instance->pdata;
//
// *Developers*: If desired, call NP_MemAlloc to create a
// NPSavedDate structure containing any state information
// that you want restored if this plugin instance is later
// recreated.
//
if ( This ) {
// destroy hmf and PS
if ( This->hmf ) GpiDeleteMetaFile( This->hmf );
if ( This->hps ) GpiDestroyPS( This->hps );
// delete buffer
if ( This->bufMeta ) {
free( This->bufMeta );
This->bufMeta=NULL;
This->cbMeta=0;
This->offMeta=0;
}
// Remove the subclass for the client window
if ( This->hWnd ) WinSubclassWindow( This->hWnd, This->lpfnOldWndProc );
// make some saved instance data if necessary
if ( This->pSavedInstanceData == 0 ) {
// make a struct header for the data
This->pSavedInstanceData =
(NPSavedData*)NPN_MemAlloc(sizeof (struct _NPSavedData));
// fill in the struct
if ( This->pSavedInstanceData != 0 ) {
This->pSavedInstanceData->len = 0;
This->pSavedInstanceData->buf = 0;
// replace the def below and references to it with your data
#define SIDATA "aSavedInstanceDataBlock"
// the data
This->pSavedInstanceData->buf = NPN_MemAlloc(sizeof SIDATA);
if( This->pSavedInstanceData->buf ) {
strcpy((char*)This->pSavedInstanceData->buf, SIDATA);
This->pSavedInstanceData->len = sizeof SIDATA;
}
}
}
// save some instance data
*save = This->pSavedInstanceData;
NPN_MemFree(instance->pdata);
instance->pdata = 0;
}
return NPERR_NO_ERROR;
}
static void
Run(SqueakPlugin *plugin)
{
if (plugin->pid || !plugin->nswindow || !plugin->srcUrl ||plugin->failureUrl)
return;
plugin->pid= fork();
if (plugin->pid == -1) {
perror("Squeak fork() failed");
plugin->pid= 0;
return;
}
DPRINT("NP: fork() -> %i\n", plugin->pid);
if (plugin->pid == 0) {
char tmp1[16], tmp2[16];
plugin->argv[2]= NPN_StrDup(DisplayString(plugin->display));
sprintf(tmp1, "%i", plugin->pipes[SQUEAK_READ]);
plugin->argv[4]= NPN_StrDup(tmp1);
sprintf(tmp2, "%i", plugin->pipes[SQUEAK_WRITE]);
plugin->argv[5]= NPN_StrDup(tmp2);
DPRINT("NP(child): Running Squeak VM with arguments\n");
{
int i;
for (i= 1; i<plugin->argc; i++)
DPRINT(" %s\n", plugin->argv[i]);
}
/* this is from the XLib manual ... */
if ((fcntl(ConnectionNumber(plugin->display), F_SETFD, FD_CLOEXEC)) == -1)
DPRINT("NP: Cannot disinherit X connection fd\n");
DPRINT("NP(child): trying %s\n", plugin->vmName);
execv(plugin->vmName, plugin->argv);
/* ~/.npsqueak/npsqueakrun could not be executed */
strcpy(plugin->vmName, SYSTEM_BIN_DIR "/" NPSQUEAKRUN);
NPN_MemFree(plugin->argv[0]);
plugin->argv[0]= NPN_StrDup(plugin->vmName);
DPRINT("NP(child): trying %s\n", plugin->vmName);
execv(plugin->vmName, plugin->argv);
/* npsqueakrun could not be executed either */
fprintf(stderr, "Squeak Plugin: running \"%s\"\n", plugin->vmName);
perror("Squeak execv() failed");
_exit(1);
} else {
/* establish communication via command pipes */
XtAppContext app= XtDisplayToApplicationContext(plugin->display);
plugin->input= XtAppAddInput(app,
plugin->pipes[PLUGIN_READ],
(XtPointer) XtInputReadMask,
(XtInputCallbackProc) InputCallback,
plugin);
/* send browser window */
DPRINT("NP: Sending browser window=0x%X\n", plugin->nswindow);
SendInt(plugin, plugin->nswindow);
}
}
bool nsScriptableObjectRawInput::HasMethod(NPIdentifier name) {
#ifdef _DEBUG
NPUTF8* name_utf8 = NPN_UTF8FromIdentifier(name);
NPN_MemFree((void*)name_utf8);
#endif
// does the method exist?
return ((generic_methods_.find(name) != generic_methods_.end()) || (methods_.find(name) != methods_.end()));
}
bool nsScriptableObjectRawInput::HasProperty(NPIdentifier name) {
#ifdef _DEBUG
NPUTF8* name_utf8 = NPN_UTF8FromIdentifier(name);
NPN_MemFree((void*)name_utf8);
#endif
// does the property exist?
return (properties_.find(name) != properties_.end());
}
bool nsScriptableObjectOverwolfSample::HasMethod(NPIdentifier name) {
#ifdef _DEBUG
NPUTF8* name_utf8 = NPN_UTF8FromIdentifier(name);
NPN_MemFree((void*)name_utf8);
#endif
// does the method exist?
return (methods_.find(name) != methods_.end());
}
void CPlugin::SetStatus(const CString& text)
{
if (m_pNPInstance)
{
char* message = CStringToNPStringCharacters(text);
NPN_Status(m_pNPInstance, message);
NPN_MemFree(message);
}
}
void
GnashPluginScriptObject::marshalDeallocate (NPObject *npobj)
{
// log_debug(__PRETTY_FUNCTION__);
#if 0
NPN_MemFree(reinterpret_cast<void *>(npobj));
#else
delete (GnashPluginScriptObject *)npobj;
#endif
}
native_Blender3DPlugin_SendMessage(
JRIEnv* env,
Blender3DPlugin* self,
struct java_lang_String * to,
struct java_lang_String * from,
struct java_lang_String * subject,
struct java_lang_String * body
)
{
NPP npp = (NPP)netscape_plugin_Plugin_getPeer(env, self);
BlenderPluginInstance* inst = NULL;
char *to_p, *from_p, *subject_p, *body_p;
B3D_log_entry("native_Blender3DPlugin_SendMessage");
inst = (BlenderPluginInstance*) npp->pdata;
fprintf(stderr, "Doing java stuff for instance %p\n",
inst);
fflush(stderr);
to_p = NPN_MemAlloc(JRI_GetStringUTFLength(env, to) + 1);
from_p = NPN_MemAlloc(JRI_GetStringUTFLength(env, from) + 1);
subject_p = NPN_MemAlloc(JRI_GetStringUTFLength(env, subject) + 1);
body_p = NPN_MemAlloc(JRI_GetStringUTFLength(env, body) + 1);
strcpy(to_p, JRI_GetStringUTFChars(env, to));
strcpy(from_p, JRI_GetStringUTFChars(env, from));
strcpy(subject_p, JRI_GetStringUTFChars(env, subject));
strcpy(body_p, JRI_GetStringUTFChars(env, body));
PLB_native_SendMessage_func(inst,
to_p,
from_p,
subject_p,
body_p);
NPN_MemFree(to_p);
NPN_MemFree(from_p);
NPN_MemFree(subject_p);
NPN_MemFree(body_p);
}
void
NPP_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData)
{
int id= notifyData ? ((SqueakStream*) notifyData)->id : -1;
int ok= reason == NPRES_DONE;
SqueakPlugin *plugin= (SqueakPlugin*) instance->pdata;
DPRINT("NP: URLNotify(%s, id=%i, ok=%i)\n", url, id, ok);
if (notifyData) NPN_MemFree(notifyData);
if (!plugin || -1 == id) return;
DeliverFile(plugin, id, NULL);
}
NPError
NPP_New(NPMIMEType pluginType,
NPP instance,
PRUint16 mode,
int16 argc,
char* argn[],
char* argv[],
NPSavedData* saved)
{
// TRACE("NPP_New\n");
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
// Create a new plugin instance and start it.
nsIPluginInstance* pluginInstance = NULL;
thePlugin->CreateInstance(NULL, kIPluginInstanceIID, (void**)&pluginInstance);
if (pluginInstance == NULL) {
return NPERR_OUT_OF_MEMORY_ERROR;
}
// Create a new plugin instance peer,
// XXX - Since np_instance is not implemented in the 4.0x browser, I
// XXX - had to save the plugin parameter in the peer class.
// XXX - Ask Warren about np_instance.
CPluginInstancePeer* peer =
new CPluginInstancePeer(instance, (nsMIMEType)pluginType,
(nsPluginMode)mode, (PRUint16)argc,
(const char** )argn, (const char** )argv);
assert( peer != NULL );
if (!peer) return NPERR_OUT_OF_MEMORY_ERROR;
peer->AddRef();
IUniqueIdentifier* pInst = NULL;
if(NS_SUCCEEDED(pluginInstance->QueryInterface(kIUniqueIdentifierIID, (void**)&pInst))) {
long id = 0;
if(NULL != saved) {
id = saved->len;
NPN_MemFree(saved);
}
pInst->SetUniqueId(id);
pInst->Release();
}
pluginInstance->Initialize(peer);
pluginInstance->Start();
// Set the user instance and store the peer in npp->pdata.
instance->pdata = pluginInstance;
peer->Release();
UNUSED(saved);
return NPERR_NO_ERROR;
}
NPError
NPP_Destroy( NPP instance, NPSavedData** save )
{
BlenderPluginInstance* This;
log_entry("NPP_Destroy");
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
This = (BlenderPluginInstance*) instance->pdata;
printf("NPP_Destroy ID: 0x%x %d\n", This->window, This->window);
if (This != NULL) {
if (This->pID != 0) {
#ifdef WITH_PRIVSEP
kill(This->pID, SIGTERM);
#else
kill(This->pID, SIGKILL); //if I have to kill blenderplayer directly I need to send SIGKILL
#endif
wait(This->pID);
unlink(This->temp_mail_file_name);
}
// sometimes FF doesn't delete it's own window...
//printf("%s \n", NPN_UserAgent(instance));
/*if (This->display != NULL && This->window != 0)
XDestroyWindow(This->display, This->window);
*/
if (This->blend_file) NPN_MemFree(This->blend_file);
if (This->temp_mail_file_name) NPN_MemFree(This->temp_mail_file_name);
if (This->main_file_store) NPN_MemFree(This->main_file_store);
NPN_MemFree(instance->pdata);
instance->pdata = NULL;
}
return NPERR_NO_ERROR;
}
/**
* Calls the function in the reply with the reply of the function. This has to
* be done in the browser's main thread, and hence this functions
*
* @param reply - Struct containing the callback object, and the reply param.
*/
static void
jsReply (ScriptReply* reply)
{
if (reply)
{
NPVariant result;
NPN_Invoke(reply->plugin, reply->callb, NPN_GetStringIdentifier("callback"), reply->result, 1, &result);
NPN_ReleaseObject(reply->callb);
NPN_MemFree(reply->result);
free(reply);
}
}
const char* debugName(NPIdentifier name) {
static char buf[1024];
if(NPN_IdentifierIsString(name)) {
NPUTF8* strName = NPN_UTF8FromIdentifier(name);
sprintf_s(buf, sizeof(buf), "'%s'", strName);
NPN_MemFree(strName);
}
else {
int intName = NPN_IntFromIdentifier(name);
sprintf_s(buf, sizeof(buf), "%d", intName);
}
return buf;
}
void m_strFromNP(char **dst, NPString src) {
// dst should not be a pointer without initailization
if (dst == NULL)
return;
// free old pointer values
if (*dst) {
NPN_MemFree(*dst);
*dst = NULL;
}
int len = src.UTF8Length;
*dst = (char*) NPN_MemAlloc(len+1);
memcpy(*dst, src.UTF8Characters, len);
(*dst)[len] = '\0';
}
NPError
NPP_Destroy(NPP instance, NPSavedData** save)
{
SqueakPlugin *plugin;
DPRINT("NP: NPP_Destroy\n");
if (!instance)
return NPERR_INVALID_INSTANCE_ERROR;
plugin= (SqueakPlugin*) instance->pdata;
if (plugin) {
int i;
if (plugin->sqwindow && plugin->display) {
DPRINT("NP: DestroyWindow %x\n",
plugin->sqwindow);
XSetErrorHandler(IgnoreErrors);
XSync(plugin->display,0);
XKillClient(plugin->display, plugin->sqwindow);
XSync(plugin->display,0);
}
if (plugin->pid) {
DPRINT("NP: kill 0x%i\n", plugin->pid);
kill(plugin->pid, SIGTERM);
plugin->pid= 0;
}
if (plugin->input) {
XtRemoveInput(plugin->input);
}
for (i= 0; i < 4; i++)
if (plugin->pipes[i]) {
close(plugin->pipes[i]);
plugin->pipes[i]= 0;
}
if (plugin->srcUrl) {
NPN_MemFree(plugin->srcUrl);
plugin->srcUrl= NULL;
}
if (plugin->srcFilename) {
NPN_MemFree(plugin->srcFilename);
plugin->srcFilename= NULL;
}
if (plugin->failureUrl) {
NPN_MemFree(plugin->failureUrl);
plugin->failureUrl= NULL;
}
if (plugin->argv) {
for (i= 0; i < plugin->argc; i++) {
if (plugin->argv[i])
NPN_MemFree(plugin->argv[i]);
}
plugin->argc= 0;
NPN_MemFree(plugin->argv);
plugin->argv= NULL;
}
NPN_MemFree(plugin);
}
instance->pdata= NULL;
return NPERR_NO_ERROR;
}
void CPlugin::SetStatus(const CString& text)
{
if (ShouldShowStatusOurselves())
{
FireEvent(_T("IEStatusChanged"), text);
return;
}
if (m_pNPInstance)
{
char* message = CStringToNPStringCharacters(text);
NPN_Status(m_pNPInstance, message);
NPN_MemFree(message);
}
}
