PatchSet 6600
Date: 2005/05/30 08:54:18
Author: doogie
Branch: HEAD
Tag: (none)
Log:
Fix all -Wswitch-enum warnings.
Members:
ChangeLog:1.4125->1.4126
kaffe/kaffevm/classPool.c:INITIAL->1.35
kaffe/kaffevm/findInJar.c:1.67->1.68
libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c:1.8->1.9
libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkScrollBarPeer.c:1.5->1.6
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.4125 kaffe/ChangeLog:1.4126
--- kaffe/ChangeLog:1.4125 Mon May 30 08:53:46 2005
+++ kaffe/ChangeLog Mon May 30 08:54:18 2005
@@ -1,5 +1,12 @@
2005-05-30 Adam Heath <[EMAIL PROTECTED]>
+ * kaffe/kaffevm/classPool.c, kaffe/kaffevm/findInJar.c,
+
libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c,
+
libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkScrollBarPeer.c:
+ Fix all -Wswitch-enum warnings.
+
+2005-05-30 Adam Heath <[EMAIL PROTECTED]>
+
* include/gccbuiltin.h:
Fix GCC_VERSION undefined warning.
===================================================================
Checking out kaffe/kaffe/kaffevm/classPool.c
RCS: /home/cvs/kaffe/kaffe/kaffe/kaffevm/classPool.c,v
VERS: 1.35
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/kaffe/kaffevm/classPool.c Mon May 30 09:05:19 2005
@@ -0,0 +1,652 @@
+/*
+ * classPool.c
+ * Methods dealing with the class entry pool
+ *
+ * Copyright (c) 1996, 1997
+ * Transvirtual Technologies, Inc. All rights reserved.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file.
+ */
+
+#include "config.h"
+#include "debug.h"
+#include "config-std.h"
+#include "config-mem.h"
+#include "errors.h"
+#include "external.h"
+#include "itypes.h"
+#include "access.h"
+#include "file.h"
+#include "thread.h"
+#include "jthread.h"
+#include "classMethod.h"
+#include "md.h"
+#include "support.h"
+#include "stringSupport.h"
+#include "stats.h"
+#include "gc.h"
+#include "locks.h"
+#include "md.h"
+
+#define CLASSHASHSZ 256 /* Must be a power of two */
+static iStaticLock classHashLock;
+static classEntry* classEntryPool[CLASSHASHSZ];
+#if defined(KAFFE_STATS)
+statobject classStats;
+void statClassPool(void);
+#endif
+
+/*
+ * Lookup an entry for a given (name, loader) pair.
+ * Return null if none is found.
+ */
+classEntry*
+lookupClassEntryInternal(Utf8Const* name, Hjava_lang_ClassLoader* loader)
+{
+ classEntry* entry;
+
+ entry = classEntryPool[utf8ConstHashValue(name) & (CLASSHASHSZ-1)];
+ for (; entry != 0; entry = entry->next) {
+ if (utf8ConstEqual(name, entry->name) && loader ==
entry->loader) {
+ return (entry);
+ }
+ }
+ return (NULL);
+}
+
+/*
+ * Lookup an entry for a given (name, loader) pair.
+ * Create one if none is found.
+ */
+classEntry*
+lookupClassEntry(Utf8Const* name, Hjava_lang_ClassLoader* loader,
+ errorInfo *einfo)
+{
+ classEntry* entry;
+ classEntry** entryp;
+ static int f = 0;
+
+ if (f == 0) {
+ f++;
+ registerUserCounter(&classStats, "class-pool", statClassPool);
+ }
+
+ entry = lookupClassEntryInternal(name, loader);
+ if (entry != 0)
+ return (entry);
+
+ /* Failed to find class entry - create a new one */
+ entry = gc_malloc(sizeof(classEntry), KGC_ALLOC_CLASSPOOL);
+ if (entry == 0) {
+ postOutOfMemory(einfo);
+ return (NULL);
+ }
+ entry->name = name;
+ entry->loader = loader;
+ entry->data.cl = NULL;
+ entry->next = NULL;
+ initStaticLock(&entry->slock);
+
+ /* Lock the class table and insert entry into it (if not already
+ there) */
+ lockStaticMutex(&classHashLock);
+
+ entryp = &classEntryPool[utf8ConstHashValue(name) & (CLASSHASHSZ-1)];
+ for (; *entryp != 0; entryp = &(*entryp)->next) {
+ if (utf8ConstEqual(name, (*entryp)->name) && loader ==
(*entryp)->loader) {
+ /* Someone else added it - discard ours and return
+ the new one. */
+ unlockStaticMutex(&classHashLock);
+ KFREE(entry);
+ return (*entryp);
+ }
+ }
+
+ /* Add ours to end of hash */
+ *entryp = entry;
+ addToCounter(&cpemem, "vmmem-class entry pool", 1, GCSIZEOF(entry));
+
+ /*
+ * This reference to the utf8 name will be released if and when this
+ * class entry is freed in destroyClassLoader.
+ */
+ utf8ConstAddRef(entry->name);
+
+ unlockStaticMutex(&classHashLock);
+
+ return (entry);
+}
+
+#if 0
+#if defined(TRANSLATOR) && !defined(JIT3)
+/*
+ * Find method containing pc.
+ * This is the old version that linearly scans the class entry pool.
+ *
+ * It is only used in JIT2. JIT3 uses a faster implementation
+ * in methodCache.c. JIT2 could use that implementation too if calls
+ * to makeMethodActive are added.
+ *
+ * For now, let's leave this code here. It could be used a potential
+ * fallback for gc systems that would not support gcGetObjectBase().
+ *
+ * Note that the only reason this code is in this file is that
+ * the classEntryPool is a private structure --- what we'd really need
+ * here is an "map" function over the elements in the class entry pool.
+ */
+Method*
+findMethodFromPC(uintp pc)
+{
+ classEntry* entry;
+ Method* ptr;
+ int ipool;
+ int imeth;
+
+ for (ipool = CLASSHASHSZ; --ipool >= 0; ) {
+ for (entry = classEntryPool[ipool]; entry != NULL; entry =
entry->next) {
+ if (entry->data.cl != 0) {
+ imeth = CLASS_NMETHODS(entry->data.cl);
+ ptr = CLASS_METHODS(entry->data.cl);
+ for (; --imeth >= 0; ptr++) {
+ uintp ncode;
+ if (!METHOD_TRANSLATED(ptr)) {
+ continue;
+ }
+ ncode = (uintp)METHOD_NATIVECODE(ptr);
+ if (pc >= ncode && pc <
(uintp)ptr->c.ncode.ncode_end) {
+ return (ptr);
+ }
+ }
+ }
+ }
+ }
+ return (NULL);
+}
+#endif
+#endif
+
+void
+walkClassEntries(Collector *collector, void *gc_info, Hjava_lang_ClassLoader*
loader)
+{
+ classEntry* entry;
+ int ipool;
+
+ for (ipool = CLASSHASHSZ; --ipool >= 0; ) {
+ for (entry = classEntryPool[ipool]; entry != NULL;
+ entry = entry->next)
+ {
+ if (entry->loader == loader && entry->state >=
NMS_LOADING) {
+ KGC_markObject(collector, gc_info,
entry->data.cl);
+ }
+ }
+ }
+}
+
+/*
+ * Remove all entries from the class entry pool that belong to a given
+ * class. Return the number of entries removed.
+ */
+int
+removeClassEntries(Hjava_lang_ClassLoader* loader)
+{
+ classEntry** entryp;
+ classEntry* entry;
+ int ipool;
+ int totalent = 0;
+
+ lockStaticMutex(&classHashLock);
+ for (ipool = CLASSHASHSZ; --ipool >= 0; ) {
+ entryp = &classEntryPool[ipool];
+ while (*entryp != NULL) {
+ /* loop invariant: entryp points at the next non-null
+ * entry that must be examined.
+ */
+ entry = *entryp;
+ if (entry->loader == loader) {
+ /*
+ * If class gc is turned off, no classloader
+ * should ever be finalized because they're all
+ * kept alive by their respective classes.
+ */
+ assert(entry->data.cl == 0 ||
+ Kaffe_JavaVMArgs.enableClassGC != 0);
+DBG(CLASSGC,
+ dprintf("removing %s l=%p/c=%p\n",
+ entry->name->data, loader, entry->data.cl);
+ );
+ /* release reference to name */
+ utf8ConstRelease(entry->name);
+ (*entryp) = entry->next;
+ addToCounter(&cpemem, "vmmem-class entry pool",
+ 1, -(jlong)GCSIZEOF(entry));
+ destroyStaticLock(&entry->slock);
+ gc_free(entry);
+ totalent++;
+ } else {
+ entryp = &(*entryp)->next;
+ }
+ }
+ }
+ unlockStaticMutex(&classHashLock);
+ return (totalent);
+}
+
+/*
+ * Finalize a classloader and remove its entries in the class entry pool.
+ */
+void
+/* ARGSUSED */
+destroyClassLoader(Collector *c UNUSED, void* _loader)
+{
+ Hjava_lang_ClassLoader* loader = _loader;
+ int rmoved;
+
+ rmoved = removeClassEntries(loader);
+ unloadNativeLibraries(loader);
+
+ if (Kaffe_JavaVMArgs.enableVerboseGC > 0) {
+ dprintf("<GC: destroying classloader "
+ "@%p (%d entries removed)>\n", loader, rmoved);
+ }
+}
+
+static nameDependency *dependencies;
+static iStaticLock mappingLock;
+
+static
+nameDependency *findNameDependency(jthread_t jt)
+{
+ nameDependency *curr, *retval = NULL;
+
+ for( curr = dependencies; curr && !retval; curr = curr->next )
+ {
+ if( curr->thread == jt )
+ {
+ retval = curr;
+ }
+ }
+ return( retval );
+}
+
+static
+int addNameDependency(nameDependency *nd)
+{
+ int retval = 1;
+
+ assert(nd != 0);
+
+ lockStaticMutex(&mappingLock);
+ {
+ nameDependency *curr;
+
+ nd->next = dependencies;
+ dependencies = nd;
+
+ for( curr = findNameDependency(nd->mapping->data.thread);
+ curr && retval;
+ curr = findNameDependency(curr->mapping->data.thread) )
+ {
+ if( curr->mapping->data.thread == nd->thread )
+ {
+ retval = 0;
+ }
+ }
+ }
+ unlockStaticMutex(&mappingLock);
+ return( retval );
+}
+
+static
+void remNameDependency(classEntry *ce)
+{
+
+ assert(ce != 0);
+
+ lockStaticMutex(&mappingLock);
+ {
+ nameDependency **last, *curr;
+
+ last = &dependencies;
+ curr = dependencies;
+ while( curr && (curr->mapping != ce) )
+ {
+ last = &curr->next;
+ curr = curr->next;
+ }
+ if( curr )
+ {
+ *last = curr->next;
+ }
+ }
+ unlockStaticMutex(&mappingLock);
+}
+
+int classMappingSearch(classEntry *ce,
+ Hjava_lang_Class **out_cl,
+ errorInfo *einfo)
+{
+ int done = 0, retval = 1;
+ nameDependency nd;
+ jthread_t jt;
+
+ jt = KTHREAD(current)();
+ while( !done )
+ {
+ lockStaticMutex(&ce->slock);
+ switch( ce->state )
+ {
+ case NMS_EMPTY:
+ /* This thread's responsibility. */
+ ce->state = NMS_SEARCHING;
+ ce->data.thread = jt;
+ done = 1;
+ break;
+ case NMS_SEARCHING:
+ if( ce->data.thread == jt )
+ {
+ done = 1;
+ break;
+ }
+ waitStaticCond(&ce->slock, (jlong)0);
+ break;
+ case NMS_LOADING:
+ /*
+ * Another thread is loading it, make sure there is not
+ * a cycle.
+ */
+ nd.thread = jt;
+ nd.mapping = ce;
+ if( (ce->data.thread == jt) ||
+ !addNameDependency(&nd) )
+ {
+ /* Circularity. */
+ done = 1;
+ retval = 0;
+ postExceptionMessage(
+ einfo,
+ JAVA_LANG(ClassCircularityError),
+ "%s",
+ ce->name->data);
+ }
+ else
+ {
+ waitStaticCond(&ce->slock, (jlong)0);
+ }
+ remNameDependency(ce);
+ break;
+ case NMS_LOADED:
+ /*
+ * Another thread loaded it, however, its not finished
+ * linking yet.
+ */
+ waitStaticCond(&ce->slock, (jlong)0);
+ break;
+ case NMS_DONE:
+ /* Its already been loaded and linked. */
+ *out_cl = ce->data.cl;
+ done = 1;
+ break;
+ }
+ unlockStaticMutex(&ce->slock);
+ }
+ return( retval );
+}
+
+int classMappingLoad(classEntry *ce,
+ Hjava_lang_Class **out_cl,
+ errorInfo *einfo)
+{
+ int done = 0, retval = 1;
+ nameDependency nd;
+ jthread_t jt;
+
+ *out_cl = NULL;
+ jt = KTHREAD(current)();
+ while( !done )
+ {
+ lockStaticMutex(&ce->slock);
+ switch( ce->state )
+ {
+ case NMS_EMPTY:
+ case NMS_SEARCHING:
+ /* This thread's responsibility. */
+ ce->state = NMS_LOADING;
+ ce->data.thread = jt;
+ done = 1;
+ break;
+ case NMS_LOADING:
+ /*
+ * Another thread is loading it, make sure there is not
+ * a cycle.
+ */
+ nd.thread = jt;
+ nd.mapping = ce;
+ if( (ce->data.thread == jt) ||
+ !addNameDependency(&nd) )
+ {
+ /* Circularity. */
+ done = 1;
+ retval = 0;
+ postExceptionMessage(
+ einfo,
+ JAVA_LANG(ClassCircularityError),
+ "%s",
+ ce->name->data);
+ }
+ else
+ {
+ waitStaticCond(&ce->slock, (jlong)0);
+ }
+ remNameDependency(ce);
+ break;
+ case NMS_LOADED:
+ /*
+ * Another thread loaded it, however, its not finished
+ * linking yet.
+ */
+ waitStaticCond(&ce->slock, (jlong)0);
+ break;
+ case NMS_DONE:
+ /* Its already been loaded and linked. */
+ *out_cl = ce->data.cl;
+ done = 1;
+ break;
+ }
+ unlockStaticMutex(&ce->slock);
+ }
+ return( retval );
+}
+
+Hjava_lang_Class *classMappingLoaded(classEntry *ce, Hjava_lang_Class *cl)
+{
+ Hjava_lang_Class *retval = NULL;
+
+ assert(ce != 0);
+ assert(cl != 0);
+
+ lockStaticMutex(&ce->slock);
+ {
+ switch( ce->state )
+ {
+ case NMS_LOADING:
+ /* FALLTHROUGH */
+ case NMS_SEARCHING:
+ if( cl->state < CSTATE_PREPARED )
+ {
+ ce->state = NMS_LOADED;
+ }
+ else
+ {
+ ce->state = NMS_DONE;
+ }
+ ce->data.cl = cl;
+ retval = cl;
+ break;
+ case NMS_EMPTY:
+ case NMS_LOADED:
+ case NMS_DONE:
+ default:
+ /* Ignore. */
+ retval = ce->data.cl;
+ break;
+ }
+ broadcastStaticCond(&ce->slock);
+ }
+ unlockStaticMutex(&ce->slock);
+
+ return( retval );
+}
+
+void setClassMappingState(classEntry *ce, name_mapping_state_t nms)
+{
+
+ assert(ce != 0);
+
+ lockStaticMutex(&ce->slock);
+ {
+ switch( ce->state )
+ {
+ case NMS_SEARCHING:
+ ce->state = nms;
+ break;
+ case NMS_LOADING:
+ /* FALLTHROUGH */
+ case NMS_LOADED:
+ ce->state = nms;
+ break;
+ case NMS_DONE:
+ break;
+ case NMS_EMPTY:
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ broadcastStaticCond(&ce->slock);
+ }
+ unlockStaticMutex(&ce->slock);
+}
+
+void KaffeVM_initClassPool()
+{
+ initStaticLock(&classHashLock);
+ initStaticLock(&mappingLock);
+}
+
+#if defined(KAFFE_STATS) || defined(KAFFE_PROFILER) || defined(KAFFE_VMDEBUG)
+/**
+ * Walk the class pool and invoke walker() for each classes
+ */
+void
+walkClassPool(int (*walker)(Hjava_lang_Class *clazz, void *), void *param)
+{
+ int ipool;
+ classEntry* entry;
+
+ assert(walker != NULL);
+
+ for (ipool = CLASSHASHSZ; --ipool >= 0; ) {
+ entry = classEntryPool[ipool];
+ for (; entry != NULL; entry = entry->next) {
+ if (entry->data.cl
+ && entry->loader == entry->data.cl->loader) {
+ walker(entry->data.cl, param);
+ }
+ }
+ }
+}
+#endif
+
+
+#if defined(KAFFE_STATS)
+static void
+statClass(Hjava_lang_Class *clazz, int *total)
+{
+ Collector *c = main_collector;
+ int misc = 0;
+ int miscfixed = 0;
+ int bytecodemem = 0, jitmem = 0;
+
+#define SIZE_IFNONZERO(x) ((x) ? KGC_getObjectSize(c, (x)) : 0)
+
+ /* compute sizes of miscellaneous data */
+ /* we tally up the memory for KMALLOC'ed objects (they'll appear
+ * under "other-fixed".) and the memory for other misc objects
+ */
+ misc += SIZE_IFNONZERO(clazz); /* myself */
+ if (!CLASS_IS_PRIMITIVE(clazz)) {
+ /* For primitives, vtable is -1 and methods is the
+ * class of the corresponding array
+ */
+ misc += SIZE_IFNONZERO(clazz->vtable);
+ misc += SIZE_IFNONZERO(CLASS_CONSTANTS(clazz)->data);
+ misc += SIZE_IFNONZERO(CLASS_FIELDS(clazz));
+ misc += SIZE_IFNONZERO(CLASS_STATICDATA(clazz));
+
+ miscfixed += SIZE_IFNONZERO(clazz->if2itable);
+ miscfixed += SIZE_IFNONZERO(clazz->itable2dtable);
+ miscfixed += SIZE_IFNONZERO(clazz->gc_layout);
+ miscfixed += SIZE_IFNONZERO(clazz->sourcefile);
+ miscfixed += SIZE_IFNONZERO(clazz->implementors);
+ miscfixed += SIZE_IFNONZERO(clazz->inner_classes);
+ }
+ if (!CLASS_IS_ARRAY(clazz) && !CLASS_IS_PRIMITIVE(clazz)) {
+ misc += SIZE_IFNONZERO(clazz->interfaces);
+ }
+
+ /* methods only if we have some */
+ if (!CLASS_IS_PRIMITIVE(clazz) && !CLASS_IS_ARRAY(clazz)
+ && CLASS_METHODS(clazz) != 0)
+ {
+ Method *m = CLASS_METHODS(clazz);
+ int i, n = CLASS_NMETHODS(clazz);
+ misc += SIZE_IFNONZERO(CLASS_METHODS(clazz));
+ for (i = 0; i < n; m++, i++) {
+ miscfixed += SIZE_IFNONZERO(m->parsed_sig);
+ miscfixed += SIZE_IFNONZERO(m->lines);
+ miscfixed += SIZE_IFNONZERO(m->declared_exceptions);
+ misc += SIZE_IFNONZERO(m->exception_table);
+ /* bytecode or jitted code */
+ if ((m->accflags & ACC_NATIVE) == 0) {
+ if (METHOD_TRANSLATED(m)) {
+ jitmem +=
SIZE_IFNONZERO(m->c.ncode.ncode_start);
+ } else {
+ bytecodemem +=
SIZE_IFNONZERO(m->c.bcode.code);
+ }
+ }
+ }
+ }
+
+ dprintf("%7d %7d %7d %7d %s\n",
+ misc,
+ miscfixed,
+ jitmem,
+ bytecodemem,
+ CLASS_CNAME(clazz));
+
+ total[0] += misc;
+ total[1] += miscfixed;
+ total[2] += jitmem;
+ total[3] += bytecodemem;
+}
+
+void
+statClassPool(void)
+{
+ int total[20];
+
+ memset(total, 0, sizeof total);
+ dprintf("#DUMPING CLASSPOOL MEMORY\n");
+ dprintf("%-7s %-7s %-7s %-7s %-7s\n",
+ "#MISC", "MISCFIX", "JCODE", "BCODE", "CLASS");
+ dprintf("%-7s %-7s %-7s %-7s %-7s\n",
+ "#------", "-------", "-------", "-------", "--------------\n");
+ walkClassPool(statClass, total);
+ dprintf("%7.2f %7.2f %7.2f %7.2f KBytes\n",
+ total[0]/1024.0, total[1]/1024.0, total[2]/1024.0,
+ total[3]/1024.0);
+ fflush(stderr);
+}
+#endif
+
Index: kaffe/kaffe/kaffevm/findInJar.c
diff -u kaffe/kaffe/kaffevm/findInJar.c:1.67
kaffe/kaffe/kaffevm/findInJar.c:1.68
--- kaffe/kaffe/kaffevm/findInJar.c:1.67 Fri May 6 15:24:27 2005
+++ kaffe/kaffe/kaffevm/findInJar.c Mon May 30 08:54:26 2005
@@ -155,6 +155,9 @@
}
return (class);
+ case CP_INVALID:
+ case CP_SOFILE:
+ case CP_BYTEARRAY:
default:
break;
}
Index:
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c
diff -u
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c:1.8
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c:1.9
---
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c:1.8
Wed Feb 23 21:58:53 2005
+++
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkEvents.c
Mon May 30 08:54:27 2005
@@ -1096,6 +1096,32 @@
else
return FALSE;
break;
+ case GDK_NOTHING:
+ case GDK_DELETE:
+ case GDK_DESTROY:
+ case GDK_2BUTTON_PRESS:
+ case GDK_3BUTTON_PRESS:
+ case GDK_MAP:
+ case GDK_UNMAP:
+ case GDK_PROPERTY_NOTIFY:
+ case GDK_SELECTION_CLEAR:
+ case GDK_SELECTION_REQUEST:
+ case GDK_SELECTION_NOTIFY:
+ case GDK_PROXIMITY_IN:
+ case GDK_PROXIMITY_OUT:
+ case GDK_DRAG_ENTER:
+ case GDK_DRAG_LEAVE:
+ case GDK_DRAG_MOTION:
+ case GDK_DRAG_STATUS:
+ case GDK_DROP_START:
+ case GDK_DROP_FINISHED:
+ case GDK_CLIENT_EVENT:
+ case GDK_VISIBILITY_NOTIFY:
+ case GDK_NO_EXPOSE:
+ case GDK_SCROLL:
+ case GDK_WINDOW_STATE:
+ case GDK_SETTING:
+ case GDK_OWNER_CHANGE:
default:
break;
}
Index:
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkScrollBarPeer.c
diff -u
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkScrollBarPeer.c:1.5
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkScrollBarPeer.c:1.6
---
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkScrollBarPeer.c:1.5
Thu May 26 12:36:12 2005
+++
kaffe/libraries/clib/awt/classpath-gtk/gtk-peer/gnu_java_awt_peer_gtk_GtkScrollBarPeer.c
Mon May 30 08:54:27 2005
@@ -203,6 +203,18 @@
AWT_ADJUSTMENT_BLOCK_INCREMENT,
(jint) value);
break;
+ case GTK_SCROLL_NONE:
+ case GTK_SCROLL_JUMP:
+ case GTK_SCROLL_STEP_UP:
+ case GTK_SCROLL_STEP_DOWN:
+ case GTK_SCROLL_PAGE_UP:
+ case GTK_SCROLL_PAGE_DOWN:
+ case GTK_SCROLL_STEP_LEFT:
+ case GTK_SCROLL_STEP_RIGHT:
+ case GTK_SCROLL_PAGE_LEFT:
+ case GTK_SCROLL_PAGE_RIGHT:
+ case GTK_SCROLL_START:
+ case GTK_SCROLL_END:
default:
/* GTK_SCROLL_JUMP: */
(*gdk_env())->CallVoidMethod (gdk_env(), obj, postAdjustmentEventID,
_______________________________________________
kaffe mailing list
[email protected]
http://kaffe.org/cgi-bin/mailman/listinfo/kaffe
