QObject* QtJambiShell_QDeclarativeListProperty::object() { QTJAMBI_DEBUG_TRACE("(shell) entering: QDeclarativeListProperty::object()"); jmethodID method_id = m_vtable->method(8); if (method_id) { JNIEnv *__jni_env = qtjambi_current_environment(); if (!__jni_env) { return QtjambiDeclarativeListProperty::object(); } __jni_env->PushLocalFrame(100); QObject* __qt_return_value; jobject __java_return_value_object = m_link->javaObject(__jni_env); if(__jni_env->IsSameObject(__java_return_value_object, 0) == JNI_FALSE) { jobject __java_return_value = __jni_env->CallObjectMethod(__java_return_value_object, method_id); qtjambi_exception_check(__jni_env); QObject* __qt_return_value_tmp = (QObject* ) qtjambi_to_qobject(__jni_env, __java_return_value); QTJAMBI_EXCEPTION_CHECK(__jni_env); __qt_return_value = __qt_return_value_tmp; } else { qtjambishell_throw_nullpointerexception(__jni_env, "QDeclarativeListProperty::object()"); __qt_return_value = 0; } qtjambi_exception_check(__jni_env); __jni_env->PopLocalFrame(0); QTJAMBI_DEBUG_TRACE("(shell) -> leaving: QDeclarativeListProperty::object()"); return __qt_return_value; } else { QTJAMBI_DEBUG_TRACE("(shell) -> super() and leaving: QDeclarativeListProperty::object()"); return QtjambiDeclarativeListProperty::object(); } }
void init(jclass declaringClass, jobjectArray javaArguments, QVarLengthArray<jvalue> convertedArgs, jintArray conversionScheme) { JNIEnv *env = qtjambi_current_environment(); Q_ASSERT(env != 0); if (env != 0) { if (declaringClass != 0) m_declaring_class = reinterpret_cast<jclass>(env->NewGlobalRef(declaringClass)); if (conversionScheme != 0) m_conversion_scheme = reinterpret_cast<jintArray>(env->NewGlobalRef(conversionScheme)); if (javaArguments != 0) { // Convert all the arguments m_arguments = qtjambi_from_jobjectArray(env, javaArguments, m_conversion_scheme, true); } else { // Copy the converted arguments jint *a = m_conversion_scheme != 0 ? env->GetIntArrayElements(m_conversion_scheme, 0) : 0; for (int i=0; i<convertedArgs.size(); ++i) { if (a != 0 && a[i] == 'L') { jvalue val; val.l = env->NewGlobalRef(convertedArgs[i].l); m_arguments.append(val); } else { m_arguments.append(convertedArgs[i]); } } env->ReleaseIntArrayElements(m_conversion_scheme, a, JNI_ABORT); } } }
void QtJambiShell_QDeclarativeListProperty::clear() { QTJAMBI_DEBUG_TRACE("(shell) entering: QDeclarativeListProperty::clear()"); jmethodID method_id = m_vtable->method(6); if (method_id) { JNIEnv *__jni_env = qtjambi_current_environment(); if (!__jni_env) { QtjambiDeclarativeListProperty::clear(); return; } __jni_env->PushLocalFrame(100); jobject __java_return_value_object = m_link->javaObject(__jni_env); if(__jni_env->IsSameObject(__java_return_value_object, 0) == JNI_FALSE) { __jni_env->CallVoidMethod(__java_return_value_object, method_id); qtjambi_exception_check(__jni_env); } else { qtjambishell_throw_nullpointerexception(__jni_env, "QDeclarativeListProperty::clear()"); } qtjambi_exception_check(__jni_env); __jni_env->PopLocalFrame(0); QTJAMBI_DEBUG_TRACE("(shell) -> leaving: QDeclarativeListProperty::clear()"); } else { QTJAMBI_DEBUG_TRACE("(shell) -> super() and leaving: QDeclarativeListProperty::clear()"); QtjambiDeclarativeListProperty::clear(); } }
void operator()() { JNIEnv *env = qtjambi_current_environment(); Q_ASSERT(env != 0); if (env != 0 && m_method_id != 0) { qtjambi_invoke_method(env, m_functor, m_method_id, m_result_type, m_arguments); } else { qWarning("Run functor called with invalid data. JNI Environment == %p, method_id == %p", env, m_method_id); } }
JObjectWrapper operator()() { JNIEnv *env = qtjambi_current_environment(); Q_ASSERT(env != 0); if (env != 0 && m_method_id != 0) { jobject javaResult = qtjambi_invoke_method(env, m_functor, m_method_id, m_result_type, m_arguments); return javaResult != 0 ? qtjambi_to_jobjectwrapper(env, javaResult) : JObjectWrapper(); } else { qWarning("Run functor called with invalid data. JNI Environment == %p, method id == %p", env, m_method_id); return JObjectWrapper(); } }
int main(int argc, char **argv) { if (argc < 2) { printf("Usage:\n" " jambi <vm options> [classname] options\n"); return 0; } int start = 2; QStringList vm_parameters; for(int i=1; i<argc; i++){ QString arg = QLatin1String(argv[i]); if(arg.startsWith("-")){ vm_parameters << arg; start++; }else{ break; } } qtjambi_initialize_vm(vm_parameters); JNIEnv *env = qtjambi_current_environment(); QString class_name = QLatin1String(argv[start-1]); jclass java_class = env->FindClass(class_name.replace('.', '/').toLatin1()); if (!java_class) { printf("failed to find class: '%s'\n", qPrintable(class_name)); return 0; } jmethodID main_id = env->GetStaticMethodID(java_class, "main", "([Ljava/lang/String;)V"); if (!main_id) { printf("failed to find main(String[])\n"); return 0; } jclass string_class = env->FindClass("java/lang/String"); Q_ASSERT(string_class); jobjectArray args = env->NewObjectArray(argc - start, string_class, 0); for (int i = start; i < argc; ++i) { env->SetObjectArrayElement(args, i - start, qtjambi_from_qstring(env, QLatin1String(argv[i]))); } env->CallStaticVoidMethod(java_class, main_id, args); qtjambi_exception_check(env); qtjambi_destroy_vm(); return 0; }
// emitting (writeShellDestructor) QtJambiShell_QDeclarativeListProperty::~QtJambiShell_QDeclarativeListProperty() { QTJAMBI_DEBUG_TRACE("(shell) entering: QtJambiShell_QDeclarativeListProperty::~QtJambiShell_QDeclarativeListProperty()"); #ifdef QT_DEBUG if (m_vtable) m_vtable->deref(); #endif if (m_link) { JNIEnv *__jni_env = qtjambi_current_environment(); if (__jni_env != 0) m_link->nativeShellObjectDestroyed(__jni_env); } QTJAMBI_DEBUG_TRACE("(shell) leaving: QtJambiShell_QDeclarativeListProperty::~QtJambiShell_QDeclarativeListProperty()"); }
void operator ()(JObjectWrapper &wrapper) { JNIEnv *env = qtjambi_current_environment(); if (env != 0 && m_functor) { jobject javaObject = qtjambi_from_jobjectwrapper(env, wrapper); StaticCache *sc = StaticCache::instance(); sc->resolveQtConcurrent_MapFunctor(); if (javaObject != 0) env->CallVoidMethod(m_functor, sc->QtConcurrent_MapFunctor.map, javaObject); } else { qWarning("Map functor called with invalid data. JNI Environment == %p, java functor object == %p", env, m_functor); } }
bool operator()(const JObjectWrapper &wrapper) { JNIEnv *env = qtjambi_current_environment(); if (env != 0 && m_functor != 0) { jobject javaObject = qtjambi_from_jobjectwrapper(env, wrapper); StaticCache *sc = StaticCache::instance(); sc->resolveQtConcurrent_FilteredFunctor(); return env->CallBooleanMethod(m_functor, sc->QtConcurrent_FilteredFunctor.filter, javaObject); } else { qWarning("Filtered functor called with invalid data. JNI Environment == %p, java functor object == %p", env, m_functor); return false; } }
~RunFunctorBase() { JNIEnv *env = qtjambi_current_environment(); if (env != 0) { if (m_declaring_class != 0) env->DeleteGlobalRef(m_declaring_class); jint *a = m_conversion_scheme != 0 ? env->GetIntArrayElements(m_conversion_scheme, 0) : 0; for (int i=0; i<m_arguments.size(); ++i) { if (a != 0 && a[i] == 'L') env->DeleteGlobalRef(m_arguments[i].l); } env->ReleaseIntArrayElements(m_conversion_scheme, a, JNI_ABORT); if (m_conversion_scheme != 0) env->DeleteGlobalRef(m_conversion_scheme); } }
static bool compare(const QVariant::Private *a, const QVariant::Private *b) { Q_ASSERT(a->type == b->type); const JObjectWrapper *wrapper_a = cast_to_object_wrapper(a); if (wrapper_a) { const JObjectWrapper *wrapper_b = cast_to_object_wrapper(b); JNIEnv *env = qtjambi_current_environment(); StaticCache *sc = StaticCache::instance(); return env->CallBooleanMethod(wrapper_a->object, sc->Object.equals, wrapper_b->object); } if (QtJambiVariant::getLastHandler()) return QtJambiVariant::getLastHandler()->compare(a, b); else if (qcoreVariantHandler()) return qcoreVariantHandler()->compare(a, b); return false; }
JObjectWrapper operator ()(const JObjectWrapper &wrapper) { JNIEnv *env = qtjambi_current_environment(); if (env != 0 && m_functor) { jobject javaObject = qtjambi_from_jobjectwrapper(env, wrapper); StaticCache *sc = StaticCache::instance(); sc->resolveQtConcurrent_MappedFunctor(); jobject javaResult = env->CallObjectMethod(m_functor, sc->QtConcurrent_MappedFunctor.map, javaObject); return qtjambi_to_jobjectwrapper(env, javaResult); } else { qWarning("Mapped functor called with invalid data. JNI Environment == %p, java functor object == %p", env, m_functor); return JObjectWrapper(); } }
static void streamDebug(QDebug dbg, const QVariant &v) { if((uint)v.userType() == JOBJECTWRAPPER_TYPE) { const JObjectWrapper wrapper = v.value<JObjectWrapper>(); JNIEnv *env = qtjambi_current_environment(); StaticCache *sc = StaticCache::instance(); sc->resolveObject(); jobject java_object = wrapper.object; dbg << qtjambi_to_qstring(env, static_cast<jstring>(env->CallObjectMethod(java_object, sc->Object.toString))); return; } else if (QtJambiVariant::getLastHandler()) { QtJambiVariant::getLastHandler()->debugStream(dbg, v); return; } else if (qcoreVariantHandler()) { qcoreVariantHandler()->debugStream(dbg, v); return; } }
void operator()(JObjectWrapper &result, const JObjectWrapper &wrapper) { JNIEnv *env = qtjambi_current_environment(); if (env != 0 && m_functor != 0) { StaticCache *sc = StaticCache::instance(); sc->resolveQtConcurrent_ReducedFunctor(); // reduce() is synchronous, so while this data is static in terms // of the map/reduce operation, it does not need to be protected if (m_first_call) { m_first_call = false; result = JObjectWrapper(env, env->CallObjectMethod(m_functor, sc->QtConcurrent_ReducedFunctor.defaultResult)); } jobject javaObject = qtjambi_from_jobjectwrapper(env, wrapper); jobject javaResult = qtjambi_from_jobjectwrapper(env, result); env->CallVoidMethod(m_functor, sc->QtConcurrent_ReducedFunctor.reduce, javaResult, javaObject); } else { qWarning("Reduce functor called with invalid data. JNI Environment == %p, java functor object == %p", env, m_functor); } }
static bool convert(const QVariant::Private *d, QVariant::Type t, void *result, bool *ok) { const JObjectWrapper *wrapper = cast_to_object_wrapper(d); if(wrapper != 0) { JNIEnv *env = qtjambi_current_environment(); StaticCache *sc = StaticCache::instance(); jobject java_object = wrapper->object; switch (t) { case QVariant::Int : sc->resolveQtEnumerator(); if (env->IsInstanceOf(java_object, sc->QtEnumerator.class_ref)) { *((int*)result) = env->CallIntMethod(java_object, sc->QtEnumerator.value); return true; } break; case QVariant::String : sc->resolveObject(); *((QString*)result) = qtjambi_to_qstring(env, static_cast<jstring>(env->CallObjectMethod(java_object, sc->Object.toString))); return true; break; default : return false; } } if (QtJambiVariant::getLastHandler()) return QtJambiVariant::getLastHandler()->convert(d, t, result, ok); else if (qcoreVariantHandler()) return qcoreVariantHandler()->convert(d, t, result, ok); return false; }
void init(jobject functor) { JNIEnv *env = qtjambi_current_environment(); if (env != 0) m_functor = env->NewGlobalRef(functor); }
virtual ~Functor() { JNIEnv *env = qtjambi_current_environment(); if (env != 0) env->DeleteGlobalRef(m_functor); }