callisto-debian/gtk3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

display the current cursor name.

Browse Source 
Tue Jul 14 06:25:46 1998  Tim Janik  <timj@gtk.org>

        * gtk/testgtk.c (create_cursors): display the current cursor name.

        * gtk/gtktypeutils.h:
        * gtk/gtktypeutils.c (gtk_type_init_builtin_types): cleanups to
        the fundamental type definition. the GtkArg union now only covers
        the required storage types for argument values. adapted the GTK_VALUE_*
        macro set. handle GTK_TYPE_UCHAR. definiton of type set bounds macros.

        * gtk/gtkargcollector.c (gtk_arg_collect_value): clean ups of the
        code, fixed int/float collection. fixed a bug in the sanity checking
        code for GtkObjects.

        * gtk/gtkbindings.c (gtk_binding_entry_add_signal): fixups of the
        argument collection code.

        * gtk/gtksignal.c (gtk_signal_collect_params): use the type set bounds
        macros when distinguishing the return type.
This commit is contained in:
Tim Janik
1998-07-14 07:40:15 +00:00
committed by Tim Janik
parent f38374c160
commit da355feec6
19 changed files with 477 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
ChangeLog
View File

@ -1,3 +1,23 @@
Tue Jul 14 06:25:46 1998 Tim Janik <timj@gtk.org>
* gtk/testgtk.c (create_cursors): display the current cursor name.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c (gtk_type_init_builtin_types): cleanups to
the fundamental type definition. the GtkArg union now only covers
the required storage types for argument values. adapted the GTK_VALUE_*
macro set. handle GTK_TYPE_UCHAR. definiton of type set bounds macros.
* gtk/gtkargcollector.c (gtk_arg_collect_value): clean ups of the
code, fixed int/float collection. fixed a bug in the sanity checking
code for GtkObjects.
* gtk/gtkbindings.c (gtk_binding_entry_add_signal): fixups of the
argument collection code.
* gtk/gtksignal.c (gtk_signal_collect_params): use the type set bounds
macros when distinguishing the return type.
Mon Jul 13 12:42:51 1998 George Lebl <jirka@5z.com>
* gdk/gdkwindow.h: (gdk_window_reparent) check if old_parent_private

20
ChangeLog.pre-2-0
View File

@ -1,3 +1,23 @@
Tue Jul 14 06:25:46 1998 Tim Janik <timj@gtk.org>
* gtk/testgtk.c (create_cursors): display the current cursor name.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c (gtk_type_init_builtin_types): cleanups to
the fundamental type definition. the GtkArg union now only covers
the required storage types for argument values. adapted the GTK_VALUE_*
macro set. handle GTK_TYPE_UCHAR. definiton of type set bounds macros.
* gtk/gtkargcollector.c (gtk_arg_collect_value): clean ups of the
code, fixed int/float collection. fixed a bug in the sanity checking
code for GtkObjects.
* gtk/gtkbindings.c (gtk_binding_entry_add_signal): fixups of the
argument collection code.
* gtk/gtksignal.c (gtk_signal_collect_params): use the type set bounds
macros when distinguishing the return type.
Mon Jul 13 12:42:51 1998 George Lebl <jirka@5z.com>
* gdk/gdkwindow.h: (gdk_window_reparent) check if old_parent_private

20
ChangeLog.pre-2-10
View File

@ -1,3 +1,23 @@
Tue Jul 14 06:25:46 1998 Tim Janik <timj@gtk.org>
* gtk/testgtk.c (create_cursors): display the current cursor name.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c (gtk_type_init_builtin_types): cleanups to
the fundamental type definition. the GtkArg union now only covers
the required storage types for argument values. adapted the GTK_VALUE_*
macro set. handle GTK_TYPE_UCHAR. definiton of type set bounds macros.
* gtk/gtkargcollector.c (gtk_arg_collect_value): clean ups of the
code, fixed int/float collection. fixed a bug in the sanity checking
code for GtkObjects.
* gtk/gtkbindings.c (gtk_binding_entry_add_signal): fixups of the
argument collection code.
* gtk/gtksignal.c (gtk_signal_collect_params): use the type set bounds
macros when distinguishing the return type.
Mon Jul 13 12:42:51 1998 George Lebl <jirka@5z.com>
* gdk/gdkwindow.h: (gdk_window_reparent) check if old_parent_private

20
ChangeLog.pre-2-2
View File

@ -1,3 +1,23 @@
Tue Jul 14 06:25:46 1998 Tim Janik <timj@gtk.org>
* gtk/testgtk.c (create_cursors): display the current cursor name.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c (gtk_type_init_builtin_types): cleanups to
the fundamental type definition. the GtkArg union now only covers
the required storage types for argument values. adapted the GTK_VALUE_*
macro set. handle GTK_TYPE_UCHAR. definiton of type set bounds macros.
* gtk/gtkargcollector.c (gtk_arg_collect_value): clean ups of the
code, fixed int/float collection. fixed a bug in the sanity checking
code for GtkObjects.
* gtk/gtkbindings.c (gtk_binding_entry_add_signal): fixups of the
argument collection code.
* gtk/gtksignal.c (gtk_signal_collect_params): use the type set bounds
macros when distinguishing the return type.
Mon Jul 13 12:42:51 1998 George Lebl <jirka@5z.com>
* gdk/gdkwindow.h: (gdk_window_reparent) check if old_parent_private

20
ChangeLog.pre-2-4
View File

@ -1,3 +1,23 @@
Tue Jul 14 06:25:46 1998 Tim Janik <timj@gtk.org>
* gtk/testgtk.c (create_cursors): display the current cursor name.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c (gtk_type_init_builtin_types): cleanups to
the fundamental type definition. the GtkArg union now only covers
the required storage types for argument values. adapted the GTK_VALUE_*
macro set. handle GTK_TYPE_UCHAR. definiton of type set bounds macros.
* gtk/gtkargcollector.c (gtk_arg_collect_value): clean ups of the
code, fixed int/float collection. fixed a bug in the sanity checking
code for GtkObjects.
* gtk/gtkbindings.c (gtk_binding_entry_add_signal): fixups of the
argument collection code.
* gtk/gtksignal.c (gtk_signal_collect_params): use the type set bounds
macros when distinguishing the return type.
Mon Jul 13 12:42:51 1998 George Lebl <jirka@5z.com>
* gdk/gdkwindow.h: (gdk_window_reparent) check if old_parent_private

20
ChangeLog.pre-2-6
View File

@ -1,3 +1,23 @@
Tue Jul 14 06:25:46 1998 Tim Janik <timj@gtk.org>
* gtk/testgtk.c (create_cursors): display the current cursor name.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c (gtk_type_init_builtin_types): cleanups to
the fundamental type definition. the GtkArg union now only covers
the required storage types for argument values. adapted the GTK_VALUE_*
macro set. handle GTK_TYPE_UCHAR. definiton of type set bounds macros.
* gtk/gtkargcollector.c (gtk_arg_collect_value): clean ups of the
code, fixed int/float collection. fixed a bug in the sanity checking
code for GtkObjects.
* gtk/gtkbindings.c (gtk_binding_entry_add_signal): fixups of the
argument collection code.
* gtk/gtksignal.c (gtk_signal_collect_params): use the type set bounds
macros when distinguishing the return type.
Mon Jul 13 12:42:51 1998 George Lebl <jirka@5z.com>
* gdk/gdkwindow.h: (gdk_window_reparent) check if old_parent_private

20
ChangeLog.pre-2-8
View File

@ -1,3 +1,23 @@
Tue Jul 14 06:25:46 1998 Tim Janik <timj@gtk.org>
* gtk/testgtk.c (create_cursors): display the current cursor name.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c (gtk_type_init_builtin_types): cleanups to
the fundamental type definition. the GtkArg union now only covers
the required storage types for argument values. adapted the GTK_VALUE_*
macro set. handle GTK_TYPE_UCHAR. definiton of type set bounds macros.
* gtk/gtkargcollector.c (gtk_arg_collect_value): clean ups of the
code, fixed int/float collection. fixed a bug in the sanity checking
code for GtkObjects.
* gtk/gtkbindings.c (gtk_binding_entry_add_signal): fixups of the
argument collection code.
* gtk/gtksignal.c (gtk_signal_collect_params): use the type set bounds
macros when distinguishing the return type.
Mon Jul 13 12:42:51 1998 George Lebl <jirka@5z.com>
* gdk/gdkwindow.h: (gdk_window_reparent) check if old_parent_private

7
gtk/gtk.defs
View File

@ -315,6 +315,7 @@
(invalid GTK_TYPE_INVALID)
(none GTK_TYPE_NONE)
(char GTK_TYPE_CHAR)
(uchar GTK_TYPE_UCHAR)
(bool GTK_TYPE_BOOL)
(int GTK_TYPE_INT)
(uint GTK_TYPE_UINT)
@ -326,12 +327,12 @@
(enum GTK_TYPE_ENUM)
(flags GTK_TYPE_FLAGS)
(boxed GTK_TYPE_BOXED)
(foreign GTK_TYPE_FOREIGN)
(callback GTK_TYPE_CALLBACK)
(args GTK_TYPE_ARGS)
(pointer GTK_TYPE_POINTER)
(signal GTK_TYPE_SIGNAL)
(args GTK_TYPE_ARGS)
(callback GTK_TYPE_CALLBACK)
(c-callback GTK_TYPE_C_CALLBACK)
(foreign GTK_TYPE_FOREIGN)
(object GTK_TYPE_OBJECT))
; enumerations from "./gtkwidget.h"

2
gtk/gtkarg.c
View File

@ -406,7 +406,7 @@ gtk_arg_copy (GtkArg *src_arg,
dest_arg->d = src_arg->d;
if (src_arg->type == GTK_TYPE_STRING)
dest_arg->d.string_data = g_strdup (src_arg->d.string_data);
GTK_VALUE_STRING (*dest_arg) = g_strdup (GTK_VALUE_STRING (*src_arg));
return dest_arg;
}

58
gtk/gtkargcollector.c
View File

@ -32,14 +32,27 @@ gtk_arg_collect_value (GtkType fundamental_type,
case GTK_TYPE_INVALID:
error_msg = g_strdup ("invalid untyped argument");
break;
case GTK_TYPE_NONE:
/* error_msg = g_strdup ("invalid argument type `void'"); */
/* we just ignore this type, since it arithmetically just requires
* us to not move the var_args pointer any further. callers need to
* check for the validity of GTK_TYPE_NONE themselves.
*
* error_msg = g_strdup ("invalid argument type `void'");
*/
break;
/* everything smaller than an int is guarranteed to be
* passed as an int
*/
case GTK_TYPE_CHAR:
GTK_VALUE_CHAR (*arg) = va_arg (*var_args, gchar);
GTK_VALUE_CHAR (*arg) = va_arg (*var_args, gint);
break;
case GTK_TYPE_UCHAR:
GTK_VALUE_UCHAR (*arg) = va_arg (*var_args, guint);
break;
case GTK_TYPE_BOOL:
GTK_VALUE_BOOL (*arg) = va_arg (*var_args, gboolean);
GTK_VALUE_BOOL (*arg) = va_arg (*var_args, gint);
break;
case GTK_TYPE_INT:
GTK_VALUE_INT (*arg) = va_arg (*var_args, gint);
@ -51,14 +64,21 @@ gtk_arg_collect_value (GtkType fundamental_type,
GTK_VALUE_ENUM (*arg) = va_arg (*var_args, gint);
break;
case GTK_TYPE_FLAGS:
GTK_VALUE_FLAGS (*arg) = va_arg (*var_args, gint);
GTK_VALUE_FLAGS (*arg) = va_arg (*var_args, guint);
break;
/* we collect longs as glongs since they differ in size with
* integers on some platforms
*/
case GTK_TYPE_LONG:
GTK_VALUE_LONG (*arg) = va_arg (*var_args, glong);
break;
case GTK_TYPE_ULONG:
GTK_VALUE_ULONG (*arg) = va_arg (*var_args, gulong);
break;
/* floats are always passed as doubles
*/
case GTK_TYPE_FLOAT:
/* GTK_VALUE_FLOAT (*arg) = va_arg (*var_args, gfloat); */
GTK_VALUE_FLOAT (*arg) = va_arg (*var_args, gdouble);
@ -66,6 +86,9 @@ gtk_arg_collect_value (GtkType fundamental_type,
case GTK_TYPE_DOUBLE:
GTK_VALUE_DOUBLE (*arg) = va_arg (*var_args, gdouble);
break;
/* collect pointer values
*/
case GTK_TYPE_STRING:
GTK_VALUE_STRING (*arg) = va_arg (*var_args, gchar*);
break;
@ -75,10 +98,17 @@ gtk_arg_collect_value (GtkType fundamental_type,
case GTK_TYPE_BOXED:
GTK_VALUE_BOXED (*arg) = va_arg (*var_args, gpointer);
break;
/* structured types
*/
case GTK_TYPE_SIGNAL:
GTK_VALUE_SIGNAL (*arg).f = va_arg (*var_args, GtkFunction);
GTK_VALUE_SIGNAL (*arg).f = va_arg (*var_args, GtkSignalFunc);
GTK_VALUE_SIGNAL (*arg).d = va_arg (*var_args, gpointer);
break;
case GTK_TYPE_ARGS:
GTK_VALUE_ARGS (*arg).n_args = va_arg (*var_args, gint);
GTK_VALUE_ARGS (*arg).args = va_arg (*var_args, GtkArg*);
break;
case GTK_TYPE_FOREIGN:
GTK_VALUE_FOREIGN (*arg).data = va_arg (*var_args, gpointer);
GTK_VALUE_FOREIGN (*arg).notify = va_arg (*var_args, GtkDestroyNotify);
@ -92,18 +122,23 @@ gtk_arg_collect_value (GtkType fundamental_type,
GTK_VALUE_C_CALLBACK (*arg).func = va_arg (*var_args, GtkFunction);
GTK_VALUE_C_CALLBACK (*arg).func_data = va_arg (*var_args, gpointer);
break;
case GTK_TYPE_ARGS:
GTK_VALUE_ARGS (*arg).n_args = va_arg (*var_args, gint);
GTK_VALUE_ARGS (*arg).args = va_arg (*var_args, GtkArg*);
break;
/* we do some extra sanity checking when collecting objects,
* i.e. if the object pointer is not NULL, we check whether we
* actually got an object pointer within the desired class branch.
*/
case GTK_TYPE_OBJECT:
GTK_VALUE_OBJECT (*arg) = va_arg (*var_args, GtkObject*);
if (GTK_VALUE_OBJECT (*arg) != NULL)
{
register GtkObject *object = GTK_VALUE_OBJECT (*arg);
if (object->klass == NULL ||
!gtk_type_is_a (GTK_OBJECT_TYPE (object), arg->type))
if (object->klass == NULL)
error_msg = g_strconcat ("invalid unclassed object pointer for argument type `",
gtk_type_name (arg->type),
"'",
NULL);
else if (!gtk_type_is_a (GTK_OBJECT_TYPE (object), arg->type))
error_msg = g_strconcat ("invalid object `",
gtk_type_name (GTK_OBJECT_TYPE (object)),
"' for argument type `",
@ -112,6 +147,7 @@ gtk_arg_collect_value (GtkType fundamental_type,
NULL);
}
break;
default:
error_msg = g_strconcat ("unsupported argument type `",
gtk_type_name (arg->type),

22
gtk/gtkbindings.c
View File

@ -643,16 +643,16 @@ gtk_binding_entry_add_signal (GtkBindingSet *binding_set,
arg->arg_type = va_arg (args, GtkType);
switch (GTK_FUNDAMENTAL_TYPE (arg->arg_type))
{
/* for elaborated commenting about var args collection, take a look
* at gtk_arg_collect_value() in gtkargcollector.c
*/
case GTK_TYPE_CHAR:
arg->arg_type = GTK_TYPE_LONG;
arg->d.long_data = va_arg (args, gchar);
break;
case GTK_TYPE_BOOL:
arg->arg_type = GTK_TYPE_LONG;
arg->d.long_data = va_arg (args, gboolean) != 0;
break;
case GTK_TYPE_UCHAR:
case GTK_TYPE_INT:
case GTK_TYPE_UINT:
case GTK_TYPE_BOOL:
case GTK_TYPE_ENUM:
case GTK_TYPE_FLAGS:
arg->arg_type = GTK_TYPE_LONG;
arg->d.long_data = va_arg (args, gint);
break;
@ -662,9 +662,6 @@ gtk_binding_entry_add_signal (GtkBindingSet *binding_set,
arg->d.long_data = va_arg (args, glong);
break;
case GTK_TYPE_FLOAT:
arg->arg_type = GTK_TYPE_DOUBLE;
arg->d.double_data = va_arg (args, gfloat);
break;
case GTK_TYPE_DOUBLE:
arg->arg_type = GTK_TYPE_DOUBLE;
arg->d.double_data = va_arg (args, gdouble);
@ -681,11 +678,6 @@ gtk_binding_entry_add_signal (GtkBindingSet *binding_set,
i += n_args + 1;
}
break;
case GTK_TYPE_ENUM:
case GTK_TYPE_FLAGS:
arg->arg_type = GTK_TYPE_LONG;
arg->d.long_data = va_arg (args, gint);
break;
default:
g_warning ("gtk_binding_entry_add_signal(): unsupported type `%s' for arg[%u]",
gtk_type_name (arg->arg_type), i);

2
gtk/gtkobject.c
View File

@ -310,7 +310,7 @@ gtk_object_set_arg (GtkObject *object,
{
gtk_signal_connect_full (object,
arg_name + n + 2,
(GtkSignalFunc) GTK_VALUE_SIGNAL (*arg).f, NULL,
GTK_VALUE_SIGNAL (*arg).f, NULL,
GTK_VALUE_SIGNAL (*arg).d,
NULL,
(arg_id == ARG_OBJECT_SIGNAL ||

12
gtk/gtkobject.h
View File

@ -221,18 +221,6 @@ struct _GtkObjectClass
};
/* For the purpose of user signals we need the signal function
* and signal marshaller signatures already in this place.
*/
#define GTK_SIGNAL_FUNC(f) ((GtkSignalFunc) f)
typedef void (*GtkSignalFunc) (void);
typedef void (*GtkSignalMarshaller) (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* Application-level methods */

5
gtk/gtksignal.c
View File

@ -1832,9 +1832,8 @@ gtk_signal_collect_params (GtkArg *params,
return_type = GTK_FUNDAMENTAL_TYPE (return_type);
if (return_type != GTK_TYPE_NONE)
{
if ((return_type >= GTK_TYPE_CHAR &&
return_type <= GTK_TYPE_BOXED) ||
(return_type == GTK_TYPE_POINTER) ||
if ((return_type >= GTK_TYPE_FLAT_FIRST &&
return_type <= GTK_TYPE_FLAT_LAST) ||
(return_type == GTK_TYPE_OBJECT))
{
GTK_VALUE_POINTER (*params) = va_arg (var_args, gpointer);

7
gtk/gtktypebuiltins_evals.c
View File

@ -337,6 +337,7 @@ static GtkEnumValue _gtk_fundamental_type_values[] = {
{ GTK_TYPE_INVALID, "GTK_TYPE_INVALID", "invalid" },
{ GTK_TYPE_NONE, "GTK_TYPE_NONE", "none" },
{ GTK_TYPE_CHAR, "GTK_TYPE_CHAR", "char" },
{ GTK_TYPE_UCHAR, "GTK_TYPE_UCHAR", "uchar" },
{ GTK_TYPE_BOOL, "GTK_TYPE_BOOL", "bool" },
{ GTK_TYPE_INT, "GTK_TYPE_INT", "int" },
{ GTK_TYPE_UINT, "GTK_TYPE_UINT", "uint" },
@ -348,12 +349,12 @@ static GtkEnumValue _gtk_fundamental_type_values[] = {
{ GTK_TYPE_ENUM, "GTK_TYPE_ENUM", "enum" },
{ GTK_TYPE_FLAGS, "GTK_TYPE_FLAGS", "flags" },
{ GTK_TYPE_BOXED, "GTK_TYPE_BOXED", "boxed" },
{ GTK_TYPE_FOREIGN, "GTK_TYPE_FOREIGN", "foreign" },
{ GTK_TYPE_CALLBACK, "GTK_TYPE_CALLBACK", "callback" },
{ GTK_TYPE_ARGS, "GTK_TYPE_ARGS", "args" },
{ GTK_TYPE_POINTER, "GTK_TYPE_POINTER", "pointer" },
{ GTK_TYPE_SIGNAL, "GTK_TYPE_SIGNAL", "signal" },
{ GTK_TYPE_ARGS, "GTK_TYPE_ARGS", "args" },
{ GTK_TYPE_CALLBACK, "GTK_TYPE_CALLBACK", "callback" },
{ GTK_TYPE_C_CALLBACK, "GTK_TYPE_C_CALLBACK", "c-callback" },
{ GTK_TYPE_FOREIGN, "GTK_TYPE_FOREIGN", "foreign" },
{ GTK_TYPE_OBJECT, "GTK_TYPE_OBJECT", "object" },
{ 0, NULL, NULL }
};

16
gtk/gtktypeutils.c
View File

@ -535,11 +535,6 @@ gtk_type_class_init (GtkTypeNode *node)
g_slist_free (slist);
}
/* FIXME: this initialization needs to be done through
* a function pointer someday.
*/
g_assert (node->type_info.class_size >= sizeof (GtkObjectClass));
if (node->type_info.class_init_func)
node->type_info.class_init_func (node->klass);
}
@ -694,6 +689,7 @@ gtk_type_init_builtin_types (void)
} fundamental_info[] = {
{ GTK_TYPE_NONE, "void" },
{ GTK_TYPE_CHAR, "gchar" },
{ GTK_TYPE_UCHAR, "guchar" },
{ GTK_TYPE_BOOL, "gboolean" },
{ GTK_TYPE_INT, "gint" },
{ GTK_TYPE_UINT, "guint" },
@ -705,13 +701,13 @@ gtk_type_init_builtin_types (void)
{ GTK_TYPE_ENUM, "GtkEnum" },
{ GTK_TYPE_FLAGS, "GtkFlags" },
{ GTK_TYPE_BOXED, "GtkBoxed" },
{ GTK_TYPE_FOREIGN, "GtkForeign" },
{ GTK_TYPE_CALLBACK, "GtkCallback" },
{ GTK_TYPE_ARGS, "GtkArgs" },
{ GTK_TYPE_POINTER, "gpointer" },
{ GTK_TYPE_SIGNAL, "GtkSignal" },
{ GTK_TYPE_C_CALLBACK, "GtkCCallback" }
{ GTK_TYPE_ARGS, "GtkArgs" },
{ GTK_TYPE_CALLBACK, "GtkCallback" },
{ GTK_TYPE_C_CALLBACK, "GtkCCallback" },
{ GTK_TYPE_FOREIGN, "GtkForeign" },
};
struct {
gchar *type_name;

142
gtk/gtktypeutils.h
View File

@ -35,7 +35,10 @@ typedef enum
{
GTK_TYPE_INVALID,
GTK_TYPE_NONE,
/* flat types */
GTK_TYPE_CHAR,
GTK_TYPE_UCHAR,
GTK_TYPE_BOOL,
GTK_TYPE_INT,
GTK_TYPE_UINT,
@ -47,23 +50,30 @@ typedef enum
GTK_TYPE_ENUM,
GTK_TYPE_FLAGS,
GTK_TYPE_BOXED,
GTK_TYPE_FOREIGN,
GTK_TYPE_CALLBACK,
GTK_TYPE_ARGS,
GTK_TYPE_POINTER,
/* It'd be great if GTK_TYPE_POINTER and GTK_TYPE_C_CALLBACK
* could be removed eventually
*/
/* structured types */
GTK_TYPE_SIGNAL,
GTK_TYPE_ARGS,
GTK_TYPE_CALLBACK,
GTK_TYPE_C_CALLBACK,
GTK_TYPE_FOREIGN,
GTK_TYPE_OBJECT,
GTK_FUNDAMENTAL_TYPE_LAST
/* base type node of the object system */
GTK_TYPE_OBJECT
} GtkFundamentalType;
/* bounds definitions for type sets, these are provided to distinct
* between fundamental types with if() statements, and to build
* up foreign fundamentals
*/
#define GTK_TYPE_FLAT_FIRST GTK_TYPE_CHAR
#define GTK_TYPE_FLAT_LAST GTK_TYPE_POINTER
#define GTK_TYPE_STRUCTURED_FIRST GTK_TYPE_SIGNAL
#define GTK_TYPE_STRUCTURED_LAST GTK_TYPE_FOREIGN
#define GTK_TYPE_FUNDAMENTAL_LAST GTK_TYPE_OBJECT
typedef guint GtkType;
/* Builtin Types
@ -85,27 +95,47 @@ typedef struct _GtkTypeInfo GtkTypeInfo;
typedef struct _GtkEnumValue GtkEnumValue;
typedef struct _GtkEnumValue GtkFlagValue;
#define GTK_SIGNAL_FUNC(f) ((GtkSignalFunc) f)
typedef void (*GtkClassInitFunc) (gpointer klass);
typedef void (*GtkObjectInitFunc) (gpointer object);
typedef void (*GtkArgGetFunc) (GtkObject*, GtkArg*, guint);
typedef void (*GtkArgSetFunc) (GtkObject*, GtkArg*, guint);
typedef void (*GtkSignalFunc) ();
typedef gint (*GtkFunction) (gpointer data);
typedef void (*GtkDestroyNotify) (gpointer data);
typedef void (*GtkCallbackMarshal) (GtkObject *object,
gpointer data,
guint n_args,
GtkArg *args);
typedef void (*GtkDestroyNotify) (gpointer data);
typedef void (*GtkSignalMarshaller) (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *args);
/* deprecated */
typedef void (*GtkArgGetFunc) (GtkObject*, GtkArg*, guint);
typedef void (*GtkArgSetFunc) (GtkObject*, GtkArg*, guint);
struct _GtkArg
{
GtkType type;
gchar *name;
/* this union only defines the required storage types for
* the possibile values, thus there is no gint enum_data field,
* because that would just be a mere alias for gint int_data.
* use the GTK_VALUE_*() and GTK_RETLOC_*() macros to access
* the discrete memebers.
*/
union {
/* flat values */
gchar char_data;
guchar uchar_data;
gboolean bool_data;
gint int_data;
guint uint_data;
gint bool_data;
glong long_data;
gulong ulong_data;
gfloat float_data;
@ -113,31 +143,40 @@ struct _GtkArg
gchar *string_data;
gpointer pointer_data;
GtkObject *object_data;
/* structured values */
struct {
GtkSignalFunc f;
gpointer d;
} signal_data;
struct {
gint n_args;
GtkArg *args;
} args_data;
struct {
GtkCallbackMarshal marshal;
gpointer data;
GtkDestroyNotify notify;
} callback_data;
struct {
gpointer data;
GtkDestroyNotify notify;
} foreign_data;
struct {
gint n_args;
GtkArg *args;
} args_data;
struct {
GtkFunction f;
gpointer d;
} signal_data;
struct {
GtkFunction func;
gpointer func_data;
} c_callback_data;
struct {
gpointer data;
GtkDestroyNotify notify;
} foreign_data;
} d;
};
/* argument value access macros, these must not contain casts,
* to allow the usage of these macros in combination with the
* adress operator, e.g. &GTK_VALUE_CHAR (*arg)
*/
/* flat values */
#define GTK_VALUE_CHAR(a) ((a).d.char_data)
#define GTK_VALUE_UCHAR(a) ((a).d.uchar_data)
#define GTK_VALUE_BOOL(a) ((a).d.bool_data)
#define GTK_VALUE_INT(a) ((a).d.int_data)
#define GTK_VALUE_UINT(a) ((a).d.uint_data)
@ -147,30 +186,39 @@ struct _GtkArg
#define GTK_VALUE_DOUBLE(a) ((a).d.double_data)
#define GTK_VALUE_STRING(a) ((a).d.string_data)
#define GTK_VALUE_ENUM(a) ((a).d.int_data)
#define GTK_VALUE_FLAGS(a) ((a).d.int_data)
#define GTK_VALUE_FLAGS(a) ((a).d.uint_data)
#define GTK_VALUE_BOXED(a) ((a).d.pointer_data)
#define GTK_VALUE_FOREIGN(a) ((a).d.foreign_data)
#define GTK_VALUE_CALLBACK(a) ((a).d.callback_data)
#define GTK_VALUE_ARGS(a) ((a).d.args_data)
#define GTK_VALUE_OBJECT(a) ((a).d.pointer_data)
#define GTK_VALUE_POINTER(a) ((a).d.pointer_data)
#define GTK_VALUE_SIGNAL(a) ((a).d.signal_data)
#define GTK_VALUE_C_CALLBACK(a) ((a).d.c_callback_data)
#define GTK_VALUE_OBJECT(a) ((a).d.object_data)
#define GTK_RETLOC_CHAR(a) ((gchar*)(a).d.pointer_data)
#define GTK_RETLOC_BOOL(a) ((gint*)(a).d.pointer_data)
#define GTK_RETLOC_INT(a) ((gint*)(a).d.pointer_data)
#define GTK_RETLOC_UINT(a) ((guint*)(a).d.pointer_data)
#define GTK_RETLOC_LONG(a) ((glong*)(a).d.pointer_data)
#define GTK_RETLOC_ULONG(a) ((gulong*)(a).d.pointer_data)
#define GTK_RETLOC_FLOAT(a) ((gfloat*)(a).d.pointer_data)
#define GTK_RETLOC_DOUBLE(a) ((gdouble*)(a).d.pointer_data)
#define GTK_RETLOC_STRING(a) ((gchar**)(a).d.pointer_data)
#define GTK_RETLOC_ENUM(a) ((gint*)(a).d.pointer_data)
#define GTK_RETLOC_FLAGS(a) ((gint*)(a).d.pointer_data)
#define GTK_RETLOC_BOXED(a) ((gpointer*)(a).d.pointer_data)
#define GTK_RETLOC_OBJECT(a) ((GtkObject**)(a).d.pointer_data)
#define GTK_RETLOC_POINTER(a) ((gpointer*)(a).d.pointer_data)
/* structured values */
#define GTK_VALUE_SIGNAL(a) ((a).d.signal_data)
#define GTK_VALUE_ARGS(a) ((a).d.args_data)
#define GTK_VALUE_CALLBACK(a) ((a).d.callback_data)
#define GTK_VALUE_C_CALLBACK(a) ((a).d.c_callback_data)
#define GTK_VALUE_FOREIGN(a) ((a).d.foreign_data)
/* return location macros, these all narow down to
* pointer types, because return values need to be
* passed by reference
*/
/* flat values */
#define GTK_RETLOC_CHAR(a) ((gchar*) (a).d.pointer_data)
#define GTK_RETLOC_UCHAR(a) ((guchar*) (a).d.pointer_data)
#define GTK_RETLOC_BOOL(a) ((gboolean*) (a).d.pointer_data)
#define GTK_RETLOC_INT(a) ((gint*) (a).d.pointer_data)
#define GTK_RETLOC_UINT(a) ((guint*) (a).d.pointer_data)
#define GTK_RETLOC_LONG(a) ((glong*) (a).d.pointer_data)
#define GTK_RETLOC_ULONG(a) ((gulong*) (a).d.pointer_data)
#define GTK_RETLOC_FLOAT(a) ((gfloat*) (a).d.pointer_data)
#define GTK_RETLOC_DOUBLE(a) ((gdouble*) (a).d.pointer_data)
#define GTK_RETLOC_STRING(a) ((gchar**) (a).d.pointer_data)
#define GTK_RETLOC_ENUM(a) ((gint*) (a).d.pointer_data)
#define GTK_RETLOC_FLAGS(a) ((guint*) (a).d.pointer_data)
#define GTK_RETLOC_BOXED(a) ((gpointer*) (a).d.pointer_data)
#define GTK_RETLOC_POINTER(a) ((gpointer*) (a).d.pointer_data)
#define GTK_RETLOC_OBJECT(a) ((GtkObject**) (a).d.pointer_data)
struct _GtkTypeInfo
{

21
gtk/testgtk.c
View File

@ -2710,10 +2710,21 @@ set_cursor (GtkWidget *spinner,
{
guint c;
GdkCursor *cursor;
GtkWidget *label;
GtkFlagValue *vals;
c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
c &= 0xfe;
label = gtk_object_get_user_data (GTK_OBJECT (spinner));
vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
while (vals && vals->value != c)
vals++;
if (vals)
gtk_label_set (GTK_LABEL (label), vals->value_nick);
else
gtk_label_set (GTK_LABEL (label), "<unknown>");
cursor = gdk_cursor_new (c);
gdk_window_set_cursor (widget->window, cursor);
gdk_cursor_destroy (cursor);
@ -2817,6 +2828,16 @@ create_cursors (void)
GTK_SIGNAL_FUNC (set_cursor),
darea);
label = gtk_widget_new (GTK_TYPE_LABEL,
"visible", TRUE,
"label", "XXX",
"parent", vbox,
NULL);
gtk_container_child_set (GTK_CONTAINER (vbox), label,
"expand", FALSE,
NULL);
gtk_object_set_user_data (GTK_OBJECT (spinner), label);
any =
gtk_widget_new (gtk_hseparator_get_type (),
"GtkWidget::visible", TRUE,

21
tests/testgtk.c
View File

@ -2710,10 +2710,21 @@ set_cursor (GtkWidget *spinner,
{
guint c;
GdkCursor *cursor;
GtkWidget *label;
GtkFlagValue *vals;
c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
c &= 0xfe;
label = gtk_object_get_user_data (GTK_OBJECT (spinner));
vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
while (vals && vals->value != c)
vals++;
if (vals)
gtk_label_set (GTK_LABEL (label), vals->value_nick);
else
gtk_label_set (GTK_LABEL (label), "<unknown>");
cursor = gdk_cursor_new (c);
gdk_window_set_cursor (widget->window, cursor);
gdk_cursor_destroy (cursor);
@ -2817,6 +2828,16 @@ create_cursors (void)
GTK_SIGNAL_FUNC (set_cursor),
darea);
label = gtk_widget_new (GTK_TYPE_LABEL,
"visible", TRUE,
"label", "XXX",
"parent", vbox,
NULL);
gtk_container_child_set (GTK_CONTAINER (vbox), label,
"expand", FALSE,
NULL);
gtk_object_set_user_data (GTK_OBJECT (spinner), label);
any =
gtk_widget_new (gtk_hseparator_get_type (),
"GtkWidget::visible", TRUE,