JNIEXPORT jstring JNICALL
Java_org_gnome_glib_GlibMisc_g_1format_1size_1for_1display
(
JNIEnv* env,
jclass cls,
jlong _size
)
{
char* result;
jstring _result;
goffset size;
// convert parameter size
size = (goffset) _size;
// call function
result = g_format_size_for_display(size);
// cleanup parameter size
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// cleanup return value
if (result != NULL) {
g_free(result);
}
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_gtk_GtkAssistant_gtk_1assistant_1get_1page_1title
(
JNIEnv* env,
jclass cls,
jlong _self,
jlong _page
)
{
const gchar* result;
jstring _result;
GtkAssistant* self;
GtkWidget* page;
// convert parameter self
self = (GtkAssistant*) _self;
// convert parameter page
page = (GtkWidget*) _page;
// call function
result = gtk_assistant_get_page_title(self, page);
// cleanup parameter self
// cleanup parameter page
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_atk_AtkImage_atk_1image_1get_1image_1description
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
const gchar* result;
jstring _result;
AtkImage* self;
// convert parameter self
self = (AtkImage*) _self;
// call function
result = atk_image_get_image_description(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1get_1preview_1uri
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
char* result;
jstring _result;
GtkFileChooser* self;
// convert parameter self
self = (GtkFileChooser*) _self;
// call function
result = gtk_file_chooser_get_preview_uri(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// cleanup return value
if (result != NULL) {
g_free(result);
}
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_pango_PangoColor_pango_1color_1to_1string
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
gchar* result;
jstring _result;
PangoColor* self;
// convert parameter self
self = (PangoColor*) _self;
// call function
result = pango_color_to_string(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// cleanup return value
if (result != NULL) {
g_free(result);
}
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_gtk_GtkFontButton_gtk_1font_1button_1get_1title
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
const gchar* result;
jstring _result;
GtkFontButton* self;
// convert parameter self
self = (GtkFontButton*) _self;
// call function
result = gtk_font_button_get_title(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_atk_AtkAction_atk_1action_1get_1localized_1name
(
JNIEnv* env,
jclass cls,
jlong _self,
jint _i
)
{
const gchar* result;
jstring _result;
AtkAction* self;
gint i;
// convert parameter self
self = (AtkAction*) _self;
// convert parameter i
i = (gint) _i;
// call function
result = atk_action_get_localized_name(self, i);
// cleanup parameter self
// cleanup parameter i
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_pango_PangoFontDescription_pango_1font_1description_1to_1filename
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
char* result;
jstring _result;
PangoFontDescription* self;
// convert parameter self
self = (PangoFontDescription*) _self;
// call function
result = pango_font_description_to_filename(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// cleanup return value
if (result != NULL) {
g_free(result);
}
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1get_1icon_1name
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
const gchar* result;
jstring _result;
GtkWindow* self;
// convert parameter self
self = (GtkWindow*) _self;
// call function
result = gtk_window_get_icon_name(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_glib_GlibMisc_g_1get_1user_1special_1dir
(
JNIEnv* env,
jclass cls,
jint _directory
)
{
const gchar* result;
jstring _result;
GUserDirectory directory;
// convert parameter directory
directory = (GUserDirectory) _directory;
// call function
result = g_get_user_special_dir(directory);
// cleanup parameter directory
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// and finally
return _result;
}
/*
* Implements
* org.freedesktop.bindings.Environment.getenv(String variableName)
*/
JNIEXPORT jobject JNICALL
Java_org_freedesktop_bindings_Environment_getenv
(
JNIEnv *env,
jclass cls,
jstring _name
)
{
const gchar* name;
gchar* result;
// convert parameter name
name = bindings_java_getString(env, _name);
if (name == NULL) {
return NULL; /* OutOfMemoryError already thrown */
}
// call function
result = (gchar*) g_getenv(name);
// clean up name
bindings_java_releaseString(name);
// and return
return bindings_java_newString(env, result);
}
JNIEXPORT jstring JNICALL
Java_oscats_bindings_Time_strftime
(
JNIEnv *env,
jclass klass,
jstring _format,
jlong _timestamp
)
{
/*
* Call strftime() to generate the string in the desired format. We
* pass in size as the max, and the return value indicates how much was
* used.
*/
const char *format;
size_t size;
char buf[MAXWIDTH];
struct tm *brokendown;
time_t timestamp;
size = MAXWIDTH;
format = bindings_java_getString(env, _format);
if (format == NULL) {
return NULL; /* OutOfMemoryError already thrown */
}
timestamp = (time_t) _timestamp;
brokendown = localtime(×tamp);
size = strftime(buf, size, format, brokendown);
bindings_java_releaseString(format);
if (size == 0) {
// throw exception instead!
return bindings_java_newString(env, "Nothing returned!\0");
}
return bindings_java_newString(env, buf);
}
/*
* Implements
* org.freedesktop.bindings.Plumbing.toHexString(long pointer)
*/
JNIEXPORT jstring JNICALL
Java_org_freedesktop_bindings_Plumbing_toHexString
(
JNIEnv *env,
jclass cls,
jlong _pointer
)
{
const gchar* result;
result = bindings_java_memory_pointerToString((gpointer) _pointer);
return bindings_java_newString(env, result);
}
/**
* Implements
* org.gnome.glib.GObject.g_quark_to_string(long quark)
*/
JNIEXPORT jstring JNICALL
Java_oscats_glib_GObject_g_1quark_1to_1string
(
JNIEnv* env,
jclass cls,
jlong _quark
)
{
const gchar* str;
// call function
str = g_quark_to_string((GQuark)_quark);
// and return
return bindings_java_newString(env, str);
}
JNIEXPORT jstring JNICALL
Java_org_gnome_glib_GlibMisc_g_1get_1user_1name
(
JNIEnv* env,
jclass cls
)
{
const gchar* result;
jstring _result;
// call function
result = g_get_user_name();
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// and finally
return _result;
}
JNIEXPORT jstring JNICALL
Java_org_gnome_glib_GlibMisc_g_1markup_1escape_1text
(
JNIEnv* env,
jclass cls,
jstring _text,
jint _len
)
{
char* result;
jstring _result;
const gchar* text;
gssize len;
// convert parameter text
text = (const gchar*) bindings_java_getString(env, _text);
if (text == NULL) {
return NULL; // Java Exception already thrown
}
// convert parameter len
len = (gssize) _len;
// call function
result = g_markup_escape_text(text, len);
// cleanup parameter text
bindings_java_releaseString(text);
// cleanup parameter len
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// cleanup return value
if (result != NULL) {
g_free(result);
}
// and finally
return _result;
}
/**
* Implements
* org.gnome.glib.GObject.g_type_name(long object)
* called from
* org.gnome.glib.Plumbing.instanceForObject(long pointer)
* also made available via
* org.gnome.glib.GObject.typeName(Object object);
*/
JNIEXPORT jstring JNICALL
Java_oscats_glib_GObject_g_1type_1name
(
JNIEnv *env,
jclass cls,
jlong _object
)
{
GObject* object;
const gchar* name;
// translate value
object = (GObject*) _object;
// call function & macro
name = g_type_name(G_TYPE_FROM_INSTANCE(object));
//g_print("GObject (%ld): %s\n", (long) G_OBJECT_TYPE(object), name);
// return name. Guard against NullPointerException by returning an
// empty string instead of null
return bindings_java_newString(env, (name != NULL ? name : "\0"));
}
/**
* Implements
* org.gnome.glib.GValue.g_type_name(long value)
* called from
* org.gnome.glib.GValue.typeName(long value)
* called from
* org.gnome.glib.Plumbing.instanceFor(long pointer)
* and also made available via
* org.gnome.glib.GValue.typeName(Value value)
*/
JNIEXPORT jstring JNICALL
Java_org_gnome_glib_GValue_g_1type_1name
(
JNIEnv *env,
jclass cls,
jlong _value
)
{
GValue* value;
const gchar* name;
// translate value
value = (GValue*) _value;
// call function & macro
name = g_type_name(G_VALUE_TYPE(value));
//g_print("GValue g_type_name(%ld): %s\n", (long) G_VALUE_TYPE(value), name);
// return name. Guard against NullPointerException by returning an
// empty string instead of null
return bindings_java_newString(env, (name != NULL ? name : "\0"));
}
/**
* Implements
* org.gnome.glib.GValue.g_value_get_string(long value)
* called from
* org.gnome.glib.GValue.getString(Value value)
* called from
* org.gnome.glib.Object.getPropertyString(String name)
*
* Extract the string value from a GValue of G_TYPE_STRING, returning the
* primitive (well, String) to be used as such.
*/
JNIEXPORT jstring JNICALL
Java_org_gnome_glib_GValue_g_1value_1get_1string
(
JNIEnv* env,
jclass cls,
jlong _value
)
{
GValue* value;
const gchar* str;
// translate value
value = (GValue*) _value;
if (!G_VALUE_HOLDS_STRING(value)) {
bindings_java_throw(env, "You've asked for the string value of a GValue, but it's not a G_TYPE_STRING!");
return NULL;
}
// call function
str = g_value_get_string(value);
// and return
return bindings_java_newString(env, str);
}
/*
* Signature the prototype of (*GClosureMarshall), meeting the requirements
* to be the second argument to g_closure_set_marshal()
*/
static void
bindings_java_marshaller
(
GClosure* closure,
GValue* return_value,
guint n_param_values,
const GValue* param_values,
gpointer invocation_hint,
gpointer marshal_data
)
{
BindingsJavaClosure* bjc;
JNIEnv* env;
jvalue* jargs;
guint i;
GType type;
// Return values, as necessary
jboolean _b;
gboolean b;
jint _e;
jstring _str;
gchar* str;
GObject* obj;
/*
* Begin marshaller by downcasting the GClosure we got.
*/
bjc = (BindingsJavaClosure*) closure;
/*
* Get the JNIEnv interface pointer
*/
env = bindings_java_getEnv();
if (env == NULL) {
g_critical("Couldn't get JNIEnv interface, aborting marshal");
return;
}
/*
* Build the parameters for the callback. The signature of the
* handlers on the Java side for a signal "name" would be:
*
* receiveName(Signal handler, type arg0, type arg1, ...)
*
* Note that arg0 is universally the source object (in otherwords, a
* method function where the first argument is always a reference to
* self).
*
* In case you didn't know, JNI's jvalue us a rather complex union
* which holds any of the possible things you can send across the
* boundary. So we allocate an array of them, then for each parameter
* passed to the marshaller, whack them in.
*/
jargs = g_newa(jvalue, n_param_values + 1);
jargs[0].l = bjc->handler;
for(i = 0; i < n_param_values; i++) {
type = G_VALUE_TYPE(¶m_values[i]);
switch(G_TYPE_FUNDAMENTAL(type)) {
case G_TYPE_CHAR:
jargs[i+1].c = g_value_get_char(¶m_values[i]);
break;
case G_TYPE_UCHAR:
jargs[i+1].c = g_value_get_uchar(¶m_values[i]);
break;
case G_TYPE_BOOLEAN:
b = g_value_get_boolean(¶m_values[i]);
jargs[i+1].z = (b == TRUE) ? JNI_TRUE : JNI_FALSE;
break;
case G_TYPE_INT:
jargs[i+1].i = g_value_get_int(¶m_values[i]);
break;
case G_TYPE_UINT:
jargs[i+1].i = g_value_get_uint(¶m_values[i]);
break;
case G_TYPE_ENUM:
jargs[i+1].i = g_value_get_enum(¶m_values[i]);
break;
case G_TYPE_FLAGS:
jargs[i+1].i = g_value_get_flags(¶m_values[i]);
break;
case G_TYPE_LONG:
jargs[i+1].j = g_value_get_long(¶m_values[i]);
break;
case G_TYPE_ULONG:
jargs[i+1].j = g_value_get_ulong(¶m_values[i]);
break;
case G_TYPE_FLOAT:
jargs[i+1].f = g_value_get_float(¶m_values[i]);
break;
case G_TYPE_DOUBLE:
jargs[i+1].d = g_value_get_double(¶m_values[i]);
break;
case G_TYPE_STRING:
jargs[i+1].l = bindings_java_newString(env, g_value_get_string(¶m_values[i]));
break;
case G_TYPE_OBJECT:
case G_TYPE_INTERFACE:
/*
* GObjects are just pointers, and so we pass up the
* address across the boundary to be looked up and
* either an existing Proxy returned or a new Proxy
* created.
*/
obj = g_value_get_object(¶m_values[i]);
bindings_java_memory_cleanup(obj, FALSE);
jargs[i+1].j = (jlong) obj;
break;
case G_TYPE_BOXED:
/*
* We make a copy of the GBoxed so that we own it and
* thus it can (will) survive the duration of the
* signal in the event that the developer using this
* code keeps a reference to the returned Boxed.
*/
jargs[i+1].j = (jlong) g_boxed_copy(type, g_value_get_boxed(¶m_values[i]));
break;
case G_TYPE_PARAM:
/*
* We're ignoring GParamSpec at the moment. They
* normally only show up in 'notify' signals, and we
* don't need them.
*/
case G_TYPE_POINTER:
/*
* and, we're ignoring something that gets registered
* as a gpointer, by definition it has no type
* information and there's nothing we can do.
*/
jargs[i+1].j = (jlong) NULL;
break;
default:
/*
* Unrecognized. Probably means we need to add a clause above.
*/
g_printerr("Don't know how to marshal a %s", g_type_name(type));
jargs[i+1].l = 0;
break;
}
}
/*
* And now we invoke the callback on the Java side Signal handler; we have to
* select the correct function based on what return type is necessary.
*/
switch(bjc->returnType) {
case 'V':
/*
* void return signals
*/
(*env)->CallStaticVoidMethodA(env, bjc->receiver, bjc->method, jargs);
break;
case 'Z':
/*
* boolean return signals
*/
_b = (*env)->CallStaticBooleanMethodA(env, bjc->receiver, bjc->method, jargs);
if (_b == JNI_TRUE) {
b = TRUE;
} else if (_b == JNI_FALSE) {
b = FALSE;
} else {
g_critical("How did you manage to return a boolean that's neither TRUE nor FALSE?");
return;
}
g_value_set_boolean(return_value, b);
break;
case 'I':
/*
* integer return signals
*/
_e = (*env)->CallStaticIntMethodA(env, bjc->receiver, bjc->method, jargs);
g_value_set_int(return_value, _e);
break;
case 'E':
/*
* enum return signals
*/
_e = (*env)->CallStaticIntMethodA(env, bjc->receiver, bjc->method, jargs);
g_value_set_enum(return_value, _e);
break;
case 'L':
/*
* String return signals
*
* L is actually Object, of course, but the only type we need to
* worry about is java.lang.String encode it for now, and so make the
* enormous assumption that a string is what we get back.
*/
_str = (*env)->CallStaticObjectMethodA(env, bjc->receiver, bjc->method, jargs);
if (_str == NULL) {
g_warning("Invoking string handler returned null. That's probably bad");
break;
}
str = (gchar*) bindings_java_getString(env, _str);
if (str == NULL) {
/* OutOfMemoryError already thrown */
return;
}
// according to the API docs, this copies the input...
g_value_set_string(return_value, str);
// ... so we can release str
bindings_java_releaseString(str);
break;
default:
/*
* If it's not void, boolean or gchar*, then what kind of signal is it?
*/
g_critical("Invocation for return type %c not implemented", bjc->returnType);
break;
}
/*
* Cleanup
*/
for(i = 0; i < n_param_values; i++) {
type = G_VALUE_TYPE(¶m_values[i]);
switch(G_TYPE_FUNDAMENTAL(type)) {
case G_TYPE_STRING:
(*env)->DeleteLocalRef(env, jargs[i+1].l);
break;
default:
break;
}
}
/*
* Don't need to free jargs - we alloca()'d it
*/
/*
* Now, check if an exception occurred in the callback. There's a
* catch: because we're in native code right now [care of the call to
* gtk_main()] the exception gets swallowed until we return from that
* native call. So we call the function which causes the main loop to
* terminate, with the result that the exception will propegate out
* and, yes, probably halt the program.
*
* This is abrupt, but it is deliberate: we need to force developers
* to deal with criticals emitted by the underlying libraries.
* Otherwise, the next thing that is likely to happen is a
* segmentation fault, and not only does that crash the "program" but
* it takes out the Java Virtual Machine running it. People don't
* like VM crashes.
*
* Uncaught exceptions of any kind leaving a signal handler are to be
* considered programmer error and will be fatal.
*/
if ((*env)->ExceptionOccurred(env)) {
gtk_main_quit();
}
}
