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; }
CPluginInstancePeer::CPluginInstancePeer(NPP npp, nsMIMEType typeString, nsPluginMode type, PRUint16 attr_cnt, const char** attr_list, const char** val_list) : npp(npp), typeString(typeString), type(type), attribute_cnt((PRUint16)NULL), attribute_list(NULL), values_list(NULL) { // Set the reference count to 0. NS_INIT_REFCNT(); attribute_list = (char**) NPN_MemAlloc(attr_cnt * sizeof(const char*)); values_list = (char**) NPN_MemAlloc(attr_cnt * sizeof(const char*)); if (attribute_list != NULL && values_list != NULL) { for (int i = 0, j = 0; i < attr_cnt; i++) { if (attr_list[i] != NULL && val_list[i] != NULL) { attribute_list[j] = (char*) NPN_MemAlloc(strlen(attr_list[i]) + 1); if (attribute_list[j] != NULL) strcpy(attribute_list[j], attr_list[i]); values_list[j] = (char*) NPN_MemAlloc(strlen(val_list[i]) + 1); if (values_list[j] != NULL) strcpy(values_list[j], val_list[i]); j = j + 1; attribute_cnt = j; } } } }
//----------------------------------------------------------------------------- // 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; }
/* 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); }
// ============================== // ! Scriptability related code ! // ============================== // // here the plugin is asked by Mozilla to tell if it is scriptable // we should return a valid interface id and a pointer to // nsScriptablePeer interface which we should have implemented // and which should be defined in the corressponding *.xpt file // in the bin/components folder NPError nsPluginInstance::GetValue(NPPVariable aVariable, void *aValue) { NPError rv = NPERR_NO_ERROR; switch (aVariable) { case NPPVpluginScriptableInstance: { // addref happens in getter, so we don't addref here nsIDimdimControl * scriptablePeer = getScriptablePeer(); if (scriptablePeer) { *(nsISupports **)aValue = scriptablePeer; } else rv = NPERR_OUT_OF_MEMORY_ERROR; } break; case NPPVpluginScriptableIID: { static nsIID scriptableIID = NS_IDIMDIMCONTROL_IID; nsIID* ptr = (nsIID *)NPN_MemAlloc(sizeof(nsIID)); if (ptr) { *ptr = scriptableIID; *(nsIID **)aValue = ptr; } else rv = NPERR_OUT_OF_MEMORY_ERROR; } break; default: break; } return rv; }
NPError NPP_Destroy(NPP instance, NPSavedData** save) { // TRACE("NPP_Destroy\n"); if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; nsIPluginInstance* pluginInstance = (nsIPluginInstance* )instance->pdata; IUniqueIdentifier* pInst = NULL; if(NS_SUCCEEDED(pluginInstance->QueryInterface(kIUniqueIdentifierIID, (void**)&pInst))) { *save = (NPSavedData*)NPN_MemAlloc(sizeof(NPSavedData)); long id; pInst->GetUniqueId(&id); (*save)->buf = NULL; (*save)->len = id; pInst->Release(); } pluginInstance->Stop(); pluginInstance->Destroy(); pluginInstance->Release(); instance->pdata = NULL; return NPERR_NO_ERROR; }
bool ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { if (name == sendCmd_id) { if ( argCount < 1 ) { return false; } PString strParam = ""; NPString npStr = NPVARIANT_TO_STRING( args[0] ); for (unsigned int i=0; i<npStr.utf8length; i++) { strParam += npStr.utf8characters[ i ]; } PString strResult = g_NativeLogic.InvokeFunction( strParam ); char* pszName = (char*)NPN_MemAlloc( strResult.GetSize() + 1 ); strcpy( pszName, strResult ); STRINGZ_TO_NPVARIANT(pszName, *result); return PR_TRUE; } return PR_FALSE; }
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; }
/** * Custom allocation of memory. * Stub for future use. * * @param plugin - Parent plugin * @param aClass - Plugin class * @return JS Object */ static NPObject* jsInterface_Allocate (NPP plugin, NPClass *aClass) { jsInterfaceObject *object; object = (jsInterfaceObject*) NPN_MemAlloc(sizeof(jsInterfaceObject)); return (NPObject*) object; }
void CPlugin::getVersion(char* *aVersion) { const char *ua = NPN_UserAgent(m_pNPInstance); char*& version = *aVersion; version = (char*)NPN_MemAlloc(1 + strlen(ua)); if (version) strcpy(version, ua); }
NPMIMEType dupMimeType(NPMIMEType type) { NPMIMEType mimetype = NPN_MemAlloc(strlen(type)+1); if (mimetype) strcpy(mimetype, type); return(mimetype); }
NPError NPP_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved) { PluginInstance* This; if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; instance->pdata = NPN_MemAlloc(sizeof(PluginInstance)); This = (PluginInstance*) instance->pdata; if (This == NULL) { return NPERR_OUT_OF_MEMORY_ERROR; } memset(This, 0, sizeof(PluginInstance)); /* mode is NP_EMBED, NP_FULL, or NP_BACKGROUND (see npapi.h) */ This->mode = mode; This->type = dupMimeType(pluginType); This->instance = instance; This->pluginsPageUrl = NULL; This->exists = FALSE; /* Parse argument list passed to plugin instance */ /* We are interested in these arguments * PLUGINSPAGE = <url> */ while (argc > 0) { argc --; if (argv[argc] != NULL) { if (!PL_strcasecmp(argn[argc], "PLUGINSPAGE")) This->pluginsPageUrl = strdup(argv[argc]); else if (!PL_strcasecmp(argn[argc], "PLUGINURL")) This->pluginsFileUrl = strdup(argv[argc]); else if (!PL_strcasecmp(argn[argc], "CODEBASE")) This->pluginsPageUrl = strdup(argv[argc]); else if (!PL_strcasecmp(argn[argc], "CLASSID")) This->pluginsFileUrl = strdup(argv[argc]); else if (!PL_strcasecmp(argn[argc], "HIDDEN")) This->pluginsHidden = (!PL_strcasecmp(argv[argc], "TRUE")); } } return NPERR_NO_ERROR; }
bool ScriptablePluginObject::GetProperty(NPIdentifier name, NPVariant *result) { VOID_TO_NPVARIANT(*result); //kk /*if (name == sBar_id) { static int a = 17; INT32_TO_NPVARIANT(a, *result); a += 5; return true; }*/ char *pProp = NPN_UTF8FromIdentifier(name); if( !strcmp( "Version", pProp ) ) { char *p = (char*) NPN_MemAlloc( "Version 1.0" );//allocating Memory for the string with invocation of Browser-API STRINGZ_TO_NPVARIANT( p, *result); return true; } if( !strcmp( "Name", pProp ) ) { char *p = (char*) NPN_MemAlloc( m_pszName );//allocating Memory for the string with invocation of Browser-API STRINGZ_TO_NPVARIANT( p, *result); return true; } if (name == sPluginType_id) { NPObject *myobj = NPN_CreateObject(mNpp, GET_NPOBJECT_CLASS(ConstructablePluginObject)); if (!myobj) { return false; } OBJECT_TO_NPVARIANT(myobj, *result); return true; } return true; }
void CPlugin::getVersion(char* *aVersion) { OutputDebugStringA("cplugin_getversion"); const char *ua = NPN_UserAgent(m_pNPInstance); char*& version = *aVersion; version = (char*)NPN_MemAlloc(1 + strlen(ua)); if (version) strcpy(version, ua); }
char * m_strndup(const char *src, int len) { char *ret = NULL; if ((src) && (len >= 0)) { ret = (char*) NPN_MemAlloc(len+1); memcpy(ret, src, len); ret[len] = '\0'; } return ret; }
void convertToVariant(NPP npp, const Any& any, NPVariant* variant, bool result) { switch (any.getType()) { case Any::Empty: NULL_TO_NPVARIANT(*variant); break; case Any::Bool: BOOLEAN_TO_NPVARIANT(any.toBoolean(), *variant); break; case Any::Int32: case Any::Uint32: INT32_TO_NPVARIANT(static_cast<int32_t>(any), *variant); break; case Any::Int64: case Any::Uint64: case Any::Float32: case Any::Float64: DOUBLE_TO_NPVARIANT(static_cast<double>(any), *variant); break; case Any::Dynamic: if (any.isString()) { std::string value = any.toString(); if (value.length() == 0) { STRINGN_TO_NPVARIANT(0, 0, *variant); } else if (!result) { STRINGN_TO_NPVARIANT(value.c_str(), static_cast<uint32_t>(value.length()), *variant); } else { void* buffer = NPN_MemAlloc(value.length()); if (!buffer) { STRINGN_TO_NPVARIANT(0, 0, *variant); } else { memmove(buffer, value.c_str(), value.length()); STRINGN_TO_NPVARIANT(static_cast<NPUTF8*>(buffer), static_cast<uint32_t>(value.length()), *variant); } } } else { assert(any.isObject()); convertToVariant(npp, any.toObject(), variant, result); } break; default: VOID_TO_NPVARIANT(*variant); break; } }
NPObject* Snapshot_Allocate (NPP plugin, NPClass* klass) { Mumble* self = (Mumble*) Mumble_Get(PA_Self(plugin)); Mumble* copy = (Mumble*) NPN_MemAlloc(sizeof(Mumble)); memcpy(copy, self, sizeof(Mumble)); return PA_Object(klass, plugin, copy); }
void* NPN_MemAlloc(LPCTSTR psz) { int size = strlen( psz ); void * rv = NPN_MemAlloc(size); strcpy( (char*) rv, psz ); return rv; }
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); }
char* CStringToNPStringCharacters(const CString &str) { CStringW wstr = CT2W(str); int nUTF8 = WideCharToMultiByte(CP_UTF8, 0, wstr, wstr.GetLength() + 1, NULL, 0, NULL, NULL); if (nUTF8 == 0) return NULL; char* utf8str = (char *)NPN_MemAlloc(nUTF8); WideCharToMultiByte(CP_UTF8, 0, wstr, wstr.GetLength() + 1, utf8str, nUTF8, NULL, NULL); return utf8str; }
bool CNPPluginMisc::SetRetValue(char *psz_ret,NPVariant *result) { int len = strlen(psz_ret); char *tmp = (char*)NPN_MemAlloc(len+1); strncpy(tmp,psz_ret,len); tmp[len] = '\0'; STRINGZ_TO_NPVARIANT(tmp,*result); return true; }
NPError NPP_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved) { PluginInstance* This; if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; instance->pdata = NPN_MemAlloc(sizeof(PluginInstance)); This = (PluginInstance*) instance->pdata; if (This != NULL) { /* mode is NP_EMBED, NP_FULL, or NP_BACKGROUND (see npapi.h) */ This->mode = mode; This->window = (Window) 0; This->opmode = NP_NORMAL; This->nodata = FALSE; #ifdef TEXT_PLUGIN This->form = 0; This->text = 0; #endif /* TEXT_PLUGIN */ while (argc > 0) { if (!strcasecmp(argn[argc-1], "MODE") && argv[argc-1]) { if (!strcasecmp(argv[argc-1], "seek")) This->opmode = NP_SEEK; if (!strcasecmp(argv[argc-1], "asfile")) This->opmode = NP_ASFILE; if (!strcasecmp(argv[argc-1], "asfileonly")) This->opmode = NP_ASFILEONLY; } else if (!strcasecmp(argn[argc-1], "NODATA")) This->nodata = TRUE; argc --; } /* PLUGIN DEVELOPERS: * Initialize fields of your plugin * instance data here. If the NPSavedData is non- * NULL, you can use that data (returned by you from * NPP_Destroy to set up the new plugin instance). */ return NPERR_NO_ERROR; } else return NPERR_OUT_OF_MEMORY_ERROR; }
void* NPN_MemDup (const void* aMem, uint32 aLen) { if (!aMem || !aLen) return NULL; void* dup = NPN_MemAlloc (aLen); if (!dup) return NULL; return memcpy (dup, aMem, aLen); }
// Type conversions NPString NPString::fromQString(const QString &qstr) { NPString npstring; const QByteArray qutf8 = qstr.toUtf8(); npstring.utf8length = qutf8.length(); npstring.utf8characters = (char*)NPN_MemAlloc(npstring.utf8length); memcpy((char*)npstring.utf8characters, qutf8.constData(), npstring.utf8length); return npstring; }
NS_IMETHODIMP npAPInsIInputStreamShim::EnsureBuffer(int32 requestedAdditionalLen) { // if we don't have a buffer, create one if (!mBuffer) { if (0 < INITIAL_BUFFER_LENGTH) { mBuffer = NPN_MemAlloc(INITIAL_BUFFER_LENGTH); mBufferLength = INITIAL_BUFFER_LENGTH; } if (!mBuffer) { mBufferLength = 0; return NS_ERROR_FAILURE; } } else { // See if we need to grow our buffer. If what we have plus what // we're about to get is greater than the current buffer size... int32 additionalLen = requestedAdditionalLen < buffer_increment ? buffer_increment : requestedAdditionalLen; if (mBufferLength < (mCountFromPluginHost + additionalLen)) { // create the new buffer void *tBuffer = NPN_MemAlloc(mBufferLength + additionalLen); if (!tBuffer) { return NS_ERROR_FAILURE; } // copy the old buffer into the new buffer memcpy(tBuffer, mBuffer, mBufferLength); // delete the old buffer NPN_MemFree(mBuffer); // update mBuffer; mBuffer = tBuffer; // update our bufferLength mBufferLength += additionalLen; } } return NS_OK; }
bool convert_mrb_to_js_string(mrb_state *mrb, mrb_value value, NPP npp, NPVariant *result) { NPUTF8 *ptr = (NPUTF8 *)NPN_MemAlloc(RSTRING_LEN(value)); if (!ptr){ return false; } std::copy(RSTRING_PTR(value), RSTRING_END(value), ptr); STRINGN_TO_NPVARIANT(ptr, RSTRING_LEN(value), *result); return true; }
char * m_strdup(const char *src) { char *ret = NULL; if (src) { int len = strlen(src); if (len >= 0) { ret = (char*) NPN_MemAlloc(len+1); memcpy(ret, src, len); ret[len] = '\0'; } } return ret; }
void execute_blenderplayer(BlenderPluginInstance* instance){ char file_name[] = "/tmp/blender.XXXXXX"; int fd = mkstemp(file_name); ssize_t real_size = write(fd, instance->main_file_store, instance->stream_retrieved); close(fd); instance->temp_mail_file_name = NPN_MemAlloc(strlen(file_name) + 1); strcpy(instance->temp_mail_file_name, file_name); instance->pID = fork(); //XSelectInput(This->display , This->window, SubstructureNotifyMask); //XSync(This->display, FALSE); #if defined(WITH_APPARMOR) const char* executable = "blenderplayer-web"; #elif defined(WITH_PRIVSEP) const char* executable = "blenderplayer-wrapper"; #else const char* executable = "blenderplayer"; #endif if (instance->pID == 0) { // child char window_id[50]; sprintf(window_id, "%d", instance->window); //exit(0); #ifdef WITH_PRIVSEP execlp(executable, executable, file_name, window_id, (char*)NULL); #else execlp(executable, executable, "-i", window_id, file_name, (char*)NULL); #endif } else if (instance->pID < 0) { // failed to fork printf("Failed to fork!!!\n"); } /*XEvent e; int started = 0; while(!started) { XNextEvent(This->display, &e); printf("Event type %d\n", e.type); if (e.type == MapNotify) { started = 1; XCreateWindowEvent event = e.xcreatewindow; printf("Created window x:%d, y: %d, h: %d, w: %d\n", event.x, event.y, event.height, event.width); } }*/ }