#
# Properties file specifying the GTK conversions for JNI, including both
# general patterns and special cases.
#
# The properties are of the form "<schemeType>.<spec>: <conversion>". For
# specs that refer to types, then the conversion is taken literally. For specs
# that refer to wrapping or unwrapping of values, the conversion must be
# statements to convert a variable named $FROM into a variable named $TO,
# including the declaration of the variable itself.
#
# The specs are as follows:
#   javaType: the public Java type name
#   javaUnwrap: how to unwrap a public Java type into a native Java type
#   javaWrap: how to wrap a native Java type into a return of a public 
#       Java type
#   javaNative: the Java type corresponding to a native method's argument
#       or return type
#   nativeType: the native type for an argument or return value
#   nativeUnwrap: how to unwrap a native type into a raw GLib/GTK type
#   nativeWrap: how to wrap a raw GLib/GTK type into a return of a native
#       Java type
#   rawType: the raw GLib/GTK type to be passed as an argument or accepted
#       as a return value
#
# For specs that refer to types, then the conversion is simply a literal
# value. For the unwrappers, two variables are used; $FROM is the variable
# name to convert from, and $TO is the variable name to convert to. For
# wrappers, one variable is used; $CALL is the function/method call which
# needs to be wrapped. For native wrappers, an additional variable is used;
# $CLEANUP contains statements to insert after the call and before the
# return.
#
# If no Java-level wrapping or unwrapping is necessary, then it is okay to
# omit definitions for javaWrap, javaUnwrap, and javaNative. If only one of
# wrapping or unwrapping is needed at the Java level, then it is okay to
# omit the unneeded definition. However, one must always specify native-level
# wrapping and unwrapping.
#
# Within a native unwrapping section, since C doesn't allow one to mix
# variable declarations with statements, if you need to use a
# non-declaration statement, then it may be placed in a second "section,"
# separated from the first by a single "-" on a line by itself.
# Additionally, if there is any necessary cleanup, this may be placed in a
# third section after the statements.
#
# There are five special sets of properties, named $BOXED, $ENUM, $FLAG,
# $STRING_ENUM, and $OBJECT used to define the patterns for boxed types,
# enumerated types, flag types, and GTK/Gnome objectsrespectively. In the
# context of these properties, there are three additional variables
# available: $JAVA_TYPE refers to the fully qualified Java type (class)
# name corresponding to the GTK name, $JAVA_PATH refers to the Java path
# string for the class (the fully-qualified name but with slashes instead
# of dots), and $GLIB_TYPE refers to the original GLib/GTK type name.
#
# One final special case is that if a type simply has the definition
# "<scheme-name>.alias: <scheme-name>" then the first name is treated as
# an alias for the second.
#
# The Java-Gnome bindings library is free software distributed under the
# terms of the GNU Library General Public License version 2.
#
# Author: Dan Bornstein, danfuzz@milk.com
# based on translation forms originally by Olivier Gutknecht, gutkneco@lirmm.fr
# Copyright 2000 Dan Bornstein, all rights reserved.
#

# these are the generic patterns

$ENUM.javaType:     $JAVA_TYPE
$ENUM.javaUnwrap:   int $TO = $FROM.getValue ();
$ENUM.javaWrap:     return $JAVA_TYPE.intern ($CALL);
$ENUM.javaNative:   int
$ENUM.nativeType:   jint
$ENUM.nativeUnwrap: $GLIB_TYPE $TO = ($GLIB_TYPE) $FROM;
$ENUM.nativeWrap:                   \
    jint result_j = (jint) ($CALL); \
    $CLEANUP                        \
    return result_j;
$ENUM.rawType:      $GLIB_TYPE


$ENUM*.javaType:     $JAVA_TYPE
$ENUM*.javaNative:   int []
$ENUM*.nativeType:   jintArray
$ENUM*.nativeUnwrap: \
    gint *$TO_g = (gint *) (*env)->GetIntArrayElements (env, $FROM, NULL);\
    $GLIB_TYPE *$TO = ($GLIB_TYPE *)$TO_g;                               \
    \n-\n                                                                \
    \n-\n                                                                \
    (*env)->ReleaseIntArrayElements (env, $FROM, (jint*)$TO_g, 0);
$ENUM*.nativeWrap:   return (jint)$CALL;
$ENUM*.rawType:      $GLIB_TYPE *


$FLAG.javaType:     $JAVA_TYPE
$FLAG.javaUnwrap:   int $TO = $FROM.getValue ();
$FLAG.javaWrap:     return $JAVA_TYPE.intern ($CALL);
$FLAG.javaNative:   int
$FLAG.nativeType:   jint
$FLAG.nativeUnwrap: $GLIB_TYPE $TO = ($GLIB_TYPE) $FROM;
$FLAG.nativeWrap:                   \
    jint result_j = (jint) ($CALL); \
    $CLEANUP                        \
    return result_j;
$FLAG.rawType:      $GLIB_TYPE


$STRING_ENUM.javaType: $JAVA_TYPE


$OBJECT.javaType:     $JAVA_TYPE
$OBJECT.javaNative:   int
$OBJECT.nativeType:   jint
$OBJECT.nativeUnwrap: $GLIB_TYPE *$TO = ($GLIB_TYPE *)$FROM;
$OBJECT.nativeWrap:   return (jint)$CALL;
$OBJECT.rawType:      $GLIB_TYPE *


$OBJECT*.javaType:     $JAVA_TYPE
$OBJECT*.javaNative:   int []
$OBJECT*.nativeType:   jintArray
$OBJECT*.nativeUnwrap: \
    gint *$TO_g = (gint *) (*env)->GetIntArrayElements (env, $FROM, NULL);\
    $GLIB_TYPE *$TO = ($GLIB_TYPE *)$TO_g;                               \
    \n-\n                                                                \
    \n-\n                                                                \
    (*env)->ReleaseIntArrayElements (env, $FROM, (jint*)$TO_g, 0);
$OBJECT*.nativeWrap:   return (jint)$CALL;
$OBJECT*.rawType:      $GLIB_TYPE *


$BOXED.javaType:     $JAVA_TYPE
$BOXED.javaNative:   int
$BOXED.nativeType:   jint
$BOXED.nativeUnwrap: $GLIB_TYPE *$TO = ($GLIB_TYPE *)$FROM;
$BOXED.nativeWrap:   return (jint)$CALL;
$BOXED.rawType:      $GLIB_TYPE *


$BOXED*.javaType:     $JAVA_TYPE
$BOXED*.javaNative:   int []
$BOXED*.nativeType:   jintArray
$BOXED*.nativeUnwrap: \
    gint *$TO_g = (gint *) (*env)->GetIntArrayElements (env, $FROM, NULL);\
    $GLIB_TYPE *$TO = ($GLIB_TYPE *)$TO_g;                               \
    \n-\n                                                                \
    \n-\n                                                                \
    (*env)->ReleaseIntArrayElements (env, $FROM, (jint*)$TO_g, 0);
$BOXED*.nativeWrap:   return (jint)$CALL;
$BOXED*.rawType:      $GLIB_TYPE *


type.alias: GType


gpointer.javaType:     org.gnu.glib.Boxed
gpointer.javaNative:   int
gpointer.nativeType:   jint
gpointer.nativeUnwrap: gpointer *$TO = (gpointer *)$FROM;
gpointer.nativeWrap:   return (jint)$CALL;
gpointer.rawType:      gpointer


none.javaType:     void
none.javaWrap:     $CALL;
none.nativeType:   void
none.nativeWrap:   \
    $CALL;         \
    $CLEANUP
none.rawType:      void

bool.javaType:     boolean
bool.nativeType:   jboolean
bool.nativeUnwrap: gboolean $TO = (gboolean) $FROM;
bool.nativeWrap:                            \
    jboolean result_j = (jboolean) ($CALL); \
    $CLEANUP                                \
    return result_j;
bool.rawType:      gboolean

bool*.javaType:     boolean[]
bool*.nativeType:   jbooleanArray
bool*.nativeUnwrap: \
    gboolean *$TO = (gboolean *) (*env)->GetBooleanArrayElements(env, $FROM, NULL);\
    \n-\n \
    \n-\n \
    (*env)->ReleaseBooleanArrayElements(env, $FROM, (jboolean *)$TO, 0);
bool*.nativeWrap:                            \
    $CLEANUP          \
    return FIXME("need to figure out the right way to tell how long it is");
bool*.rawType:      gboolean *

char.javaType:     byte
char.nativeType:   jbyte
char.nativeUnwrap: gchar $TO = (gchar) $FROM;
char.nativeWrap:                      \
    jbyte result_j = (jbyte) ($CALL); \
    $CLEANUP                          \
    return result_j;
char.rawType:      gchar

uchar.javaType:     byte
uchar.nativeType:   jbyte
uchar.nativeUnwrap: guchar $TO = (guchar) $FROM;
uchar.nativeWrap:                     \
    jbyte result_j = (jbyte) ($CALL); \
    $CLEANUP                          \
    return result_j;
uchar.rawType:      guchar

short.javaType:     short
short.nativeType:   jshort
short.nativeUnwrap: gushort $TO = (gushort) $FROM;
short.nativeWrap:   return (jshort) ($CALL);
short.nativeWrap:                       \
    jshort result_j = (jshort) ($CALL); \
    $CLEANUP                            \
    return result_j;
short.rawType:      gshort

ushort.javaType:     short
ushort.nativeType:   jshort
ushort.nativeUnwrap: gushort $TO = (gushort) $FROM;
ushort.nativeWrap:                      \
    jshort result_j = (jshort) ($CALL); \
    $CLEANUP                            \
    return result_j;
ushort.rawType:      gushort

int.javaType:     int
int.nativeType:   jint
int.nativeUnwrap: gint32 $TO = (gint32) $FROM;
int.nativeWrap:                     \
    jint result_j = (jint) ($CALL); \
    $CLEANUP                        \
    return result_j;
int.rawType:      gint32

int*.javaType:     int []
int*.nativeType:   jintArray
int*.nativeUnwrap:                                                    \
    gint *$TO = (gint *) (*env)->GetIntArrayElements (env, $FROM, NULL); \
    \n-\n                                                                \
    \n-\n                                                                \
    (*env)->ReleaseIntArrayElements (env, $FROM, (jint *) $TO, 0);
int*.nativeWrap:   \
    $CLEANUP          \
    return FIXME("need to figure out the right way to tell how long it is");
int*.rawType:      gint *

uint.javaType:     int
uint.nativeType:   jint
uint.nativeUnwrap: guint32 $TO = (guint32) $FROM;
uint.nativeWrap:                    \
    jint result_j = (jint) ($CALL); \
    $CLEANUP                        \
    return result_j;
uint.rawType:      guint32

long.javaType:     long
long.nativeType:   jlong
long.nativeUnwrap: glong $TO = (glong) $FROM;
long.nativeWrap:                    \
    jlong result_j = (jlong) ($CALL); \
    $CLEANUP                        \
    return result_j;
long.rawType:      glong

ulong.javaType:     int
ulong.nativeType:   jint
ulong.nativeUnwrap: gulong $TO = (gulong) $FROM;
ulong.nativeWrap:                   \
    jint result_j = (jint) ($CALL); \
    $CLEANUP                        \
    return result_j;
ulong.rawType:      gulong

int64.javaType:     long
int64.nativeType:   jlong
int64.nativeUnwrap: gint64 $TO = (gint64) $FROM;
int64.nativeWrap:                     \
    jlong result_j = (jlong) ($CALL); \
    $CLEANUP                          \
    return result_j;
int64.rawType:      gint64

float.javaType:     double
float.nativeType:   jdouble
float.nativeUnwrap: gdouble $TO = (gdouble) $FROM;
float.nativeWrap:                       \
    jdouble result_j = (jdouble) ($CALL); \
    $CLEANUP                            \
    return result_j;
float.rawType:      gdouble

float*.javaType:     double []
float*.nativeType:   jdoubleArray
float*.nativeUnwrap:                                                    \
    gdouble *$TO = (gdouble *) (*env)->GetDoubleArrayElements (env, $FROM, NULL); \
    \n-\n                                                                \
    \n-\n                                                                \
    (*env)->ReleaseDoubleArrayElements (env, $FROM, (jdouble *) $TO, 0);
float*.nativeWrap:   \
    $CLEANUP          \
    return FIXME("need to figure out the right way to tell how long it is");
float*.rawType:      gdouble *


double.javaType:     double
double.nativeType:   jdouble
double.nativeUnwrap: gdouble $TO = (gdouble) $FROM;
double.nativeWrap:                        \
    jdouble result_j = (jdouble) ($CALL); \
    $CLEANUP                              \
    return result_j;
double.rawType:      gdouble

double*.javaType:     double []
double*.nativeType:   jdoubleArray
double*.nativeUnwrap:                                                    \
    gdouble *$TO = (gdouble *) (*env)->GetDoubleArrayElements (env, $FROM, NULL); \
    \n-\n                                                                \
    \n-\n                                                                \
    (*env)->ReleaseDoubleArrayElements (env, $FROM, (jdouble *) $TO, 0);
double*.nativeWrap:   \
    $CLEANUP          \
    return FIXME("need to figure out the right way to tell how long it is");
double*.rawType:      gdouble *

string.javaType:      byte[]
string.nativeType:   jbyteArray
string.nativeUnwrap:			                                     \
    jint $FROM_len = (*env)->GetArrayLength(env, $FROM);                     \
    gchar* $TO = (gchar*)g_malloc($FROM_len + 1);  \
    \n-\n                                                                    \
    (*env)->GetByteArrayRegion(env, $FROM, 0, $FROM_len, (jbyte*)$TO);      \
    $TO[$FROM_len] = 0;                                                      \
    \n-\n 
string.nativeWrap:                                                           \
    gchar *result_g = (gchar*)$CALL;                                         \
    jsize result_len = result_g ? strlen (result_g) : 0;                     \
    jbyteArray result_j = result_g ?                                         \
        (*env)->NewByteArray (env, result_len) : NULL;                       \
    if (result_g)                                                            \
        (*env)->SetByteArrayRegion (env, result_j, 0, result_len, result_g); \
    $CLEANUP                                                                 \
    return result_j;
string.rawType:      gchar *

string*.javaType:     String[]
string*.javaUnwrap:   org.gnu.glib.GStringArray $TO = new org.gnu.glib.GStringArray ($FROM);
string*.javaWrap:     return ($CALL).toJava ();
string*.javaNative:   org.gnu.glib.GStringArray
string*.nativeType:   jobject
string*.nativeUnwrap: gchar **$TO = (gchar**)peerOfGStringArray (env, $FROM);
string*.nativeWrap:   \
    $CLEANUP          \
    return makeGStringArray (env, ($CALL));
string*.rawType:      gchar **

static_string.alias:  string
static_string*.alias: string

# used for passing arrays to a char *argv[] argument. At the Java layer,
# the arguments passed to main don't have the program name, but we arrange
# it so that a user can pass the name as a Java property (gnome.appName);
# if that's not set, then we use "java-gnome" as the default
argvec.javaType:     String[]
argvec.javaUnwrap:   org.gnu.glib.GStringArray $TO = org.gnu.glib.GStringArray.makeArgv ($FROM);
argvec.javaWrap:     return ($CALL).toJavaArgs ();
argvec.javaNative:   org.gnu.glib.GStringArray
argvec.nativeType:   jobject
argvec.nativeUnwrap: gchar **$TO = (gchar**)peerOfGStringArray (env, $FROM);
argvec.nativeWrap:   \
    $CLEANUP         \
    return makeGStringArray (env, ($CALL));
argvec*.javaType:     String[]
argvec*.javaUnwrap:   org.gnu.glib.GStringArray $TO = org.gnu.glib.GStringArray.makeArgv ($FROM);
argvec*.javaWrap:     return ($CALL).toJavaArgs ();
argvec*.javaNative:   org.gnu.glib.GStringArray
argvec*.nativeType:   jobject
argvec*.nativeUnwrap: \
    gchar **$TO_arr = (gchar **)peerOfGStringArray (env, $FROM); \
    gchar ***$TO = &$TO_arr;
argvec*.nativeWrap:   \
    $CLEANUP          \
    return makeGStringArray (env, *($CALL));


# used for passing the length of an array of arguments. See discussion
# on argvec, above, for why this is used.
argcnt.javaType:     int
argcnt.nativeType:   jint
argcnt.nativeUnwrap: gint32 $TO = ((gint32) $FROM) + 1;
argcnt.nativeWrap:                  \
    jint result_j = (jint) ($CALL); \
    $CLEANUP                        \
    return result_j - 1;
argcnt.rawType:      gint32
argcnt*.javaType:     int
argcnt*.nativeType:   jint
argcnt*.nativeUnwrap: \
    gint32 $TO_int = ((gint32) $FROM) + 1; \
    gint32 *$TO = &$TO_int;
argcnt*.nativeWrap:                  \
    jint result_j = (jint) ($CALL); \
    $CLEANUP                        \
    return (*result_j) - 1;
argcnt*.rawType:      gint32 *

time_t.javaType:     java.util.Date
time_t.javaUnwrap:   long $TO = (long) ($FROM.getTime () / 1000);
time_t.javaWrap:     return new java.util.Date (($CALL) * 1000);
time_t.javaNative:   long
time_t.nativeType:   jlong
time_t.nativeUnwrap: time_t $TO = (time_t) $FROM;
time_t.nativeWrap:       \
    jlong result = $CALL; \
    $CLEANUP             \
    return result;
time_t.rawType:      time_t

GListString.javaType:     org.gnu.glib.GListString
GListString.nativeType:   jobject
GListString.nativeUnwrap: GList *$TO = (GList *)peerOfGListString (env, $FROM);
GListString.nativeWrap:   \
    $CLEANUP        \
    return makeGListString (env, ($CALL));
GListString.rawType:      GList *


GnomeUIInfo*.javaType:	org.gnu.gnome.GnomeUIInfo[]
GnomeUIInfo*.nativeType:	jobjectArray
GnomeUIInfo*.nativeUnwrap:	                                        \
    jsize $TO_len = $FROM ? (*env)->GetArrayLength(env,  $FROM) : 0;    \
    GnomeUIInfo *$TO = $FROM ? g_new(GnomeUIInfo, $TO_len) : NULL;      \
    GnomeUIInfo *m$FROM = $TO;                                          \
    GnomeUIInfo *s$FROM;                                                \
    int $TO_index;                                                      \
    jobject $FROM_elem;                                                 \
    \n-\n                                                               \
    if ($TO) {                                                          \
        for ($TO_index = 0; $TO_index < $TO_len; $TO_index++) {         \
            $FROM_elem = (*env)->GetObjectArrayElement(env,             \
							 $FROM,         \
							 $TO_index);    \
	    s$FROM = (GnomeUIInfo *)peerOfBaseObject(env, $FROM_elem);  \
	    memcpy(m$FROM, s$FROM, sizeof(GnomeUIInfo));                \
	    m$FROM++;                                                   \
        }                                                               \
    }
GnomeUIInfo*.rawType:      $GLIB_TYPE *

