mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-24 17:20:36 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/gobject2gtk.h
wrobell 08eaa11259 - some fixes to int2float making automake 1.5 happy (gst now requires automake1.5). It's still not perfect but it bui... 
Original commit message from CVS:
- added playondemand plugin by Leif Morgan Johnson <lmjohns3@eos.ncsu.edu>
- some fixes to int2float
- aplied a patch from wrobell <wrobell@ite.pl> that is a first attempt at
making automake 1.5 happy (gst now requires automake1.5). It's still not
perfect but it builds.
- Made the schedulers plugable. The default scheduler now lives inside a
plugin.
- Added a new mpeg1/2 parser/demuxer.
- Fixed some compiler warnings in the core libs.
- substantial work to GstThread (hopefully less race conditions). simplified
the code in GstThread a bit. A state change can now also happen in the
thread context.
- reworked the state semantics of a bin. it'll now automatically get the
highest state of its children.
- the autoplugger now nests the threads so that a state change failure of
one thread doesn't make its upstream thread lock.
- GstQueue refuses to go to PLAYING if the sinkpad is not connected. This
way the queue will not wedge in the _get lock.
- GstQueue unlocks its mutexes when going to PAUSED.
- make sure that when all elements in a bin/thread go to PAUSED, the bin
is set to PAUSED too.
- make a parent bin wait for its children to PAUSE before ending the
iteration with FALSE (EOS)
- Some changes to GstPlay to deal with EOS.
- aplied the latest patch from Zeenix to gstrtp.

end result: GstPlay doesn't crash on EOS and the pipeline is now shut down
properly.
2001-12-04 22:12:50 +00:00

434 lines
16 KiB
C
Raw Blame History

#ifndef __GOBJECT_2_GTK_H__
#define __GOBJECT_2_GTK_H__
#include <gtk/gtk.h>
#define G_MAXUINT UINT_MAX
#define G_MAXULONG ULONG_MAX
#define G_MAXINT64 G_MAXULONG
#define G_E 2.7182818284590452354E0
#define G_LN2 6.9314718055994530942E-1
#define G_LN10 2.3025850929940456840E0
#define G_PI 3.14159265358979323846E0
#define G_PI_2 1.57079632679489661923E0
#define G_PI_4 0.78539816339744830962E0
#define G_SQRT2 1.4142135623730950488E0
// lists functions not in glib 1.2
GList *g_list_delete_link (GList *list, GList *llink);
GSList *g_slist_delete_link (GSList *list, GSList *llink);
#define g_string_append_printf g_string_printfa
// string helper functions not in glib 1.2
#define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz"
#define G_CSET_DIGITS "0123456789"
gchar* g_strcanon (gchar *string, const gchar *valid_chars,
gchar substitutor);
// GObject
typedef struct _GObject GObject;
typedef struct _GObjectClass GObjectClass;
#define g_string_printf g_string_sprintf
#define g_string_printfa g_string_sprintfa
#define g_object_ref(obj) gtk_object_ref((GtkObject *)(obj))
#define g_object_unref(obj) gtk_object_unref((GtkObject *)(obj))
// the helper macros for type checking
#define G_TYPE_CHECK_INSTANCE_CAST GTK_CHECK_CAST
#define G_TYPE_CHECK_INSTANCE_TYPE GTK_CHECK_TYPE
#define G_TYPE_INSTANCE_GET_CLASS(o,t,c) (((c*)(GTK_OBJECT(o)->klass)))
#define G_TYPE_CHECK_CLASS_CAST GTK_CHECK_CLASS_CAST
#define G_TYPE_CHECK_CLASS_TYPE GTK_CHECK_CLASS_TYPE
#define G_TYPE_FROM_CLASS(klass) (((GtkObjectClass *)(klass))->type)
#define G_OBJECT_GET_CLASS(object) (G_OBJECT(object)->klass)
#define G_OBJECT_TYPE GTK_OBJECT_TYPE
#define G_OBJECT_CLASS_TYPE(gclass) (gclass->type)
// types
#define G_TYPE_NONE GTK_TYPE_NONE
#define G_TYPE_CHAR GTK_TYPE_CHAR
#define G_TYPE_UCHAR GTK_TYPE_UCHAR
#define G_TYPE_BOOLEAN GTK_TYPE_BOOL
#define G_TYPE_INT GTK_TYPE_INT
#define G_TYPE_UINT GTK_TYPE_UINT
#define G_TYPE_LONG GTK_TYPE_LONG
#define G_TYPE_ULONG GTK_TYPE_ULONG
#define G_TYPE_ENUM GTK_TYPE_ENUM
#define G_TYPE_FLAGS GTK_TYPE_FLAGS
#define G_TYPE_FLOAT GTK_TYPE_FLOAT
#define G_TYPE_DOUBLE GTK_TYPE_DOUBLE
#define G_TYPE_STRING GTK_TYPE_STRING
#define G_TYPE_POINTER GTK_TYPE_POINTER
#define G_TYPE_BOXED GTK_TYPE_BOXED
#define G_TYPE_PARAM GTK_TYPE_PARAM
// marshallers
#define g_cclosure_marshal_VOID__VOID gtk_marshal_NONE__NONE
#define g_cclosure_marshal_VOID__BOOLEAN gtk_marshal_NONE__BOOL
#define g_cclosure_marshal_VOID__CHAR gtk_marshal_NONE__CHAR
#define g_cclosure_marshal_VOID__UCHAR gtk_marshal_NONE__UCHAR
#define g_cclosure_marshal_VOID__INT gtk_marshal_NONE__INT
#define g_cclosure_marshal_VOID__UINT gtk_marshal_NONE__UINT
#define g_cclosure_marshal_VOID__LONG gtk_marshal_NONE__LONG
#define g_cclosure_marshal_VOID__ULONG gtk_marshal_NONE__ULONG
#define g_cclosure_marshal_VOID__ENUM gtk_marshal_NONE__ENUM
#define g_cclosure_marshal_VOID__FLAGS gtk_marshal_NONE__FLAGS
#define g_cclosure_marshal_VOID__FLOAT gtk_marshal_NONE__FLOAT
#define g_cclosure_marshal_VOID__DOUBLE gtk_marshal_NONE__DOUBLE
#define g_cclosure_marshal_VOID__STRING gtk_marshal_NONE__STRING
#define g_cclosure_marshal_VOID__PARAM gtk_marshal_NONE__PARAM
#define g_cclosure_marshal_VOID__BOXED gtk_marshal_NONE__BOXED
#define g_cclosure_marshal_VOID__POINTER gtk_marshal_NONE__POINTER
#define g_cclosure_marshal_VOID__OBJECT gtk_marshal_NONE__OBJECT
#define g_cclosure_marshal_STRING__OBJECT_POINTER gtk_marshal_STRING__POINTER_POINTER
#define g_cclosure_marshal_VOID__UINT_POINTER gtk_marshal_NONE__UINT_POINTER
#define gst_marshal_VOID__VOID gtk_marshal_NONE__NONE
#define gst_marshal_VOID__BOOLEAN gtk_marshal_NONE__BOOL
#define gst_marshal_VOID__INT gtk_marshal_NONE__INT
#define gst_marshal_VOID__INT_INT gtk_marshal_NONE__INT_INT
#define gst_marshal_VOID__STRING gtk_marshal_NONE__STRING
#define gst_marshal_VOID__POINTER gtk_marshal_NONE__POINTER
#define gst_marshal_VOID__OBJECT gtk_marshal_NONE__POINTER
#define gst_marshal_VOID__OBJECT_POINTER gtk_marshal_NONE__POINTER_POINTER
#define gst_marshal_VOID__INT_INT gtk_marshal_NONE__INT_INT
/* General macros */
#ifdef __cplusplus
# define G_BEGIN_DECLS extern "C" {
# define G_END_DECLS }
#else
# define G_BEGIN_DECLS
# define G_END_DECLS
#endif
// args
//#define set_property set_arg
//#define get_property get_arg
#define g_object_get_property(obj,argname,pspec)\
G_STMT_START{ \
(pspec)->name = (gchar*)argname;\
gtk_object_getv ((GtkObject *)(obj),1,(pspec));\
}G_STMT_END
#define g_object_set(o,args...) gtk_object_set ((GtkObject *) (o), ## args)
// type system
#define GType GtkType
#define GTypeFlags guint
#define GClassInitFunc GtkClassInitFunc
#define GBaseInitFunc GtkClassInitFunc
#define GInstanceInitFunc GtkObjectInitFunc
#define g_type_class_peek_parent(c) gtk_type_parent_class (GTK_OBJECT_CLASS (c)->type)
#define g_type_init gtk_type_init
#define g_type_is_a gtk_type_is_a
#define g_type_class_ref gtk_type_class
#define g_type_class_unref(c)
#define g_type_name(t) gtk_type_name(t)
#define g_type_from_name(t) gtk_type_from_name(t)
#define g_type_parent(t) gtk_type_parent(t)
#define GEnumValue GtkEnumValue
#define g_enum_register_static gtk_type_register_enum
GType g2g_object_get_type (void);
/*********************************
* FIXME API NOT in glib2.0
***********************************/
// type registration
typedef struct _GTypeInfo GTypeInfo;
struct _GTypeInfo
{
/* interface types, classed types, instantiated types */
guint16 class_size;
GBaseInitFunc base_init;
gpointer base_finalize;
/* classed types, instantiated types */
GClassInitFunc class_init;
gpointer class_finalize;
gconstpointer class_data;
/* instantiated types */
guint16 instance_size;
guint16 n_preallocs;
GInstanceInitFunc instance_init;
/* value handling */
const gpointer value_table;
};
#define G_TYPE_FLAG_ABSTRACT 0
#define g_type_register_static g2g_type_register_static
guint g2g_type_register_static (GtkType parent_type, gchar *type_name,
const GTypeInfo *info, guint flags);
// object creation
#define g_object_new g2g_object_new
gpointer g2g_object_new(GtkType type,gpointer blah_varargs_stuff);
// disposal
#define g_object_run_dispose g2g_object_run_dispose
void g2g_object_run_dispose (GObject *object);
#define G_SIGNAL_RUN_LAST GTK_RUN_LAST
#define G_SIGNAL_RUN_FIRST GTK_RUN_FIRST
#define G_SIGNAL_RUN_CLEANUP 0
#define G_SIGNAL_NO_RECURSE GTK_RUN_NO_RECURSE
#define G_SIGNAL_NO_HOOKS GTK_RUN_NO_HOOKS
#define GCallback gpointer // FIXME?
#define G_CALLBACK(f) ((gpointer)(f))
#define g_signal_new g2g_signal_new
#define g_signal_handlers_destroy(x)
guint
g2g_signal_new (const gchar *signal_name,
GtkType object_type,
GtkSignalRunType signal_flags,
guint function_offset,
gpointer accumulator, // GSignalAccumulator
gpointer accu_data,
GtkSignalMarshaller marshaller,
GType return_type,
guint nparams,
...);
#define \
g_signal_emit(object,signal,detail,args...) \
gtk_signal_emit((GtkObject *)object,signal, ## args )
#define \
g_signal_connect(object,name,func,func_data) \
gtk_signal_connect((GtkObject *)object,name,func,func_data)
#define \
g_signal_handlers_disconnect_by_func(object,func,func_data) \
gtk_signal_disconnect_by_func((GtkObject *)object,func,func_data)
#define \
g_signal_connect_object(object,name,func,func_data) \
gtk_signal_connect_object((GtkObject *)object,name,func,(GtkObject*)func_data)
#define \
g_signal_emit_by_name(object,name,data,self) \
gtk_signal_emit_by_name ((GtkObject *)object,name,data,self)
#define \
g_signal_has_handler_pending(object,name,data,may_block) \
gtk_signal_handler_pending ((GtkObject *)object,name,may_block)
#define g_signal_lookup gtk_signal_lookup
#define g_signal_handler_block(o,id) gtk_signal_handler_block ((GtkObject *)(o), id)
#define g_signal_handler_unblock(o,id) gtk_signal_handler_unblock ((GtkObject *)(o), id)
gint* g_signal_list_ids (GType type, guint *n_ids);
// lists
GSList* g_slist_delete_link (GSList *list, GSList *link) __attribute__ ((no_instrument_function));
// arguments/parameters
// first define GValue and GParamSpec
#define GValue GtkArg
#define GParamFlags gint
#define G_VALUE_TYPE(v) ((v)->type)
#define G_PARAM_READWRITE GTK_ARG_READWRITE
#define G_PARAM_READABLE GTK_ARG_READABLE
#define G_PARAM_WRITABLE GTK_ARG_WRITABLE
#define G_OBJECT_WARN_INVALID_PROPERTY_ID(a,b,c)
typedef struct _GParamSpec GParamSpec;
struct _GParamSpec {
gchar *name;
GType value_type;
GParamFlags flags;
};
#define g_value_init(value,t) ((value)->type = (t))
#define g_value_copy(src_val,dest_val) (dest_val = gtk_arg_copy(src_val,dest_val))
#define g_value_unset(val)
#define g_object_class_install_property g2g_object_class_install_property
void g2g_object_class_install_property(GObjectClass *oclass,guint property_id,GParamSpec *pspec);
#define g_object_class_find_property g2g_object_class_find_property
GParamSpec *g2g_object_class_find_property(GObjectClass *oclass,const gchar *name);
#define g_object_class_list_properties g2g_object_class_list_properties
GParamSpec **g2g_object_class_list_properties(GObjectClass *oclass,guint *n_properties);
#define G_IS_PARAM_SPEC_ENUM(pspec) (GTK_FUNDAMENTAL_TYPE(pspec->value_type) == GTK_TYPE_ENUM)
#define g_param_spec_boolean g2g_param_spec_boolean
GParamSpec *g2g_param_spec_boolean(gchar *name,gchar *nick,gchar *blurb,gboolean def,gint flags);
#define g_param_spec_int g2g_param_spec_int
GParamSpec *g2g_param_spec_int(gchar *name,gchar *nick,gchar *blurb,gint min,gint max,gint def,gint flags);
#define g_param_spec_uint g2g_param_spec_uint
GParamSpec *g2g_param_spec_uint(gchar *name,gchar *nick,gchar *blurb,guint min,guint max,guint def,gint flags);
#define g_param_spec_long g2g_param_spec_long
GParamSpec *g2g_param_spec_long(gchar *name,gchar *nick,gchar *blurb,glong min,glong max,glong def,gint flags);
#define g_param_spec_ulong g2g_param_spec_ulong
GParamSpec *g2g_param_spec_ulong(gchar *name,gchar *nick,gchar *blurb,gulong min,gulong max,gulong def,gint flags);
#define g_param_spec_float g2g_param_spec_float
GParamSpec *g2g_param_spec_float(gchar *name,gchar *nick,gchar *blurb,float min,float max,float def,gint flags);
#define g_param_spec_double g2g_param_spec_double
GParamSpec *g2g_param_spec_double(gchar *name,gchar *nick,gchar *blurb,double min,double max,double def,gint flags);
#define g_param_spec_enum g2g_param_spec_enum
GParamSpec *g2g_param_spec_enum(gchar *name,gchar *nick,gchar *blurb,GType e,guint def,gint flags);
#define g_param_spec_pointer g2g_param_spec_pointer
GParamSpec *g2g_param_spec_pointer(gchar *name,gchar *nick,gchar *blurb,gint flags);
#define g_param_spec_string g2g_param_spec_string
GParamSpec *g2g_param_spec_string(gchar *name,gchar *nick,gchar *blurb,gchar *def,gint flags);
#define g_value_get_char(value) GTK_VALUE_CHAR(*value)
#define g_value_set_char(value,data) (GTK_VALUE_CHAR(*value) = (data))
#define g_value_get_uchar(value) GTK_VALUE_UCHAR(*value)
#define g_value_set_uchar(value,data) (GTK_VALUE_UCHAR(*value) = (data))
#define g_value_get_boolean(value) GTK_VALUE_BOOL(*value)
#define g_value_set_boolean(value,data) (GTK_VALUE_BOOL(*value) = (data))
#define g_value_get_enum(value) GTK_VALUE_INT(*value)
#define g_value_set_enum(value,data) (GTK_VALUE_INT(*value) = (data))
#define g_value_get_int(value) GTK_VALUE_INT(*value)
#define g_value_set_int(value,data) (GTK_VALUE_INT(*value) = (data))
#define g_value_get_uint(value) GTK_VALUE_UINT(*value)
#define g_value_set_uint(value,data) (GTK_VALUE_UINT(*value) = (data))
#define g_value_get_long(value) GTK_VALUE_LONG(*value)
#define g_value_set_long(value,data) (GTK_VALUE_LONG(*value) = (data))
#define g_value_get_ulong(value) GTK_VALUE_ULONG(*value)
#define g_value_set_ulong(value,data) (GTK_VALUE_ULONG(*value) = (data))
#define g_value_get_float(value) GTK_VALUE_FLOAT(*value)
#define g_value_set_float(value,data) (GTK_VALUE_FLOAT(*value) = (data))
#define g_value_get_double(value) GTK_VALUE_DOUBLE(*value)
#define g_value_set_double(value,data) (GTK_VALUE_DOUBLE(*value) = (data))
#define g_value_get_string(value) GTK_VALUE_STRING(*value)
#define g_value_set_string(value,data) (GTK_VALUE_STRING(*value) = (data))
#define g_value_get_pointer(value) GTK_VALUE_POINTER(*value)
#define g_value_set_pointer(value,data) (GTK_VALUE_POINTER(*value) = (data))
/* FIXME semi 64-bit support, we map to ulong here... */
#define g_param_spec_int64 g2g_param_spec_ulong
#define g_value_get_int64(value) GTK_VALUE_ULONG(*value)
#define g_value_set_int64(value,data) (GTK_VALUE_ULONG(*value) = (data))
#define G_VALUE_HOLDS_CHAR(value) (((value)->type)==GTK_TYPE_CHAR)
#define G_VALUE_HOLDS_UCHAR(value) (((value)->type)==GTK_TYPE_UCHAR)
#define G_VALUE_HOLDS_BOOLEAN(value) (((value)->type)==GTK_TYPE_BOOL)
#define G_VALUE_HOLDS_INT(value) (((value)->type)==GTK_TYPE_INT)
#define G_VALUE_HOLDS_UINT(value) (((value)->type)==GTK_TYPE_UINT)
#define G_VALUE_HOLDS_LONG(value) (((value)->type)==GTK_TYPE_LONG)
#define G_VALUE_HOLDS_ULONG(value) (((value)->type)==GTK_TYPE_ULONG)
#define G_VALUE_HOLDS_FLOAT(value) (((value)->type)==GTK_TYPE_FLOAT)
#define G_VALUE_HOLDS_DOUBLE(value) (((value)->type)==GTK_TYPE_DOUBLE)
#define G_VALUE_HOLDS_STRING(value) (((value)->type)==GTK_TYPE_STRING)
#define G_VALUE_HOLDS_POINTER(value) (((value)->type)==GTK_TYPE_POINTER)
// the object itself
//#define GObject GtkObject
//#define GObjectClass GtkObjectClass
#define G_OBJECT(obj) ((GObject *)(obj))
#define G_OBJECT_CLASS(c) ((GObjectClass *)(c))
#define G_TYPE_OBJECT \
(g2g_object_get_type())
//#define G_OBJECT(obj)
// (GTK_CHECK_CAST((obj),G_TYPE_OBJECT,GObject))
//#define G_OBJECT_CLASS(klass)
// (GTK_CHECK_CLASS_CAST((klass),G_TYPE_OBJECT,GObjectClass))
#define G_IS_OBJECT(obj) \
(GTK_CHECK_TYPE((obj),G_TYPE_OBJECT))
#define G_IS_OBJECT_CLASS(obj) \
(GTK_CHECK_CLASS_TYPE((klass),G_TYPE_OBJECT))
struct _GObject {
/***** THE FOLLOWING IS A VERBATIM COPY FROM GTKOBJECT *****/
/* GtkTypeObject related fields: */
GObjectClass *klass;
/* 32 bits of flags. GtkObject only uses 4 of these bits and
* GtkWidget uses the rest. This is done because structs are
* aligned on 4 or 8 byte boundaries. If a new bitfield were
* used in GtkWidget much space would be wasted.
*/
guint32 flags;
/* reference count.
* refer to the file docs/refcounting.txt on this issue.
*/
guint ref_count;
/* A list of keyed data pointers, used for e.g. the list of signal
* handlers or an object's user_data.
*/
GData *object_data;
/***** END OF COPY FROM GTKOBJECT *****/
};
struct _GObjectClass {
/***** THE FOLLOWING IS A VERBATIM COPY FROM GTKOBJECT *****/
/* GtkTypeClass fields: */
GtkType type;
/* The signals this object class handles. "signals" is an
* array of signal ID's.
*/
guint *signals;
/* The number of signals listed in "signals".
*/
guint nsignals;
/* The number of arguments per class.
*/
guint n_args;
GSList *construct_args;
/* Non overridable class methods to set and get per class arguments */
void (*set_arg) (GtkObject *object,
GtkArg *arg,
guint arg_id);
void (*get_arg) (GtkObject *object,
GtkArg *arg,
guint arg_id);
/* The functions that will end an objects life time. In one way ore
* another all three of them are defined for all objects. If an
* object class overrides one of the methods in order to perform class
* specific destruction then it must still invoke its superclass'
* implementation of the method after it is finished with its
* own cleanup. (See the destroy function for GtkWidget for
* an example of how to do this).
*/
void (* dispose) (GObject *object);
void (* destroy) (GObject *object);
void (* finalize) (GObject *object);
/***** END OF COPY FROM GTKOBJECT *****/
void (*set_property) (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec);
void (*get_property) (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec);
};
GType g_object_get_type (void);
#endif /* __GOBJECT_2_GTK_H__ */
Reference in a new issue View git blame Copy permalink