JavaClass_hasInstance(JSContext *cx, JSObject *obj, jsval candidate_jsval, JSBool *has_instancep) { JavaClassDescriptor *class_descriptor; JavaObjectWrapper *java_wrapper; JSClass *js_class; JSBool has_instance; JSObject *candidate_obj; jclass java_class; jobject java_obj; JNIEnv *jEnv; JSJavaThreadState *jsj_env; has_instance = JS_FALSE; class_descriptor = JS_GetPrivate(cx, obj); if (!class_descriptor) { JS_ReportErrorNumber(cx, jsj_GetErrorMessage, NULL, JSJMSG_BAD_OP_JCLASS); return JS_FALSE; } /* * Make sure that the thing to the left of the instanceof operator is a * Java object. */ if (!JSVAL_IS_OBJECT(candidate_jsval)) goto done; candidate_obj = JSVAL_TO_OBJECT(candidate_jsval); #ifdef JS_THREADSAFE js_class = JS_GetClass(cx, candidate_obj); #else js_class = JS_GetClass(candidate_obj); #endif if ((js_class != &JavaObject_class) && (js_class != &JavaArray_class)) goto done; java_class = class_descriptor->java_class; java_wrapper = JS_GetPrivate(cx, candidate_obj); if (!java_wrapper) { JS_ReportErrorNumber(cx, jsj_GetErrorMessage, NULL, JSJMSG_BAD_OP_PROTO); return JS_FALSE; } java_obj = java_wrapper->java_obj; /* Get JNI pointer */ jsj_env = jsj_EnterJava(cx, &jEnv); has_instance = (*jEnv)->IsInstanceOf(jEnv, java_obj, java_class); jsj_ExitJava(jsj_env); done: *has_instancep = has_instance; return JS_TRUE; }
/* Mimick the behaviour exposed by standard Error objects (http://mxr.mozilla.org/mozilla-central/source/js/src/jsexn.cpp#554) */ static char* jsvalue_to_string(JSContext* cx, jsval val, gboolean* is_string) { char* value = NULL; JSString* value_str = NULL; if (JSVAL_IS_PRIMITIVE(val)) { value_str = JS_ValueToSource(cx, val); } else { JSObject *obj = JSVAL_TO_OBJECT(val); if (JS_ObjectIsFunction(cx, obj)) { JSFunction *fn = JS_ValueToFunction(cx, val); value_str = JS_GetFunctionId(fn); if (!value_str) value = g_strdup("[unknown function]"); } else { value = g_strdup_printf("[object %s]", JS_GetClass(cx, obj)->name); } } if (!value && value_str) value = gjs_value_debug_string(cx, val); if (is_string) *is_string = JSVAL_IS_STRING(val); return value; }
JSObject* gjs_param_from_g_param(JSContext *context, GParamSpec *gparam) { JSObject *obj; Param *priv; if (gparam == NULL) return NULL; gjs_debug(GJS_DEBUG_GPARAM, "Wrapping %s '%s' on %s with JSObject", g_type_name(G_TYPE_FROM_INSTANCE((GTypeInstance*) gparam)), gparam->name, g_type_name(gparam->owner_type)); JS::RootedObject proto(context, gjs_lookup_param_prototype(context)); obj = JS_NewObjectWithGivenProto(context, JS_GetClass(proto), proto); GJS_INC_COUNTER(param); priv = g_slice_new0(Param); JS_SetPrivate(obj, priv); priv->gparam = gparam; g_param_spec_ref (gparam); gjs_debug(GJS_DEBUG_GPARAM, "JSObject created with param instance %p type %s", priv->gparam, g_type_name(G_TYPE_FROM_INSTANCE((GTypeInstance*) priv->gparam))); return obj; }
static void js_json_emit_jsval(JSContext *cx, jsval value, htsbuf_queue_t *out) { char buf[100]; if(JSVAL_IS_BOOLEAN(value)) { if(JSVAL_TO_BOOLEAN(value)) htsbuf_append(out, "true", 4); else htsbuf_append(out, "false", 5); } else if(JSVAL_IS_INT(value)) { snprintf(buf, sizeof(buf), "%d", JSVAL_TO_INT(value)); htsbuf_append(out, buf, strlen(buf)); } else if(JSVAL_IS_DOUBLE(value)) { double dbl; if(JS_ValueToNumber(cx, value, &dbl) && !my_double2str(buf, sizeof(buf), dbl)) htsbuf_append(out, buf, strlen(buf)); else htsbuf_append(out, "null", 4); } else if(JSVAL_IS_NULL(value)) { htsbuf_append(out, "null", 4); } else if(JSVAL_IS_STRING(value)) { js_json_emit_str(cx, value, out); } else if(JSVAL_IS_OBJECT(value)) { JSObject *obj = JSVAL_TO_OBJECT(value); JSClass *c = JS_GetClass(cx, obj); if(!strcmp(c->name, "XML")) // Treat some classes special js_json_emit_str(cx, value, out); else { if(json_encode_from_object(cx, obj, out)) htsbuf_append(out, "null", 4); } } }
static JSBool js_item_moveBefore(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { js_item_t *ji = JS_GetPrivate(cx, obj); js_item_t *before; if(argc >= 1 && JSVAL_IS_OBJECT(argv[0]) && !JSVAL_IS_NULL(argv[0]) && JS_GetClass(cx, JSVAL_TO_OBJECT(argv[0])) == &item_class) { before = JS_GetPrivate(cx, JSVAL_TO_OBJECT(argv[0])); } else { before = NULL; } TAILQ_REMOVE(&ji->ji_model->jm_items, ji, ji_link); if(before) TAILQ_INSERT_BEFORE(before, ji, ji_link); else TAILQ_INSERT_TAIL(&ji->ji_model->jm_items, ji, ji_link); prop_move(ji->ji_root, before ? before->ji_root : NULL); *rval = JSVAL_VOID; return JS_TRUE; }
std::string gjs_debug_object(JSObject * const obj) { std::ostringstream out; const JSClass* clasp = JS_GetClass(obj); out << "<object " << clasp->name << " at " << obj << '>'; return out.str(); }
void gjs_define_error_class(JSContext *context, JSObject *in_object, GIEnumInfo *info) { const char *constructor_name; GIBoxedInfo *glib_error_info; JSObject *prototype, *parent_proto; JSObject *constructor; Error *priv; /* See the comment in gjs_define_boxed_class() for an * explanation of how this all works; Error is pretty much the * same as Boxed (except that we inherit from GLib.Error). */ constructor_name = g_base_info_get_name( (GIBaseInfo*) info); g_irepository_require(NULL, "GLib", "2.0", (GIRepositoryLoadFlags) 0, NULL); glib_error_info = (GIBoxedInfo*) g_irepository_find_by_name(NULL, "GLib", "Error"); parent_proto = gjs_lookup_generic_prototype(context, glib_error_info); g_base_info_unref((GIBaseInfo*)glib_error_info); if (!gjs_init_class_dynamic(context, in_object, parent_proto, g_base_info_get_namespace( (GIBaseInfo*) info), constructor_name, &gjs_error_class, gjs_error_constructor, 1, /* props of prototype */ &gjs_error_proto_props[0], /* funcs of prototype */ &gjs_error_proto_funcs[0], /* props of constructor, MyConstructor.myprop */ NULL, /* funcs of constructor, MyConstructor.myfunc() */ &gjs_error_constructor_funcs[0], &prototype, &constructor)) { gjs_log_exception(context); g_error("Can't init class %s", constructor_name); } GJS_INC_COUNTER(gerror); priv = g_slice_new0(Error); priv->info = info; g_base_info_ref( (GIBaseInfo*) priv->info); priv->domain = g_quark_from_string (g_enum_info_get_error_domain(priv->info)); JS_SetPrivate(prototype, priv); gjs_debug(GJS_DEBUG_GBOXED, "Defined class %s prototype is %p class %p in object %p", constructor_name, prototype, JS_GetClass(prototype), in_object); gjs_define_enum_values(context, constructor, priv->info); gjs_define_enum_static_methods(context, constructor, priv->info); }
std::string ObjectWrapper::getClassName() { auto jsclass = JS_GetClass(_object); if (jsclass) return jsclass->name; JS::RootedValue ctor(_context); getValue(InternedString::constructor, &ctor); return ObjectWrapper(_context, ctor).getString(InternedString::name); }
bool rs::jsapi::Object::IsObject(const Value& value) { auto isObject = value.isObject() && !value.isNull(); if (isObject) { auto obj = value.toObject(); isObject = obj; if (isObject) { auto klass = JS_GetClass(obj); isObject = klass && klass->name && std::strcmp(klass->name, class_.name) == 0; } } return isObject; }
JSObject* gjs_error_from_gerror(JSContext *context, GError *gerror, gboolean add_stack) { JSObject *obj; JSObject *proto; Error *priv; Error *proto_priv; GIEnumInfo *info; if (gerror == NULL) return NULL; info = find_error_domain_info(gerror->domain); if (!info) { /* We don't have error domain metadata */ /* Marshal the error as a plain GError */ GIBaseInfo *glib_boxed; JSObject *retval; glib_boxed = g_irepository_find_by_name(NULL, "GLib", "Error"); retval = gjs_boxed_from_c_struct(context, glib_boxed, gerror, 0); g_base_info_unref(glib_boxed); return retval; } gjs_debug_marshal(GJS_DEBUG_GBOXED, "Wrapping struct %s %p with JSObject", g_base_info_get_name((GIBaseInfo *)info), gboxed); proto = gjs_lookup_generic_prototype(context, info); proto_priv = priv_from_js(context, proto); obj = JS_NewObjectWithGivenProto(context, JS_GetClass(proto), proto, gjs_get_import_global (context)); GJS_INC_COUNTER(gerror); priv = g_slice_new0(Error); JS_SetPrivate(obj, priv); priv->info = info; priv->domain = proto_priv->domain; g_base_info_ref( (GIBaseInfo*) priv->info); priv->gerror = g_error_copy(gerror); if (add_stack) define_error_properties(context, obj); return obj; }
/** * implementation of InstallVersion.compareTo() */ static JSBool PR_CALLBACK su_versionCompareTo(JSContext *cx, JSObject *obj, uint argc, jsval *argv, jsval *rval) { int compval; VERSION thisver, v; if ( argc == 0 ) return JS_FALSE; if ( JSVAL_IS_STRING(argv[0]) ) { su_strToVersion( JS_GetStringBytes(JSVAL_TO_STRING(argv[0])), &v ); } else if (JSVAL_IS_OBJECT(argv[0]) ) { /* check to make sure it's an InstallVersion */ JSObject *argobj; JSClass *argclass; argobj = JSVAL_TO_OBJECT(argv[0]); argclass = JS_GetClass(cx, argobj); if ( argclass != &su_version_class ) { /* XXX report error here */ return JS_FALSE; } su_objToVers( cx, argobj, &v ); } else { v.major = v.minor = v.release = v.build = 0; if ( argc > 0 && JSVAL_IS_INT(argv[0]) ) v.major = JSVAL_TO_INT(argv[0]); if ( argc > 1 && JSVAL_IS_INT(argv[1]) ) v.minor = JSVAL_TO_INT(argv[1]); if ( argc > 2 && JSVAL_IS_INT(argv[2]) ) v.release = JSVAL_TO_INT(argv[2]); if ( argc > 3 && JSVAL_IS_INT(argv[3]) ) v.build = JSVAL_TO_INT(argv[3]); } su_objToVers( cx, obj, &thisver ); compval = su_compareVersions( &thisver, &v ); *rval = INT_TO_JSVAL(compval); return JS_TRUE; }
bool rs::jsapi::Object::SetPrivate(Value& value, uint64_t data, void* ptr) { auto set = false; if (value.isObject()) { auto obj = value.toObject(); auto klass = JS_GetClass(obj); if (klass != nullptr && std::strcmp(klass->name, Object::class_.name) == 0) { auto state = GetState(obj); state->data = data; state->ptr = ptr; set = true; } } return set; }
bool rs::jsapi::Object::GetPrivate(const Value& value, uint64_t& data, void*& ptr) { auto get = false; if (value.isObject()) { auto obj = value.toObject(); auto klass = JS_GetClass(obj); if (klass != nullptr && std::strcmp(klass->name, Object::class_.name) == 0) { auto state = GetState(obj); data = state->data; ptr = state->ptr; get = true; } } return get; }
nsIScriptGlobalObject * nsWWJSUtils::GetStaticScriptGlobal(JSContext* aContext, JSObject* aObj) { nsISupports* supports; JSClass* clazz; JSObject* parent; JSObject* glob = aObj; // starting point for search if (!glob) return nsnull; while (nsnull != (parent = JS_GetParent(aContext, glob))) glob = parent; #ifdef JS_THREADSAFE clazz = JS_GetClass(aContext, glob); #else clazz = JS_GetClass(glob); #endif if (!clazz || !(clazz->flags & JSCLASS_HAS_PRIVATE) || !(clazz->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS) || !(supports = (nsISupports*) JS_GetPrivate(aContext, glob))) { return nsnull; } nsCOMPtr<nsIXPConnectWrappedNative> wrapper(do_QueryInterface(supports)); NS_ENSURE_TRUE(wrapper, nsnull); nsCOMPtr<nsIScriptGlobalObject> sgo(do_QueryWrappedNative(wrapper)); // This will return a pointer to something we're about to release, // but that's ok here. return sgo; }
JSBool JetpackChild::EvalInSandbox(JSContext* cx, uintN argc, jsval* vp) { if (argc != 2) { JS_ReportError(cx, "evalInSandbox takes two arguments"); return JS_FALSE; } jsval* argv = JS_ARGV(cx, vp); JSObject* obj; if (!JSVAL_IS_OBJECT(argv[0]) || !(obj = JSVAL_TO_OBJECT(argv[0]))) { JS_ReportError(cx, "The first argument to evalInSandbox must be a global object created using createSandbox."); JS_ASSERT(JS_FALSE); return JS_FALSE; } // Unwrap, and switch compartments obj = js::UnwrapObject(obj); JSAutoEnterCompartment ac; if (!ac.enter(cx, obj)) return JS_FALSE; if (&sGlobalClass != JS_GetClass(cx, obj) || obj == JS_GetGlobalObject(cx)) { JS_ReportError(cx, "The first argument to evalInSandbox must be a global object created using createSandbox."); JS_ASSERT(JS_FALSE); return JS_FALSE; } if (!JS_WrapValue(cx, &argv[1])) return JS_FALSE; JSString* str = JS_ValueToString(cx, argv[1]); if (!str) return JS_FALSE; size_t length; const jschar* chars = JS_GetStringCharsAndLength(cx, str, &length); if (!chars) return JS_FALSE; js::AutoValueRooter ignored(cx); return JS_EvaluateUCScript(cx, obj, chars, length, "", 1, ignored.jsval_addr()); }
static JSBool getWrappedComponent(JSContext *cx, uintN argc, jsval *argv, jsval *rval, uint32 slotIndex) { JSObject *wrapped; if (!JS_ConvertArguments(cx, argc, argv, "o", &wrapped)) return JS_FALSE; if (JS_GetClass(cx, wrapped) == &sFlexibleWrapper_JSClass.base) { if (!JS_GetReservedSlot(cx, wrapped, slotIndex, rval)) return JS_FALSE; return JS_TRUE; } *rval = JSVAL_NULL; return JS_TRUE; }
static bool constructHook(JSContext *cx, unsigned argc, jsval *vp) { JS::CallArgs args = CallArgsFromVp(argc, vp); // Check that arguments were passed properly from JS_New. JS::RootedObject obj(cx, JS_NewObject(cx, js::Jsvalify(&JSObject::class_), JS::NullPtr(), JS::NullPtr())); if (!obj) { JS_ReportError(cx, "test failed, could not construct object"); return false; } if (strcmp(JS_GetClass(obj)->name, "Object") != 0) { JS_ReportError(cx, "test failed, wrong class for 'this'"); return false; } if (args.length() != 3) { JS_ReportError(cx, "test failed, argc == %d", args.length()); return false; } if (!args[0].isInt32() || args[2].toInt32() != 2) { JS_ReportError(cx, "test failed, wrong value in args[2]"); return false; } if (!args.isConstructing()) { JS_ReportError(cx, "test failed, not constructing"); return false; } // Perform a side-effect to indicate that this hook was actually called. JS::RootedValue value(cx, args[0]); JS::RootedObject callee(cx, &args.callee()); if (!JS_SetElement(cx, callee, 0, value)) return false; args.rval().setObject(*obj); // trash the argv, perversely args[0].setUndefined(); args[1].setUndefined(); args[2].setUndefined(); return true; }
nsIScriptGlobalObject * nsJSUtils::GetStaticScriptGlobal(JSObject* aObj) { const JSClass* clazz; JSObject* glob = aObj; // starting point for search if (!glob) return nullptr; glob = js::GetGlobalForObjectCrossCompartment(glob); NS_ABORT_IF_FALSE(glob, "Infallible returns null"); clazz = JS_GetClass(glob); // Whenever we end up with globals that are JSCLASS_IS_DOMJSCLASS // and have an nsISupports DOM object, we will need to modify this // check here. MOZ_ASSERT(!(clazz->flags & JSCLASS_IS_DOMJSCLASS)); nsISupports* supports; if (!(clazz->flags & JSCLASS_HAS_PRIVATE) || !(clazz->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS) || !(supports = (nsISupports*)::JS_GetPrivate(glob))) { return nullptr; } // We might either have a window directly (e.g. if the global is a // sandbox whose script object principal pointer is a window), or an // XPCWrappedNative for a window. We could also have other // sandbox-related script object principals, but we can't do much // about those short of trying to walk the proto chain of |glob| // looking for a window or something. nsCOMPtr<nsIScriptGlobalObject> sgo(do_QueryInterface(supports)); if (!sgo) { nsCOMPtr<nsIXPConnectWrappedNative> wrapper(do_QueryInterface(supports)); if (!wrapper) { return nullptr; } sgo = do_QueryWrappedNative(wrapper); } // We're returning a pointer to something that's about to be // released, but that's ok here. return sgo; }
/** * focus() - This method puts the focus on this element * * params - none; * return - void */ JSBool jhtml_anchor_focus(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { LOG_HTMLDOM("jhtml_anchor_focus\n"); if (JS_GetClass(obj) == &JSHtmlAnchorElement) { HTMLElement *pElem = (HTMLElement *) jhutil_GetPrivate(cx, obj); if (!pElem) { return JS_TRUE; } pElem->Focus(); } *rval = JSVAL_VOID; return JS_TRUE; }
void js_prop_set_from_jsval(JSContext *cx, prop_t *p, jsval value) { JSBool b; if(JSVAL_IS_INT(value)) { prop_set_int(p, JSVAL_TO_INT(value)); } else if(JSVAL_IS_BOOLEAN(value)) { prop_set_int(p, JSVAL_TO_BOOLEAN(value)); } else if(JSVAL_IS_NULL(value) || JSVAL_IS_VOID(value)) { prop_set_void(p); } else if(JSVAL_IS_DOUBLE(value)) { double d; if(JS_ValueToNumber(cx, value, &d)) prop_set_float(p, d); } else if(JS_HasInstance(cx, RichText, value, &b) && b) { JSObject *o = JSVAL_TO_OBJECT(value); jsval v2; if(!JS_EnterLocalRootScope(cx)) return; if(!JS_GetProperty(cx, o, "text", &v2)) { JS_LeaveLocalRootScope(cx); return; } prop_set_string_ex(p, NULL, JS_GetStringBytes(JS_ValueToString(cx, v2)), PROP_STR_RICH); JS_LeaveLocalRootScope(cx); } else if(JSVAL_IS_STRING(value)) { js_prop_from_str(cx, p, value); } else if(JSVAL_IS_OBJECT(value)) { JSObject *obj = JSVAL_TO_OBJECT(value); JSClass *c = JS_GetClass(cx, obj); if(!strcmp(c->name, "XML")) // Treat some classes special js_prop_from_str(cx, p, value); else js_prop_from_object(cx, obj, p); } else { prop_set_void(p); } }
ComponentJS::ComponentJS(const std::string& scriptFileName) : _scriptFileName(scriptFileName) , _jsObj(nullptr) { ScriptingCore* engine = ScriptingCore::getInstance(); JSContext* cx = engine->getGlobalContext(); // Require script JS::RootedValue classValue(cx); _succeedLoadingScript = engine->requireScript(_scriptFileName.c_str(), &classValue); if (_succeedLoadingScript) { JS::RootedObject classObj(cx, classValue.toObjectOrNull()); const JSClass* theClass = JS_GetClass(classObj); JS::RootedValue protoValue(cx); JS_GetProperty(cx, classObj, "prototype", &protoValue); TypeTest<ComponentJS> t; js_type_class_t *typeClass = nullptr; std::string typeName = t.s_name(); auto typeMapIter = _js_global_type_map.find(typeName); CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!"); typeClass = typeMapIter->second; mozilla::Maybe<JS::PersistentRootedObject> *jsObj = new (std::nothrow) mozilla::Maybe<JS::PersistentRootedObject>(); JS::RootedObject proto(cx, protoValue.toObjectOrNull()); JS::RootedObject parent(cx, typeClass->proto.ref()); jsObj->construct(cx); JS::RootedObject obj(cx, JS_NewObject(cx, theClass, proto, parent)); jsObj->ref() = obj; // Unbind current proxy binding js_proxy_t* jsproxy = js_get_or_create_proxy<ComponentJS>(cx, this); JS::RemoveObjectRoot(cx, &jsproxy->obj); jsb_remove_proxy(jsproxy); // link the native object with the javascript object jsb_new_proxy(this, jsObj->ref()); _jsObj = jsObj; } }
static void ValueToString(JSContext *cx, jsval aJSValue, nsString& aString) { if (JSVAL_IS_VOID(aJSValue)) { aString.Assign(kUndefined, STRLEN_ARRAY(kUndefined)); } else if (JSVAL_IS_NULL(aJSValue)) { aString.Assign(kNull, STRLEN_ARRAY(kNull)); } else if (JSVAL_IS_INT(aJSValue)) { jsint i = JSVAL_TO_INT(aJSValue); char buf[20]; PR_snprintf(buf, sizeof(buf), "%d", i); aString.Assign(NS_ConvertASCIItoUTF16(buf)); } else if (JSVAL_IS_DOUBLE(aJSValue)) { jsdouble d = JSVAL_TO_DOUBLE(aJSValue); char buf[50]; PR_snprintf(buf, sizeof(buf), "%f", d); aString.Assign(NS_ConvertASCIItoUTF16(buf)); } else if (JSVAL_IS_BOOLEAN(aJSValue)) { JSBool b = JSVAL_TO_BOOLEAN(aJSValue); if (b) aString.Assign(kTrue, STRLEN_ARRAY(kTrue)); else aString.Assign(kFalse, STRLEN_ARRAY(kFalse)); } else if (JSVAL_IS_STRING(aJSValue)) { JSString *str = JSVAL_TO_STRING(aJSValue); size_t len; const jschar *chars = JS_GetStringCharsAndLength(cx, str, &len); NS_ASSERTION(chars, "out of memory"); if (chars) { NS_ASSERTION(sizeof(jschar) == sizeof(PRUnichar), "char size mismatch"); aString.Assign(reinterpret_cast<const PRUnichar*>(chars), len); } } else { JSObject *obj = JSVAL_TO_OBJECT(aJSValue); JSClass *clazz = JS_GetClass(cx, obj); aString.Assign(PRUnichar('[')); aString.Append(NS_ConvertASCIItoUTF16(clazz->name)); aString.Append(PRUnichar(']')); } }
ComponentJS::ComponentJS(const std::string& scriptFileName) : _scriptFileName(scriptFileName) , _jsObj(nullptr) { ScriptingCore* engine = ScriptingCore::getInstance(); JSContext* cx = engine->getGlobalContext(); // Require script JS::RootedValue classValue(cx); _succeedLoadingScript = engine->requireScript(_scriptFileName.c_str(), &classValue); if (_succeedLoadingScript) { JS::RootedObject classObj(cx, classValue.toObjectOrNull()); const JSClass* theClass = JS_GetClass(classObj); JS::RootedValue protoValue(cx); JS_GetProperty(cx, classObj, "prototype", &protoValue); mozilla::Maybe<JS::PersistentRootedObject> *jsObj = new (std::nothrow) mozilla::Maybe<JS::PersistentRootedObject>(); js_type_class_t *typeClass = js_get_type_from_native<cocos2d::ComponentJS>(this); JS::RootedObject proto(cx, protoValue.toObjectOrNull()); JS::RootedObject parent(cx, typeClass->proto.ref()); jsObj->construct(cx); JS::RootedObject obj(cx, JS_NewObject(cx, theClass, proto, parent)); jsObj->ref() = obj; // Unbind current proxy binding js_proxy_t* nproxy = jsb_get_native_proxy(this); if (nproxy) { #if CC_ENABLE_GC_FOR_NATIVE_OBJECTS JS::RemoveObjectRoot(cx, &nproxy->obj); #endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS jsb_remove_proxy(nproxy, jsb_get_js_proxy(nproxy->obj)); } // link the native object with the javascript object jsb_new_proxy(this, jsObj->ref()); _jsObj = jsObj; } }
JSBool js_cocos2dx_CCNode_copy(JSContext *cx, uint32_t argc, jsval *vp) { if (argc == 0) { JSObject *obj = JS_THIS_OBJECT(cx, vp); js_proxy_t *proxy; JS_GET_NATIVE_PROXY(proxy, obj); cocos2d::CCNode *node = (cocos2d::CCNode *)(proxy ? proxy->ptr : NULL); TEST_NATIVE_OBJECT(cx, node) JSClass *jsclass = JS_GetClass(obj); JSObject *proto = JS_GetPrototype(obj); JSObject *parent = JS_GetParent(obj); JSObject *jsret = JS_NewObject(cx, jsclass, proto, parent); cocos2d::CCObject *ret = node->copy(); if (ret && jsret) { JS_NEW_PROXY(proxy, ret, jsret); JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(jsret)); return JS_TRUE; } } return JS_FALSE; }
nsIScriptGlobalObject * nsJSUtils::GetStaticScriptGlobal(JSContext* aContext, JSObject* aObj) { nsISupports* supports; JSClass* clazz; JSObject* glob = aObj; // starting point for search if (!glob) return nsnull; glob = JS_GetGlobalForObject(aContext, glob); NS_ABORT_IF_FALSE(glob, "Infallible returns null"); clazz = JS_GetClass(glob); if (!clazz || !(clazz->flags & JSCLASS_HAS_PRIVATE) || !(clazz->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS) || !(supports = (nsISupports*)::JS_GetPrivate(glob))) { return nsnull; } // We might either have a window directly (e.g. if the global is a // sandbox whose script object principal pointer is a window), or an // XPCWrappedNative for a window. We could also have other // sandbox-related script object principals, but we can't do much // about those short of trying to walk the proto chain of |glob| // looking for a window or something. nsCOMPtr<nsIScriptGlobalObject> sgo(do_QueryInterface(supports)); if (!sgo) { nsCOMPtr<nsIXPConnectWrappedNative> wrapper(do_QueryInterface(supports)); NS_ENSURE_TRUE(wrapper, nsnull); sgo = do_QueryWrappedNative(wrapper); } // We're returning a pointer to something that's about to be // released, but that's ok here. return sgo; }
void gjs_define_param_class(JSContext *context, JS::HandleObject in_object) { const char *constructor_name; JS::RootedObject prototype(context), constructor(context); GIObjectInfo *info; constructor_name = "ParamSpec"; if (!gjs_init_class_dynamic(context, in_object, nullptr, "GObject", constructor_name, &gjs_param_class, gjs_param_constructor, 0, /* props of prototype */ &gjs_param_proto_props[0], /* funcs of prototype */ &gjs_param_proto_funcs[0], /* props of constructor, MyConstructor.myprop */ NULL, /* funcs of constructor, MyConstructor.myfunc() */ gjs_param_constructor_funcs, &prototype, &constructor)) { g_error("Can't init class %s", constructor_name); } JS::RootedObject gtype_obj(context, gjs_gtype_create_gtype_wrapper(context, G_TYPE_PARAM)); JS_DefineProperty(context, constructor, "$gtype", gtype_obj, JSPROP_PERMANENT); info = (GIObjectInfo*)g_irepository_find_by_gtype(g_irepository_get_default(), G_TYPE_PARAM); gjs_object_define_static_methods(context, constructor, G_TYPE_PARAM, info); g_base_info_unref( (GIBaseInfo*) info); gjs_debug(GJS_DEBUG_GPARAM, "Defined class %s prototype is %p class %p in object %p", constructor_name, prototype.get(), JS_GetClass(prototype), in_object.get()); }
JSObject* gjs_object_from_g_fundamental(JSContext *context, GIObjectInfo *info, void *gfundamental) { JSObject *proto; JSObject *object; if (gfundamental == NULL) return NULL; object = _fundamental_lookup_object(gfundamental); if (object) return object; gjs_debug_marshal(GJS_DEBUG_GFUNDAMENTAL, "Wrapping fundamental %s.%s %p with JSObject", g_base_info_get_namespace((GIBaseInfo *) info), g_base_info_get_name((GIBaseInfo *) info), gfundamental); proto = gjs_lookup_fundamental_prototype_from_gtype(context, G_TYPE_FROM_INSTANCE(gfundamental)); object = JS_NewObjectWithGivenProto(context, JS_GetClass(proto), proto, gjs_get_import_global(context)); if (object == NULL) goto out; init_fundamental_instance(context, object); associate_js_instance_to_fundamental(context, object, gfundamental, FALSE); out: return object; }
JSBool unwrapAnyObject(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { JSObject *wrapped; JSObject *wrappee = NULL; if (!JS_ConvertArguments(cx, argc, argv, "o", &wrapped)) return JS_FALSE; JSClass *klass = JS_GetClass(cx, wrapped); if (klass && (klass->flags & JSCLASS_IS_EXTENDED)) { JSExtendedClass *eClass = (JSExtendedClass *) klass; if (eClass->wrappedObject != NULL) wrappee = eClass->wrappedObject(cx, wrapped); } if (wrappee) *rval = OBJECT_TO_JSVAL(wrappee); else *rval = JSVAL_NULL; return JS_TRUE; }
/** * blur - This method removes the focus from this element * * params - none; * return - void; */ JSBool jhtml_anchor_blur(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { LOG_HTMLDOM("jhtml_anchor_blur\n"); if (JS_GetClass(obj) == &JSHtmlAnchorElement) { HTMLElement *pElem = (HTMLElement *) jhutil_GetPrivate(cx, obj); if (!pElem) { return JS_TRUE; } HTMLDocument *pDoc = (pElem)? pElem->GetDocument() : 0; if (pDoc && pDoc->Body()) { pDoc->Body()->Focus(); } } *rval = JSVAL_VOID; return JS_TRUE; }
void gjs_define_param_class(JSContext *context, JSObject *in_object) { const char *constructor_name; JSObject *prototype; jsval value; JSObject *constructor; constructor_name = "ParamSpec"; if (!gjs_init_class_dynamic(context, in_object, NULL, "GObject", constructor_name, &gjs_param_class, gjs_param_constructor, 0, /* props of prototype */ &gjs_param_proto_props[0], /* funcs of prototype */ &gjs_param_proto_funcs[0], /* props of constructor, MyConstructor.myprop */ NULL, /* funcs of constructor, MyConstructor.myfunc() */ gjs_param_constructor_funcs, &prototype, &constructor)) { g_error("Can't init class %s", constructor_name); } value = OBJECT_TO_JSVAL(gjs_gtype_create_gtype_wrapper(context, G_TYPE_PARAM)); JS_DefineProperty(context, constructor, "$gtype", value, NULL, NULL, JSPROP_PERMANENT); gjs_debug(GJS_DEBUG_GPARAM, "Defined class %s prototype is %p class %p in object %p", constructor_name, prototype, JS_GetClass(prototype), in_object); }