static void
adg_gtk_area_class_init(AdgGtkAreaClass *klass)
{
GObjectClass *gobject_class;
GtkWidgetClass *widget_class;
GParamSpec *param;
gobject_class = (GObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
g_type_class_add_private(klass, sizeof(AdgGtkAreaPrivate));
gobject_class->dispose = _adg_dispose;
gobject_class->get_property = _adg_get_property;
gobject_class->set_property = _adg_set_property;
#ifdef GTK2_ENABLED
widget_class->size_request = _adg_size_request;
widget_class->expose_event = _adg_expose_event;
#endif
#ifdef GTK3_ENABLED
widget_class->get_preferred_height = _adg_get_preferred_height;
widget_class->get_preferred_height_for_width = _adg_get_preferred_height_for_width;
widget_class->get_preferred_width = _adg_get_preferred_width;
widget_class->get_preferred_width_for_height = _adg_get_preferred_width_for_height;
widget_class->draw = _adg_draw;
#endif
widget_class->size_allocate = _adg_size_allocate;
widget_class->scroll_event = _adg_scroll_event;
widget_class->button_press_event = _adg_button_press_event;
widget_class->motion_notify_event = _adg_motion_notify_event;
klass->canvas_changed = _adg_canvas_changed;
param = g_param_spec_object("canvas",
P_("Canvas"),
P_("The canvas to be shown"),
ADG_TYPE_CANVAS,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
g_object_class_install_property(gobject_class, PROP_CANVAS, param);
param = g_param_spec_double("factor",
P_("Factor"),
P_("The factor to use while zooming in and out (usually with the mouse wheel)"),
1., G_MAXDOUBLE, 1.05,
G_PARAM_READWRITE);
g_object_class_install_property(gobject_class, PROP_FACTOR, param);
param = g_param_spec_boolean("autozoom",
P_("Autozoom"),
P_("When enabled, automatically adjust the zoom in global space at every size allocation"),
FALSE,
G_PARAM_READWRITE);
g_object_class_install_property(gobject_class, PROP_AUTOZOOM, param);
param = g_param_spec_boxed("render-map",
P_("Render Map"),
P_("The transformation to be applied on the canvas before rendering it"),
CAIRO_GOBJECT_TYPE_MATRIX,
G_PARAM_READWRITE);
g_object_class_install_property(gobject_class, PROP_RENDER_MAP, param);
/**
* AdgGtkArea::canvas-changed:
* @area: an #AdgGtkArea
* @old_canvas: (type AdgCanvas*): the old #AdgCanvas object
*
* Emitted after the canvas bound to @area has been changed. The old
* canvas accessible from @old_canvas while the new canvas can be got
* with the usual API, e.g. adg_gtk_area_get_canvas().
*
* Since: 1.0
**/
_adg_signals[CANVAS_CHANGED] =
g_signal_new("canvas-changed", ADG_GTK_TYPE_AREA,
G_SIGNAL_RUN_LAST|G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET(AdgGtkAreaClass, canvas_changed),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, ADG_TYPE_CANVAS);
/**
* AdgGtkArea::extents-changed:
* @area: an #AdgGtkArea
* @old_extents: the old #CpmlExtents struct
*
* Emitted when the extents of @area have been changed.
* The old extents are always compared to the new ones,
* so when the extents are recalculated but the result
* is the same the signal is not emitted.
*
* The extents of #AdgGtkArea are subject to the render
* map, so changing the #AdgGtkArea:render-map property
* will emit this signal too.
*
* Since: 1.0
**/
_adg_signals[EXTENTS_CHANGED] =
g_signal_new("extents-changed", ADG_GTK_TYPE_AREA,
G_SIGNAL_RUN_LAST|G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET(AdgGtkAreaClass, extents_changed),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_POINTER);
}
{
GtkObjectClass *object_class;
GObjectClass *gobject_class;
GtkWidgetClass *widget_class;
GtkButtonClass *button_class;
object_class = (GtkObjectClass *) class;
gobject_class = (GObjectClass *) class;
button_class = (GtkButtonClass *) class;
widget_class = (GtkWidgetClass *) class;
color_picker_signals[COLOR_SET] =
g_signal_new ("color_set",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MateColorPickerClass, color_set),
NULL, NULL,
_mate_marshal_VOID__UINT_UINT_UINT_UINT,
G_TYPE_NONE, 4,
G_TYPE_UINT,
G_TYPE_UINT,
G_TYPE_UINT,
G_TYPE_UINT);
gobject_class->get_property = mate_color_picker_get_property;
gobject_class->set_property = mate_color_picker_set_property;
g_object_class_install_property
(gobject_class,
PROP_DITHER,
g_param_spec_boolean ("dither", NULL,
static MonoMethod*
create_allocator (int atype, int offset)
{
int index_var, bytes_var, my_fl_var, my_entry_var;
guint32 no_freelist_branch, not_small_enough_branch = 0;
guint32 size_overflow_branch = 0;
MonoMethodBuilder *mb;
MonoMethod *res;
MonoMethodSignature *csig;
AllocatorWrapperInfo *info;
if (atype == ATYPE_STRING) {
csig = mono_metadata_signature_alloc (mono_defaults.corlib, 2);
csig->ret = &mono_defaults.string_class->byval_arg;
csig->params [0] = &mono_defaults.int_class->byval_arg;
csig->params [1] = &mono_defaults.int32_class->byval_arg;
} else {
csig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
csig->ret = &mono_defaults.object_class->byval_arg;
csig->params [0] = &mono_defaults.int_class->byval_arg;
}
mb = mono_mb_new (mono_defaults.object_class, "Alloc", MONO_WRAPPER_ALLOC);
bytes_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
if (atype == ATYPE_STRING) {
/* a string alloator method takes the args: (vtable, len) */
/* bytes = (sizeof (MonoString) + ((len + 1) * 2)); */
mono_mb_emit_ldarg (mb, 1);
mono_mb_emit_icon (mb, 1);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_icon (mb, 1);
mono_mb_emit_byte (mb, MONO_CEE_SHL);
// sizeof (MonoString) might include padding
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, chars));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, bytes_var);
} else {
/* bytes = vtable->klass->instance_size */
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoVTable, klass));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoClass, instance_size));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
/* FIXME: assert instance_size stays a 4 byte integer */
mono_mb_emit_byte (mb, MONO_CEE_LDIND_U4);
mono_mb_emit_stloc (mb, bytes_var);
}
/* this is needed for strings/arrays only as the other big types are never allocated with this method */
if (atype == ATYPE_STRING) {
/* check for size */
/* if (!SMALL_ENOUGH (bytes)) jump slow_path;*/
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_icon (mb, (NFREELISTS-1) * GRANULARITY);
not_small_enough_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BGT_UN_S);
/* check for overflow */
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_icon (mb, sizeof (MonoString));
size_overflow_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLE_UN_S);
}
/* int index = INDEX_FROM_BYTES(bytes); */
index_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_icon (mb, GRANULARITY - 1);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_icon (mb, shift_amount (GRANULARITY));
mono_mb_emit_byte (mb, MONO_CEE_SHR_UN);
mono_mb_emit_icon (mb, shift_amount (sizeof (gpointer)));
mono_mb_emit_byte (mb, MONO_CEE_SHL);
/* index var is already adjusted into bytes */
mono_mb_emit_stloc (mb, index_var);
my_fl_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
my_entry_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
/* my_fl = ((GC_thread)tsd) -> ptrfree_freelists + index; */
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
mono_mb_emit_byte (mb, 0x0D); /* CEE_MONO_TLS */
mono_mb_emit_i4 (mb, offset);
if (atype == ATYPE_FREEPTR || atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING)
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, ptrfree_freelists));
else if (atype == ATYPE_NORMAL)
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, normal_freelists));
else if (atype == ATYPE_GCJ)
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, gcj_freelists));
else
g_assert_not_reached ();
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, my_fl_var);
/* my_entry = *my_fl; */
mono_mb_emit_ldloc (mb, my_fl_var);
mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
mono_mb_emit_stloc (mb, my_entry_var);
/* if (EXPECT((word)my_entry >= HBLKSIZE, 1)) { */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_icon (mb, HBLKSIZE);
no_freelist_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLT_UN_S);
/* ptr_t next = obj_link(my_entry); *my_fl = next; */
mono_mb_emit_ldloc (mb, my_fl_var);
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
/* set the vtable and clear the words in the object */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
if (atype == ATYPE_FREEPTR) {
int start_var, end_var, start_loop;
/* end = my_entry + bytes; start = my_entry + sizeof (gpointer);
*/
start_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
end_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, end_var);
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, start_var);
/*
* do {
* *start++ = NULL;
* } while (start < end);
*/
start_loop = mono_mb_get_label (mb);
mono_mb_emit_ldloc (mb, start_var);
mono_mb_emit_icon (mb, 0);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
mono_mb_emit_ldloc (mb, start_var);
mono_mb_emit_icon (mb, sizeof (gpointer));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, start_var);
mono_mb_emit_ldloc (mb, start_var);
mono_mb_emit_ldloc (mb, end_var);
mono_mb_emit_byte (mb, MONO_CEE_BLT_UN_S);
mono_mb_emit_byte (mb, start_loop - (mono_mb_get_label (mb) + 1));
} else if (atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING) {
/* need to clear just the sync pointer */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_icon (mb, 0);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
}
if (atype == ATYPE_STRING) {
/* need to set length and clear the last char */
/* s->length = len; */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, length));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_ldarg (mb, 1);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I4);
/* s->chars [len] = 0; */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_icon (mb, 2);
mono_mb_emit_byte (mb, MONO_CEE_SUB);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_icon (mb, 0);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I2);
}
/* return my_entry; */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_byte (mb, MONO_CEE_RET);
mono_mb_patch_short_branch (mb, no_freelist_branch);
if (not_small_enough_branch > 0)
mono_mb_patch_short_branch (mb, not_small_enough_branch);
if (size_overflow_branch > 0)
mono_mb_patch_short_branch (mb, size_overflow_branch);
/* the slow path: we just call back into the runtime */
if (atype == ATYPE_STRING) {
mono_mb_emit_ldarg (mb, 1);
mono_mb_emit_icall (mb, mono_string_alloc);
} else {
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_icall (mb, mono_object_new_specific);
}
mono_mb_emit_byte (mb, MONO_CEE_RET);
res = mono_mb_create_method (mb, csig, 8);
mono_mb_free (mb);
mono_method_get_header (res)->init_locals = FALSE;
info = mono_image_alloc0 (mono_defaults.corlib, sizeof (AllocatorWrapperInfo));
info->gc_name = "boehm";
info->alloc_type = atype;
mono_marshal_set_wrapper_info (res, info);
return res;
}
static void
gv_layer_class_init(GvLayerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
layer_signals[SETUP] =
g_signal_new ("setup",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GvLayerClass, setup),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
layer_signals[TEARDOWN] =
g_signal_new ("teardown",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GvLayerClass, teardown),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
layer_signals[DRAW] =
g_signal_new ("draw",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GvLayerClass, draw),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
layer_signals[EXTENTS_REQUEST] =
g_signal_new ("get_extents",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GvLayerClass, extents_request),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
layer_signals[DISPLAY_CHANGE] =
g_signal_new ("display-change",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GvLayerClass, display_change),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,
G_TYPE_POINTER);
object_class->finalize = gv_layer_finalize;
klass->setup = NULL;
klass->teardown = NULL;
klass->draw = NULL;
klass->extents_request = NULL;
klass->reproject = NULL;
klass->display_change = NULL;
}
static void spice_usb_device_widget_class_init(
SpiceUsbDeviceWidgetClass *klass)
{
GObjectClass *gobject_class = (GObjectClass *)klass;
GParamSpec *pspec;
g_type_class_add_private (klass, sizeof (SpiceUsbDeviceWidgetPrivate));
gobject_class->constructor = spice_usb_device_widget_constructor;
gobject_class->finalize = spice_usb_device_widget_finalize;
gobject_class->get_property = spice_usb_device_widget_get_property;
gobject_class->set_property = spice_usb_device_widget_set_property;
/**
* SpiceUsbDeviceWidget:session:
*
* #SpiceSession this #SpiceUsbDeviceWidget is associated with
*
**/
pspec = g_param_spec_object("session",
"Session",
"SpiceSession",
SPICE_TYPE_SESSION,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
g_object_class_install_property(gobject_class, PROP_SESSION, pspec);
/**
* SpiceUsbDeviceWidget:device-format-string:
*
* Format string to pass to spice_usb_device_get_description() for getting
* the device USB descriptions.
*/
pspec = g_param_spec_string("device-format-string",
"Device format string",
"Format string for device description",
NULL,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
g_object_class_install_property(gobject_class, PROP_DEVICE_FORMAT_STRING,
pspec);
/**
* SpiceUsbDeviceWidget::connect-failed:
* @widget: The #SpiceUsbDeviceWidget that emitted the signal
* @device: #SpiceUsbDevice boxed object corresponding to the added device
* @error: #GError describing the reason why the connect failed
*
* The #SpiceUsbDeviceWidget::connect-failed signal is emitted whenever
* the user has requested for a device to be redirected and this has
* failed.
**/
signals[CONNECT_FAILED] =
g_signal_new("connect-failed",
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(SpiceUsbDeviceWidgetClass, connect_failed),
NULL, NULL,
g_cclosure_user_marshal_VOID__BOXED_BOXED,
G_TYPE_NONE,
2,
SPICE_TYPE_USB_DEVICE,
G_TYPE_ERROR);
}
static void
rb_player_gst_class_init (RBPlayerGstClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = impl_dispose;
object_class->get_property = impl_get_property;
object_class->set_property = impl_set_property;
g_object_class_install_property (object_class,
PROP_PLAYBIN,
g_param_spec_object ("playbin",
"playbin",
"playbin element",
GST_TYPE_ELEMENT,
G_PARAM_READABLE));
g_object_class_install_property (object_class,
PROP_BUS,
g_param_spec_object ("bus",
"bus",
"GStreamer message bus",
GST_TYPE_BUS,
G_PARAM_READABLE));
g_object_class_install_property (object_class,
PROP_BUFFER_SIZE,
g_param_spec_uint ("buffer-size",
"buffer size",
"Buffer size for network streams, in kB",
64, MAX_NETWORK_BUFFER_SIZE, 128,
G_PARAM_READWRITE));
signals[PREPARE_SOURCE] =
g_signal_new ("prepare-source",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (RBPlayerGstClass, prepare_source),
NULL, NULL,
rb_marshal_VOID__STRING_OBJECT,
G_TYPE_NONE,
2,
G_TYPE_STRING, GST_TYPE_ELEMENT);
signals[CAN_REUSE_STREAM] =
g_signal_new ("can-reuse-stream",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (RBPlayerGstClass, can_reuse_stream),
NULL, NULL,
rb_marshal_BOOLEAN__STRING_STRING_OBJECT,
G_TYPE_BOOLEAN,
3,
G_TYPE_STRING, G_TYPE_STRING, GST_TYPE_ELEMENT);
signals[REUSE_STREAM] =
g_signal_new ("reuse-stream",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (RBPlayerGstClass, reuse_stream),
NULL, NULL,
rb_marshal_VOID__STRING_STRING_OBJECT,
G_TYPE_NONE,
3,
G_TYPE_STRING, G_TYPE_STRING, GST_TYPE_ELEMENT);
signals[MISSING_PLUGINS] =
g_signal_new ("missing-plugins",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
0, /* no point handling this internally */
NULL, NULL,
rb_marshal_VOID__POINTER_POINTER_POINTER,
G_TYPE_NONE,
3,
G_TYPE_POINTER, G_TYPE_STRV, G_TYPE_STRV);
g_type_class_add_private (klass, sizeof (RBPlayerGstPrivate));
}
static void
st_widget_class_init (StWidgetClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
GParamSpec *pspec;
g_type_class_add_private (klass, sizeof (StWidgetPrivate));
gobject_class->set_property = st_widget_set_property;
gobject_class->get_property = st_widget_get_property;
gobject_class->dispose = st_widget_dispose;
gobject_class->finalize = st_widget_finalize;
actor_class->get_preferred_width = st_widget_get_preferred_width;
actor_class->get_preferred_height = st_widget_get_preferred_height;
actor_class->allocate = st_widget_allocate;
actor_class->paint = st_widget_paint;
actor_class->parent_set = st_widget_parent_set;
actor_class->map = st_widget_map;
actor_class->unmap = st_widget_unmap;
actor_class->enter_event = st_widget_enter;
actor_class->leave_event = st_widget_leave;
actor_class->hide = st_widget_hide;
klass->style_changed = st_widget_real_style_changed;
/**
* StWidget:pseudo-class:
*
* The pseudo-class of the actor. Typical values include "hover", "active",
* "focus".
*/
g_object_class_install_property (gobject_class,
PROP_PSEUDO_CLASS,
g_param_spec_string ("pseudo-class",
"Pseudo Class",
"Pseudo class for styling",
"",
ST_PARAM_READWRITE));
/**
* StWidget:style-class:
*
* The style-class of the actor for use in styling.
*/
g_object_class_install_property (gobject_class,
PROP_STYLE_CLASS,
g_param_spec_string ("style-class",
"Style Class",
"Style class for styling",
"",
ST_PARAM_READWRITE));
/**
* StWidget:style:
*
* Inline style information for the actor as a ';'-separated list of
* CSS properties.
*/
g_object_class_install_property (gobject_class,
PROP_STYLE,
g_param_spec_string ("style",
"Style",
"Inline style string",
"",
ST_PARAM_READWRITE));
/**
* StWidget:theme
*
* A theme set on this actor overriding the global theming for this actor
* and its descendants
*/
g_object_class_install_property (gobject_class,
PROP_THEME,
g_param_spec_object ("theme",
"Theme",
"Theme override",
ST_TYPE_THEME,
ST_PARAM_READWRITE));
/**
* StWidget:stylable:
*
* Enable or disable styling of the widget
*/
pspec = g_param_spec_boolean ("stylable",
"Stylable",
"Whether the table should be styled",
TRUE,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_STYLABLE,
pspec);
/**
* StWidget:has-tooltip:
*
* Determines whether the widget has a tooltip. If set to %TRUE, causes the
* widget to monitor hover state (i.e. sets #ClutterActor:reactive and
* #StWidget:track-hover).
*/
pspec = g_param_spec_boolean ("has-tooltip",
"Has Tooltip",
"Determines whether the widget has a tooltip",
FALSE,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_HAS_TOOLTIP,
pspec);
/**
* StWidget:tooltip-text:
*
* text displayed on the tooltip
*/
pspec = g_param_spec_string ("tooltip-text",
"Tooltip Text",
"Text displayed on the tooltip",
"",
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_TOOLTIP_TEXT, pspec);
/**
* StWidget:track-hover:
*
* Determines whether the widget tracks pointer hover state. If
* %TRUE (and the widget is visible and reactive), the
* #StWidget:hover property and "hover" style pseudo class will be
* adjusted automatically as the pointer moves in and out of the
* widget.
*/
pspec = g_param_spec_boolean ("track-hover",
"Track hover",
"Determines whether the widget tracks hover state",
FALSE,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_TRACK_HOVER,
pspec);
/**
* StWidget:hover:
*
* Whether or not the pointer is currently hovering over the widget. This is
* only tracked automatically if #StWidget:track-hover is %TRUE, but you can
* adjust it manually in any case.
*/
pspec = g_param_spec_boolean ("hover",
"Hover",
"Whether the pointer is hovering over the widget",
FALSE,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_HOVER,
pspec);
/**
* StWidget::style-changed:
*
* Emitted when the style information that the widget derives from the
* theme changes
*/
signals[STYLE_CHANGED] =
g_signal_new ("style-changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (StWidgetClass, style_changed),
NULL, NULL,
_st_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
* <xs:complexType name="ReferenceParametersType" mixed="false">
* <xs:sequence>
* <xs:any namespace="##any" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
* </xs:sequence>
* <xs:anyAttribute namespace="##other" processContents="lax"/>
* </xs:complexType>
*/
/*****************************************************************************/
/* private methods */
/*****************************************************************************/
static struct XmlSnippet schema_snippets[] = {
{ "", SNIPPET_LIST_NODES | SNIPPET_ANY,
G_STRUCT_OFFSET(LassoWsAddrReferenceParameters, any), NULL, NULL, NULL},
{ "attributes", SNIPPET_ATTRIBUTE | SNIPPET_ANY,
G_STRUCT_OFFSET(LassoWsAddrReferenceParameters, attributes), NULL, NULL, NULL},
{NULL, 0, 0, NULL, NULL, NULL}
};
static LassoNodeClass *parent_class = NULL;
/*****************************************************************************/
/* instance and class init functions */
/*****************************************************************************/
static void
instance_init(LassoWsAddrReferenceParameters *node)
{
static void
clutter_canvas_class_init (ClutterCanvasClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
/**
* ClutterCanvas:width:
*
* The width of the canvas.
*
* Since: 1.10
*/
obj_props[PROP_WIDTH] =
g_param_spec_int ("width",
P_("Width"),
P_("The width of the canvas"),
-1, G_MAXINT,
-1,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* ClutterCanvas:height:
*
* The height of the canvas.
*
* Since: 1.10
*/
obj_props[PROP_HEIGHT] =
g_param_spec_int ("height",
P_("Height"),
P_("The height of the canvas"),
-1, G_MAXINT,
-1,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* ClutterCanvas:scale-factor-set:
*
* Whether the #ClutterCanvas:scale-factor property is set.
*
* If the #ClutterCanvas:scale-factor-set property is %FALSE
* then #ClutterCanvas will use the #ClutterSettings:window-scaling-factor
* property.
*
* Since: 1.18
*/
obj_props[PROP_SCALE_FACTOR_SET] =
g_param_spec_boolean ("scale-factor-set",
P_("Scale Factor Set"),
P_("Whether the scale-factor property is set"),
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* ClutterCanvas:scale-factor:
*
* The scaling factor to be applied to the Cairo surface used for
* drawing.
*
* If #ClutterCanvas:scale-factor is set to a negative value, the
* value of the #ClutterSettings:window-scaling-factor property is
* used instead.
*
* Use #ClutterCanvas:scale-factor-set to check if the scale factor
* is set.
*
* Since: 1.18
*/
obj_props[PROP_SCALE_FACTOR] =
g_param_spec_int ("scale-factor",
P_("Scale Factor"),
P_("The scaling factor for the surface"),
-1, 1000,
-1,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* ClutterCanvas::draw:
* @canvas: the #ClutterCanvas that emitted the signal
* @cr: the Cairo context used to draw
* @width: the width of the @canvas
* @height: the height of the @canvas
*
* The #ClutterCanvas::draw signal is emitted each time a canvas is
* invalidated.
*
* It is safe to connect multiple handlers to this signal: each
* handler invocation will be automatically protected by cairo_save()
* and cairo_restore() pairs.
*
* Return value: %TRUE if the signal emission should stop, and
* %FALSE otherwise
*
* Since: 1.10
*/
canvas_signals[DRAW] =
g_signal_new (I_("draw"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (ClutterCanvasClass, draw),
_clutter_boolean_handled_accumulator, NULL,
clutter_cairo_context_draw_marshaller,
G_TYPE_BOOLEAN, 3,
CAIRO_GOBJECT_TYPE_CONTEXT,
G_TYPE_INT,
G_TYPE_INT);
gobject_class->set_property = clutter_canvas_set_property;
gobject_class->get_property = clutter_canvas_get_property;
gobject_class->finalize = clutter_canvas_finalize;
g_object_class_install_properties (gobject_class, LAST_PROP, obj_props);
}
static void
st_adjustment_class_init (StAdjustmentClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (StAdjustmentPrivate));
object_class->constructed = st_adjustment_constructed;
object_class->get_property = st_adjustment_get_property;
object_class->set_property = st_adjustment_set_property;
g_object_class_install_property (object_class,
PROP_LOWER,
g_param_spec_double ("lower",
"Lower",
"Lower bound",
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
ST_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class,
PROP_UPPER,
g_param_spec_double ("upper",
"Upper",
"Upper bound",
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
ST_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class,
PROP_VALUE,
g_param_spec_double ("value",
"Value",
"Current value",
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
ST_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class,
PROP_STEP_INC,
g_param_spec_double ("step-increment",
"Step Increment",
"Step increment",
0.0,
G_MAXDOUBLE,
0.0,
ST_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class,
PROP_PAGE_INC,
g_param_spec_double ("page-increment",
"Page Increment",
"Page increment",
0.0,
G_MAXDOUBLE,
0.0,
ST_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class,
PROP_PAGE_SIZE,
g_param_spec_double ("page-size",
"Page Size",
"Page size",
0.0,
G_MAXDOUBLE,
0.0,
ST_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
/**
* StAdjustment::changed:
* @self: the #StAdjustment
*
* Emitted when any of the adjustment values have changed
*/
signals[CHANGED] =
g_signal_new ("changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (StAdjustmentClass, changed),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
}
static void
gnome_druid_class_init (GnomeDruidClass *klass)
{
GtkObjectClass *object_class;
GObjectClass *gobject_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
object_class = (GtkObjectClass*) klass;
gobject_class = (GObjectClass*) klass;
widget_class = (GtkWidgetClass*) klass;
container_class = (GtkContainerClass*) klass;
druid_signals[CANCEL] =
g_signal_new ("cancel",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GnomeDruidClass, cancel),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
druid_signals[HELP] =
g_signal_new ("help",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GnomeDruidClass, help),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
object_class->destroy = gnome_druid_destroy;
gobject_class->set_property = gnome_druid_set_property;
gobject_class->get_property = gnome_druid_get_property;
gobject_class->finalize = gnome_druid_finalize;
widget_class->size_request = gnome_druid_size_request;
widget_class->size_allocate = gnome_druid_size_allocate;
widget_class->map = gnome_druid_map;
widget_class->unmap = gnome_druid_unmap;
widget_class->expose_event = gnome_druid_expose;
widget_class->get_accessible = gnome_druid_get_accessible;
container_class->forall = gnome_druid_forall;
container_class->add = gnome_druid_add;
container_class->remove = gnome_druid_remove;
container_class->child_type = gnome_druid_child_type;
g_object_class_install_property (gobject_class,
PROP_SHOW_FINISH,
g_param_spec_boolean ("show_finish",
_("Show Finish"),
_("Show the 'Finish' button instead of the 'Next' button"),
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHOW_HELP,
g_param_spec_boolean ("show_help",
_("Show Help"),
_("Show the 'Help' button"),
FALSE,
G_PARAM_READWRITE));
}
CORBA_unsigned_long
giop_recv_buffer_get_request_id (GIOPRecvBuffer *buf)
{
static const glong reqid_offsets [GIOP_NUM_MSG_TYPES] [GIOP_NUM_VERSIONS] = {
/* GIOP_REQUEST */
{ G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.request_1_0.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.request_1_1.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.request_1_2.request_id)},
/* GIOP_REPLY */
{ G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.reply_1_0.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.reply_1_1.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.reply_1_2.request_id)},
/* GIOP_CANCELREQUEST */
{ G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.cancel_request.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.cancel_request.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.cancel_request.request_id)},
/* GIOP_LOCATEREQUEST */
{ G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.locate_request_1_0.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.locate_request_1_1.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.locate_request_1_2.request_id)},
/* GIOP_LOCATEREPLY */
{ G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.locate_reply_1_0.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.locate_reply_1_1.request_id),
G_STRUCT_OFFSET(GIOPRecvBuffer,
msg.u.locate_reply_1_2.request_id)},
{0,0,0}, /* GIOP_CLOSECONNECTION */
{0,0,0}, /* GIOP_MESSAGEERROR */
{0,0,0} /* GIOP_FRAGMENT */
};
gulong offset;
offset = reqid_offsets [buf->msg.header.message_type] [buf->giop_version];
if (!offset)
return 0;
return G_STRUCT_MEMBER (CORBA_unsigned_long, buf, offset);
}
static void
inf_xml_connection_default_init(InfXmlConnectionInterface* iface)
{
/**
* InfXmlConnection::sent:
* @connection: The #InfXmlConnection through which @node has been sent
* @node: An #xmlNodePtr referring to the XML node that has been sent
*
* Signal which is emitted when an XML node has been successfully
* transmitted with this connection.
*/
connection_signals[SENT] = g_signal_new(
"sent",
INF_TYPE_XML_CONNECTION,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(InfXmlConnectionInterface, sent),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE,
1,
G_TYPE_POINTER
);
/**
* InfXmlConnection::received:
* @connection: The #InfXmlConnection through which @node has been received
* @node: An #xmlNodePtr referring to the XML node that has been received
*
* Signal which is emitted when an XML node has been received by this
* connection.
*/
connection_signals[RECEIVED] = g_signal_new(
"received",
INF_TYPE_XML_CONNECTION,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(InfXmlConnectionInterface, received),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE,
1,
G_TYPE_POINTER
);
/**
* InfXmlConnection::error:
* @connection: The erroneous #InfXmlConnection
* @error: A pointer to a #GError object with details on the error
*
* This signal is emitted when an error occurs for this connection.
* For example, if the connection cannot be established and the status
* changes from %INF_XML_CONNECTION_OPENING to %INF_XML_CONNECTION_CLOSED,
* then this signal is usually emitted with more details on the error.
*
* Note however that the error may or may not be fatal for the
* connection. If it is fatal, then a status notify to
* %INF_XML_CONNECTION_CLOSING or %INF_XML_CONNECTION_CLOSED will follow.
*/
connection_signals[ERROR] = g_signal_new(
"error",
INF_TYPE_XML_CONNECTION,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(InfXmlConnectionInterface, error),
NULL, NULL,
g_cclosure_marshal_VOID__BOXED,
G_TYPE_NONE,
1,
G_TYPE_ERROR
);
g_object_interface_install_property(
iface,
g_param_spec_enum(
"status",
"XmlConnection Status",
"The status of the connection.",
INF_TYPE_XML_CONNECTION_STATUS,
INF_XML_CONNECTION_CLOSED,
G_PARAM_READABLE
)
);
/* The network of a connection should not change through lifetime. All
* users on a given network should be able to create direct connections
* between each user. For example, 'jabber' might be such a network,
* 'local' another one. All jabber user can have connections to other
* jabber users, but not to those on a local network. */
g_object_interface_install_property(
iface,
g_param_spec_string(
"network",
"Network",
"An identifier for the type of network this connection is on",
NULL,
G_PARAM_READABLE
)
);
g_object_interface_install_property(
iface,
g_param_spec_string(
"local-id",
"Local ID",
"A unique identification on the network for the local site",
NULL,
G_PARAM_READABLE
)
);
g_object_interface_install_property(
iface,
g_param_spec_string(
"remote-id",
"Remote ID",
"A unique identification on the network for the remote site",
NULL,
G_PARAM_READABLE
)
);
g_object_interface_install_property(
iface,
g_param_spec_pointer(
"local-certificate",
"Local Certificate",
"The X.509 certificate (gnutls_x509_crt_t) of the local site",
G_PARAM_READABLE
)
);
g_object_interface_install_property(
iface,
g_param_spec_boxed(
"remote-certificate",
"Remote Certificate",
"The X.509 certificate of the remote site",
INF_TYPE_CERTIFICATE_CHAIN,
G_PARAM_READABLE
)
);
}
void
ags_port_class_init(AgsPortClass *port)
{
GObjectClass *gobject;
GParamSpec *param_spec;
ags_port_parent_class = g_type_class_peek_parent(port);
/* GObjectClass */
gobject = (GObjectClass *) port;
gobject->set_property = ags_port_set_property;
gobject->get_property = ags_port_get_property;
/* properties */
/**
* AgsPort:plugin-name:
*
* The assigned plugin.
*
* Since: 0.4.0
*/
param_spec = g_param_spec_string("plugin-name\0",
"plugin-name of port\0",
"The plugin-name this port belongs to\0",
NULL,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_PLUGIN_NAME,
param_spec);
/**
* AgsPort:specifier:
*
* The assigned plugin identifier.
*
* Since: 0.4.0
*/
param_spec = g_param_spec_string("specifier\0",
"specifier of port\0",
"The specifier this port is identified by\0",
NULL,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_SPECIFIER,
param_spec);
/**
* AgsPort:control-port:
*
* The assigned plugin control port.
*
* Since: 0.4.0
*/
param_spec = g_param_spec_string("control-port\0",
"control-port of port\0",
"The control-port this port is numbered\0",
NULL,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_CONTROL_PORT,
param_spec);
/**
* AgsPort:port-value-is-pointer:
*
* Specify port data as pointer.
*
* Since: 0.4.0
*/
param_spec = g_param_spec_boolean("port-value-is-pointer\0",
"port-value-is-pointer indicates if value is a pointer\0",
"The port-value-is-pointer indicates if value is a pointer\0",
FALSE,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_PORT_VALUE_IS_POINTER,
param_spec);
/**
* AgsPort:port-value-type:
*
* The port's data type.
*
* Since: 0.4.0
*/
param_spec = g_param_spec_gtype("port-value-type\0",
"port-value-type tells you the type of the values\0",
"The port-value-type tells you the type of the values\0",
G_TYPE_NONE,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_PORT_VALUE_TYPE,
param_spec);
/**
* AgsPort:port-value-size:
*
* The port's data type size.
*
* Since: 0.4.0
*/
param_spec = g_param_spec_uint("port-value-size\0",
"port-value-size is the size of a single entry\0",
"The port-value-size is the size of a single entry\0",
1, 8,
sizeof(gdouble),
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_PORT_VALUE_SIZE,
param_spec);
/**
* AgsPort:port-value-length:
*
* The port's data array length.
*
* Since: 0.4.0
*/
param_spec = g_param_spec_uint("port-value-length\0",
"port-value-length is the array size\0",
"The port-value-length is the array size\0",
0, 65535,
1,
G_PARAM_READABLE | G_PARAM_WRITABLE);
g_object_class_install_property(gobject,
PROP_PORT_VALUE_LENGTH,
param_spec);
/* AgsPortClass */
port->safe_read = ags_port_real_safe_read;
port->safe_write = ags_port_real_safe_write;
port->safe_get_property = ags_port_real_safe_get_property;
port->safe_set_property = ags_port_real_safe_set_property;
/* signals */
/**
* AgsPort::safe-read:
* @port: the object providing safe read
*
* The ::safe-read signal is emited while doing safe read operation.
*/
port_signals[SAFE_READ] =
g_signal_new("safe-read\0",
G_TYPE_FROM_CLASS (port),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (AgsPortClass, safe_read),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
/**
* AgsPort::safe-write:
* @port: the object providing safe write
*
* The ::safe-write signal is emited while doing safe write operation.
*/
port_signals[SAFE_WRITE] =
g_signal_new("safe-write\0",
G_TYPE_FROM_CLASS (port),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (AgsPortClass, safe_write),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
/**
* AgsPort::safe-get-property:
* @port: the object providing safe get property
*
* The ::safe-get-property signal is emited while safe get property.
*/
port_signals[SAFE_GET_PROPERTY] =
g_signal_new("safe-get-property\0",
G_TYPE_FROM_CLASS (port),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (AgsPortClass, safe_get_property),
NULL, NULL,
g_cclosure_user_marshal_VOID__STRING_POINTER,
G_TYPE_NONE, 2,
G_TYPE_STRING, G_TYPE_POINTER);
/**
* AgsPort::safe-set-property:
* @port: the object providing safe set property
*
* The ::safe-set-property signal is emited while safe set property.
*/
port_signals[SAFE_SET_PROPERTY] =
g_signal_new("safe-set-property\0",
G_TYPE_FROM_CLASS (port),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (AgsPortClass, safe_set_property),
NULL, NULL,
g_cclosure_user_marshal_VOID__STRING_POINTER,
G_TYPE_NONE, 2,
G_TYPE_STRING, G_TYPE_POINTER);
}
static void
gst_app_sink_class_init (GstAppSinkClass * klass)
{
GObjectClass *gobject_class = (GObjectClass *) klass;
GstElementClass *element_class = (GstElementClass *) klass;
GstBaseSinkClass *basesink_class = (GstBaseSinkClass *) klass;
GST_DEBUG_CATEGORY_INIT (app_sink_debug, "appsink", 0, "appsink element");
gobject_class->dispose = gst_app_sink_dispose;
gobject_class->finalize = gst_app_sink_finalize;
gobject_class->set_property = gst_app_sink_set_property;
gobject_class->get_property = gst_app_sink_get_property;
g_object_class_install_property (gobject_class, PROP_CAPS,
g_param_spec_boxed ("caps", "Caps",
"The allowed caps for the sink pad", GST_TYPE_CAPS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_EOS,
g_param_spec_boolean ("eos", "EOS",
"Check if the sink is EOS or not started", DEFAULT_PROP_EOS,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_EMIT_SIGNALS,
g_param_spec_boolean ("emit-signals", "Emit signals",
"Emit new-preroll and new-sample signals",
DEFAULT_PROP_EMIT_SIGNALS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_MAX_BUFFERS,
g_param_spec_uint ("max-buffers", "Max Buffers",
"The maximum number of buffers to queue internally (0 = unlimited)",
0, G_MAXUINT, DEFAULT_PROP_MAX_BUFFERS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_DROP,
g_param_spec_boolean ("drop", "Drop",
"Drop old buffers when the buffer queue is filled", DEFAULT_PROP_DROP,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSink::wait-on-eos:
*
* Wait for all buffers to be processed after receiving an EOS.
*
* In cases where it is uncertain if an @appsink will have a consumer for its buffers
* when it receives an EOS, set to %FALSE to ensure that the @appsink will not hang.
*
* Since: 1.8
*/
g_object_class_install_property (gobject_class, PROP_WAIT_ON_EOS,
g_param_spec_boolean ("wait-on-eos", "Wait on EOS",
"Wait for all buffers to be processed after receiving an EOS",
DEFAULT_PROP_WAIT_ON_EOS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSink::eos:
* @appsink: the appsink element that emitted the signal
*
* Signal that the end-of-stream has been reached. This signal is emitted from
* the streaming thread.
*/
gst_app_sink_signals[SIGNAL_EOS] =
g_signal_new ("eos", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstAppSinkClass, eos),
NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
/**
* GstAppSink::new-preroll:
* @appsink: the appsink element that emitted the signal
*
* Signal that a new preroll sample is available.
*
* This signal is emitted from the streaming thread and only when the
* "emit-signals" property is %TRUE.
*
* The new preroll sample can be retrieved with the "pull-preroll" action
* signal or gst_app_sink_pull_preroll() either from this signal callback
* or from any other thread.
*
* Note that this signal is only emitted when the "emit-signals" property is
* set to %TRUE, which it is not by default for performance reasons.
*/
gst_app_sink_signals[SIGNAL_NEW_PREROLL] =
g_signal_new ("new-preroll", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstAppSinkClass, new_preroll),
NULL, NULL, __gst_app_marshal_ENUM__VOID, GST_TYPE_FLOW_RETURN, 0,
G_TYPE_NONE);
/**
* GstAppSink::new-sample:
* @appsink: the appsink element that emited the signal
*
* Signal that a new sample is available.
*
* This signal is emitted from the streaming thread and only when the
* "emit-signals" property is %TRUE.
*
* The new sample can be retrieved with the "pull-sample" action
* signal or gst_app_sink_pull_sample() either from this signal callback
* or from any other thread.
*
* Note that this signal is only emitted when the "emit-signals" property is
* set to %TRUE, which it is not by default for performance reasons.
*/
gst_app_sink_signals[SIGNAL_NEW_SAMPLE] =
g_signal_new ("new-sample", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstAppSinkClass, new_sample),
NULL, NULL, __gst_app_marshal_ENUM__VOID, GST_TYPE_FLOW_RETURN, 0,
G_TYPE_NONE);
/**
* GstAppSink::pull-preroll:
* @appsink: the appsink element to emit this signal on
*
* Get the last preroll sample in @appsink. This was the sample that caused the
* appsink to preroll in the PAUSED state. This sample can be pulled many times
* and remains available to the application even after EOS.
*
* This function is typically used when dealing with a pipeline in the PAUSED
* state. Calling this function after doing a seek will give the sample right
* after the seek position.
*
* Note that the preroll sample will also be returned as the first sample
* when calling gst_app_sink_pull_sample() or the "pull-sample" action signal.
*
* If an EOS event was received before any buffers, this function returns
* %NULL. Use gst_app_sink_is_eos () to check for the EOS condition.
*
* This function blocks until a preroll sample or EOS is received or the appsink
* element is set to the READY/NULL state.
*
* Returns: a #GstSample or NULL when the appsink is stopped or EOS.
*/
gst_app_sink_signals[SIGNAL_PULL_PREROLL] =
g_signal_new ("pull-preroll", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSinkClass,
pull_preroll), NULL, NULL, __gst_app_marshal_BOXED__VOID,
GST_TYPE_SAMPLE, 0, G_TYPE_NONE);
/**
* GstAppSink::pull-sample:
* @appsink: the appsink element to emit this signal on
*
* This function blocks until a sample or EOS becomes available or the appsink
* element is set to the READY/NULL state.
*
* This function will only return samples when the appsink is in the PLAYING
* state. All rendered samples will be put in a queue so that the application
* can pull samples at its own rate.
*
* Note that when the application does not pull samples fast enough, the
* queued samples could consume a lot of memory, especially when dealing with
* raw video frames. It's possible to control the behaviour of the queue with
* the "drop" and "max-buffers" properties.
*
* If an EOS event was received before any buffers, this function returns
* %NULL. Use gst_app_sink_is_eos () to check for the EOS condition.
*
* Returns: a #GstSample or NULL when the appsink is stopped or EOS.
*/
gst_app_sink_signals[SIGNAL_PULL_SAMPLE] =
g_signal_new ("pull-sample", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSinkClass,
pull_sample), NULL, NULL, __gst_app_marshal_BOXED__VOID,
GST_TYPE_SAMPLE, 0, G_TYPE_NONE);
gst_element_class_set_static_metadata (element_class, "AppSink",
"Generic/Sink", "Allow the application to get access to raw buffer",
"David Schleef <*****@*****.**>, Wim Taymans <*****@*****.**>");
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_app_sink_template));
basesink_class->unlock = gst_app_sink_unlock_start;
basesink_class->unlock_stop = gst_app_sink_unlock_stop;
basesink_class->start = gst_app_sink_start;
basesink_class->stop = gst_app_sink_stop;
basesink_class->event = gst_app_sink_event;
basesink_class->preroll = gst_app_sink_preroll;
basesink_class->render = gst_app_sink_render;
basesink_class->get_caps = gst_app_sink_getcaps;
basesink_class->set_caps = gst_app_sink_setcaps;
basesink_class->query = gst_app_sink_query;
klass->pull_preroll = gst_app_sink_pull_preroll;
klass->pull_sample = gst_app_sink_pull_sample;
g_type_class_add_private (klass, sizeof (GstAppSinkPrivate));
}
static void
gtk_ellipsis_class_init (GtkEllipsisClass *klass)
{
GObjectClass *gobject_class;
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
gobject_class = (GObjectClass *) klass;
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
container_class = (GtkContainerClass *) klass;
gobject_class->set_property = gtk_ellipsis_set_property;
gobject_class->get_property = gtk_ellipsis_get_property;
widget_class->realize = gtk_ellipsis_realize;
widget_class->unrealize = gtk_ellipsis_unrealize;
widget_class->size_request = gtk_ellipsis_size_request;
widget_class->size_allocate = gtk_ellipsis_size_allocate;
widget_class->map = gtk_ellipsis_map;
widget_class->unmap = gtk_ellipsis_unmap;
widget_class->expose_event = gtk_ellipsis_expose;
widget_class->button_press_event = gtk_ellipsis_button_press;
widget_class->button_release_event = gtk_ellipsis_button_release;
widget_class->enter_notify_event = gtk_ellipsis_enter_notify;
widget_class->leave_notify_event = gtk_ellipsis_leave_notify;
widget_class->focus = gtk_ellipsis_focus;
widget_class->grab_notify = gtk_ellipsis_grab_notify;
widget_class->state_changed = gtk_ellipsis_state_changed;
widget_class->drag_motion = gtk_ellipsis_drag_motion;
widget_class->drag_leave = gtk_ellipsis_drag_leave;
container_class->add = gtk_ellipsis_add;
container_class->remove = gtk_ellipsis_remove;
container_class->forall = gtk_ellipsis_forall;
klass->activate = gtk_ellipsis_activate;
g_type_class_add_private (klass, sizeof (GtkEllipsisPrivate));
g_object_class_install_property (gobject_class,
PROP_EXPANDED,
g_param_spec_boolean ("expanded",
P_("Expanded"),
P_("Whether the ellipsis has been opened to reveal the child widget"),
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_LABEL,
g_param_spec_string ("label",
P_("Label"),
P_("Text of the ellipsis's label"),
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_WRAP_MODE,
g_param_spec_enum ("wrap-mode",
P_("Line wrap mode"),
P_("If wrap is set, controls how linewrapping is done"),
PANGO_TYPE_WRAP_MODE,
GTK_ELLIPSIS_DEFAULT_WRAP,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_USE_UNDERLINE,
g_param_spec_boolean ("use-underline",
P_("Use underline"),
P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_USE_MARKUP,
g_param_spec_boolean ("use-markup",
P_("Use markup"),
P_("The text of the label includes XML markup. See pango_parse_markup()"),
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_LABEL_WIDGET,
g_param_spec_object ("label-widget",
P_("Label widget"),
P_("A widget to display in place of the usual label"),
GTK_TYPE_WIDGET,
G_PARAM_READWRITE));
widget_class->activate_signal =
g_signal_new (I_("activate"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEllipsisClass, activate),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
cockpit_stream_class_init (CockpitStreamClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->constructed = cockpit_stream_constructed;
gobject_class->get_property = cockpit_stream_get_property;
gobject_class->set_property = cockpit_stream_set_property;
gobject_class->dispose = cockpit_stream_dispose;
gobject_class->finalize = cockpit_stream_finalize;
/**
* CockpitStream:io-stream:
*
* The underlying io stream. The input and output streams should
* be pollable.
*/
g_object_class_install_property (gobject_class, PROP_IO_STREAM,
g_param_spec_object ("io-stream", "io-stream", "io-stream", G_TYPE_IO_STREAM,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
/**
* CockpitStream:name:
*
* Pipe name used for debugging purposes.
*/
g_object_class_install_property (gobject_class, PROP_NAME,
g_param_spec_string ("name", "name", "name", "<unnamed>",
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
/**
* CockpitStream:problem:
*
* The problem that the pipe closed with. If used as a constructor argument then
* the pipe will be created in a closed/failed state. Although 'closed' signal will
* only fire once main loop is hit.
*/
g_object_class_install_property (gobject_class, PROP_PROBLEM,
g_param_spec_string ("problem", "problem", "problem", NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
/**
* CockpitStream::open:
*
* Emitted when actually open and connected.
*/
cockpit_stream_sig_open = g_signal_new ("open", COCKPIT_TYPE_STREAM, G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (CockpitStreamClass, open),
NULL, NULL, NULL, G_TYPE_NONE, 0);
/**
* CockpitStream::read:
* @buffer: a GByteArray of the read data
* @eof: whether the pipe is done reading
*
* Emitted when data is read from the input file descriptor of the
* pipe.
*
* Data consumed from @buffer by the handler should be removed from
* the GByteArray. This can be done with the cockpit_stream_consume()
* function.
*
* This handler will only be called once with @eof set to TRUE. But
* in error conditions it may not be called with @eof set to TRUE
* at all, and the CockpitStream::close signal will simply fire.
*/
cockpit_stream_sig_read = g_signal_new ("read", COCKPIT_TYPE_STREAM, G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (CockpitStreamClass, read),
NULL, NULL, NULL,
G_TYPE_NONE, 2, G_TYPE_BYTE_ARRAY, G_TYPE_BOOLEAN);
/**
* CockpitStream::close:
* @problem: problem string or %NULL
*
* Emitted when the pipe closes, whether due to a problem or a normal
* shutdown.
*
* @problem will be NULL if the pipe closed normally.
*/
cockpit_stream_sig_close = g_signal_new ("close", COCKPIT_TYPE_STREAM, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (CockpitStreamClass, close),
NULL, NULL, NULL,
G_TYPE_NONE, 1, G_TYPE_STRING);
/**
* CockpitStream::rejected-cert:
* @pem: PEM data as a string
*
* Emitted when the pipe will close because a certificate is rejected
*/
cockpit_stream_sig_rejected_cert = g_signal_new ("rejected-cert", COCKPIT_TYPE_STREAM, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (CockpitStreamClass, close),
NULL, NULL, NULL,
G_TYPE_NONE, 1, G_TYPE_STRING);
g_type_class_add_private (klass, sizeof (CockpitStreamPrivate));
}
static void
gst_identity_class_init (GstIdentityClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstBaseTransformClass *gstbasetrans_class;
gobject_class = G_OBJECT_CLASS (klass);
gstelement_class = GST_ELEMENT_CLASS (klass);
gstbasetrans_class = GST_BASE_TRANSFORM_CLASS (klass);
gobject_class->set_property = gst_identity_set_property;
gobject_class->get_property = gst_identity_get_property;
g_object_class_install_property (gobject_class, PROP_SLEEP_TIME,
g_param_spec_uint ("sleep-time", "Sleep time",
"Microseconds to sleep between processing", 0, G_MAXUINT,
DEFAULT_SLEEP_TIME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_ERROR_AFTER,
g_param_spec_int ("error-after", "Error After", "Error after N buffers",
G_MININT, G_MAXINT, DEFAULT_ERROR_AFTER,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_DROP_PROBABILITY,
g_param_spec_float ("drop-probability", "Drop Probability",
"The Probability a buffer is dropped", 0.0, 1.0,
DEFAULT_DROP_PROBABILITY,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstIdentity:drop-buffer-flags:
*
* Drop buffers with the given flags.
*
* Since: 1.8
**/
g_object_class_install_property (gobject_class, PROP_DROP_BUFFER_FLAGS,
g_param_spec_flags ("drop-buffer-flags", "Check flags to drop buffers",
"Drop buffers with the given flags",
GST_TYPE_BUFFER_FLAGS, DEFAULT_DROP_BUFFER_FLAGS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_DATARATE,
g_param_spec_int ("datarate", "Datarate",
"(Re)timestamps buffers with number of bytes per second (0 = inactive)",
0, G_MAXINT, DEFAULT_DATARATE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SILENT,
g_param_spec_boolean ("silent", "silent", "silent", DEFAULT_SILENT,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SINGLE_SEGMENT,
g_param_spec_boolean ("single-segment", "Single Segment",
"Timestamp buffers and eat segments so as to appear as one segment",
DEFAULT_SINGLE_SEGMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
pspec_last_message = g_param_spec_string ("last-message", "last-message",
"last-message", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (gobject_class, PROP_LAST_MESSAGE,
pspec_last_message);
g_object_class_install_property (gobject_class, PROP_DUMP,
g_param_spec_boolean ("dump", "Dump", "Dump buffer contents to stdout",
DEFAULT_DUMP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SYNC,
g_param_spec_boolean ("sync", "Synchronize",
"Synchronize to pipeline clock", DEFAULT_SYNC,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_CHECK_IMPERFECT_TIMESTAMP,
g_param_spec_boolean ("check-imperfect-timestamp",
"Check for discontiguous timestamps",
"Send element messages if timestamps and durations do not match up",
DEFAULT_CHECK_IMPERFECT_TIMESTAMP,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_CHECK_IMPERFECT_OFFSET,
g_param_spec_boolean ("check-imperfect-offset",
"Check for discontiguous offset",
"Send element messages if offset and offset_end do not match up",
DEFAULT_CHECK_IMPERFECT_OFFSET,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstIdentity:signal-handoffs
*
* If set to #TRUE, the identity will emit a handoff signal when handling a buffer.
* When set to #FALSE, no signal will be emitted, which might improve performance.
*/
g_object_class_install_property (gobject_class, PROP_SIGNAL_HANDOFFS,
g_param_spec_boolean ("signal-handoffs",
"Signal handoffs", "Send a signal before pushing the buffer",
DEFAULT_SIGNAL_HANDOFFS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstIdentity::handoff:
* @identity: the identity instance
* @buffer: the buffer that just has been received
* @pad: the pad that received it
*
* This signal gets emitted before passing the buffer downstream.
*/
gst_identity_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstIdentityClass, handoff), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 1,
GST_TYPE_BUFFER | G_SIGNAL_TYPE_STATIC_SCOPE);
gobject_class->finalize = gst_identity_finalize;
gst_element_class_set_static_metadata (gstelement_class,
"Identity",
"Generic",
"Pass data without modification", "Erik Walthinsen <*****@*****.**>");
gst_element_class_add_static_pad_template (gstelement_class, &srctemplate);
gst_element_class_add_static_pad_template (gstelement_class, &sinktemplate);
gstelement_class->change_state =
GST_DEBUG_FUNCPTR (gst_identity_change_state);
gstbasetrans_class->sink_event = GST_DEBUG_FUNCPTR (gst_identity_sink_event);
gstbasetrans_class->transform_ip =
GST_DEBUG_FUNCPTR (gst_identity_transform_ip);
gstbasetrans_class->start = GST_DEBUG_FUNCPTR (gst_identity_start);
gstbasetrans_class->stop = GST_DEBUG_FUNCPTR (gst_identity_stop);
gstbasetrans_class->accept_caps =
GST_DEBUG_FUNCPTR (gst_identity_accept_caps);
gstbasetrans_class->query = gst_identity_query;
}
static void
gupnp_control_point_class_init (GUPnPControlPointClass *klass)
{
GObjectClass *object_class;
GSSDPResourceBrowserClass *browser_class;
object_class = G_OBJECT_CLASS (klass);
object_class->set_property = gupnp_control_point_set_property;
object_class->get_property = gupnp_control_point_get_property;
object_class->dispose = gupnp_control_point_dispose;
object_class->finalize = gupnp_control_point_finalize;
browser_class = GSSDP_RESOURCE_BROWSER_CLASS (klass);
browser_class->resource_available =
gupnp_control_point_resource_available;
browser_class->resource_unavailable =
gupnp_control_point_resource_unavailable;
g_type_class_add_private (klass, sizeof (GUPnPControlPointPrivate));
/**
* GUPnPControlPoint:resource-factory
*
* The resource factory to use. Set to NULL for default factory.
**/
g_object_class_install_property
(object_class,
PROP_RESOURCE_FACTORY,
g_param_spec_object ("resource-factory",
"Resource Factory",
"The resource factory to use",
GUPNP_TYPE_RESOURCE_FACTORY,
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_READWRITE |
G_PARAM_STATIC_NAME |
G_PARAM_STATIC_NICK |
G_PARAM_STATIC_BLURB));
/**
* GUPnPControlPoint::device-proxy-available
* @control_point: The #GUPnPControlPoint that received the signal
* @proxy: The now available #GUPnPDeviceProxy
*
* The ::device-proxy-available signal is emitted whenever a new
* device has become available.
**/
signals[DEVICE_PROXY_AVAILABLE] =
g_signal_new ("device-proxy-available",
GUPNP_TYPE_CONTROL_POINT,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GUPnPControlPointClass,
device_proxy_available),
NULL,
NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
GUPNP_TYPE_DEVICE_PROXY);
/**
* GUPnPControlPoint::device-proxy-unavailable
* @control_point: The #GUPnPControlPoint that received the signal
* @proxy: The now unavailable #GUPnPDeviceProxy
*
* The ::device-proxy-unavailable signal is emitted whenever a
* device is not available any more.
**/
signals[DEVICE_PROXY_UNAVAILABLE] =
g_signal_new ("device-proxy-unavailable",
GUPNP_TYPE_CONTROL_POINT,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GUPnPControlPointClass,
device_proxy_unavailable),
NULL,
NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
GUPNP_TYPE_DEVICE_PROXY);
/**
* GUPnPControlPoint::service-proxy-available
* @control_point: The #GUPnPControlPoint that received the signal
* @proxy: The now available #GUPnPServiceProxy
*
* The ::service-proxy-available signal is emitted whenever a new
* service has become available.
**/
signals[SERVICE_PROXY_AVAILABLE] =
g_signal_new ("service-proxy-available",
GUPNP_TYPE_CONTROL_POINT,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GUPnPControlPointClass,
service_proxy_available),
NULL,
NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
GUPNP_TYPE_SERVICE_PROXY);
/**
* GUPnPControlPoint::service-proxy-unavailable
* @control_point: The #GUPnPControlPoint that received the signal
* @proxy: The now unavailable #GUPnPServiceProxy
*
* The ::service-proxy-unavailable signal is emitted whenever a
* service is not available any more.
**/
signals[SERVICE_PROXY_UNAVAILABLE] =
g_signal_new ("service-proxy-unavailable",
GUPNP_TYPE_CONTROL_POINT,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GUPnPControlPointClass,
service_proxy_unavailable),
NULL,
NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
GUPNP_TYPE_SERVICE_PROXY);
}
* </xs:sequence>
* </xs:extension>
* </xs:complexContent>
* </xs:complexType>
* ]]></programlisting>
* </figure>
*/
/*****************************************************************************/
/* private methods */
/*****************************************************************************/
static struct XmlSnippet schema_snippets[] = {
{ "Object", SNIPPET_NODE,
G_STRUCT_OFFSET(LassoIdWsf2PsAddKnownEntityResponse, Object), NULL, NULL, NULL},
{ "SPtoPSRedirectURL", SNIPPET_NODE,
G_STRUCT_OFFSET(LassoIdWsf2PsAddKnownEntityResponse, SPtoPSRedirectURL), NULL, NULL, NULL},
{ "QueryString", SNIPPET_NODE,
G_STRUCT_OFFSET(LassoIdWsf2PsAddKnownEntityResponse, QueryString), NULL, NULL, NULL},
{NULL, 0, 0, NULL, NULL, NULL}
};
static LassoNodeClass *parent_class = NULL;
/*****************************************************************************/
/* instance and class init functions */
/*****************************************************************************/
/* Class Init Function. */
/*****************************************************************************/
static void
gl_color_combo_button_class_init (glColorComboButtonClass *class)
{
GObjectClass *gobject_class = (GObjectClass *) class;
gl_color_combo_button_parent_class = g_type_class_peek_parent (class);
gobject_class->finalize = gl_color_combo_button_finalize;
signals[COLOR_CHANGED] =
g_signal_new ("color_changed",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (glColorComboButtonClass, color_changed),
NULL, NULL,
gl_marshal_VOID__UINT_BOOLEAN,
G_TYPE_NONE,
2, G_TYPE_POINTER, G_TYPE_BOOLEAN);
}
/*****************************************************************************/
/* Object Instance Init Function. */
/*****************************************************************************/
static void
gl_color_combo_button_init (glColorComboButton *this)
{
GtkWidget *arrow;
static void
egg_cell_renderer_keys_class_init (EggCellRendererKeysClass *cell_keys_class)
{
GObjectClass *object_class;
GtkCellRendererClass *cell_renderer_class;
object_class = G_OBJECT_CLASS (cell_keys_class);
cell_renderer_class = GTK_CELL_RENDERER_CLASS (cell_keys_class);
parent_class = g_type_class_peek_parent (object_class);
GTK_CELL_RENDERER_CLASS (cell_keys_class)->start_editing = egg_cell_renderer_keys_start_editing;
object_class->set_property = egg_cell_renderer_keys_set_property;
object_class->get_property = egg_cell_renderer_keys_get_property;
cell_renderer_class->get_size = egg_cell_renderer_keys_get_size;
object_class->finalize = egg_cell_renderer_keys_finalize;
/* FIXME if this gets moved to a real library, rename the properties
* to match whatever the GTK convention is
*/
g_object_class_install_property (object_class,
PROP_ACCEL_KEY,
g_param_spec_uint ("accel_key",
_("Accelerator key"),
_("Accelerator key"),
0,
G_MAXINT,
0,
G_PARAM_READABLE | G_PARAM_WRITABLE));
g_object_class_install_property (object_class,
PROP_ACCEL_MASK,
g_param_spec_flags ("accel_mask",
_("Accelerator modifiers"),
_("Accelerator modifiers"),
GDK_TYPE_MODIFIER_TYPE,
0,
G_PARAM_READABLE | G_PARAM_WRITABLE));
g_object_class_install_property (object_class,
PROP_KEYCODE,
g_param_spec_uint ("keycode",
_("Accelerator keycode"),
_("Accelerator keycode"),
0,
G_MAXINT,
0,
G_PARAM_READABLE | G_PARAM_WRITABLE));
/* FIXME: Register the enum when moving to GTK+ */
g_object_class_install_property (object_class,
PROP_ACCEL_MODE,
g_param_spec_int ("accel_mode",
_("Accel Mode"),
_("The type of accelerator."),
0,
2,
0,
G_PARAM_READABLE | G_PARAM_WRITABLE));
g_signal_new ("accel_edited",
EGG_TYPE_CELL_RENDERER_KEYS,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (EggCellRendererKeysClass, accel_edited),
NULL, NULL,
marshal_VOID__STRING_UINT_FLAGS_UINT,
G_TYPE_NONE, 4,
G_TYPE_STRING,
G_TYPE_UINT,
GDK_TYPE_MODIFIER_TYPE,
G_TYPE_UINT);
g_signal_new ("accel_cleared",
EGG_TYPE_CELL_RENDERER_KEYS,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (EggCellRendererKeysClass, accel_cleared),
NULL, NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING);
}
* </xs:restriction>
* </xs:simpleType>
*
* <xs:element name="ProtocolProfile" type="xs:anyURI"/>
* <xs:element name="RelayState" type="xs:string"/>
* ]]></programlisting>
* </figure>
*/
/*****************************************************************************/
/* private methods */
/*****************************************************************************/
static struct XmlSnippet schema_snippets[] = {
{ "Extension", SNIPPET_EXTENSION, G_STRUCT_OFFSET(LassoLibAuthnRequest, Extension), NULL, NULL, NULL},
{ "ProviderID", SNIPPET_CONTENT, G_STRUCT_OFFSET(LassoLibAuthnRequest, ProviderID), NULL, NULL, NULL},
{ "AffiliationID", SNIPPET_CONTENT, G_STRUCT_OFFSET(LassoLibAuthnRequest, AffiliationID), NULL, NULL, NULL},
{ "NameIDPolicy", SNIPPET_CONTENT, G_STRUCT_OFFSET(LassoLibAuthnRequest, NameIDPolicy), NULL, NULL, NULL},
{ "ForceAuthn", SNIPPET_CONTENT | SNIPPET_BOOLEAN,
G_STRUCT_OFFSET(LassoLibAuthnRequest, ForceAuthn), NULL, NULL, NULL},
{ "IsPassive", SNIPPET_CONTENT | SNIPPET_BOOLEAN,
G_STRUCT_OFFSET(LassoLibAuthnRequest, IsPassive), NULL, NULL, NULL},
{ "ProtocolProfile", SNIPPET_CONTENT,
G_STRUCT_OFFSET(LassoLibAuthnRequest, ProtocolProfile), NULL, NULL, NULL},
{ "AssertionConsumerServiceID", SNIPPET_CONTENT,
G_STRUCT_OFFSET(LassoLibAuthnRequest, AssertionConsumerServiceID), NULL, NULL, NULL},
{ "RequestAuthnContext", SNIPPET_NODE,
G_STRUCT_OFFSET(LassoLibAuthnRequest, RequestAuthnContext), NULL, NULL, NULL},
{ "RelayState", SNIPPET_CONTENT, G_STRUCT_OFFSET(LassoLibAuthnRequest, RelayState), NULL, NULL, NULL},
{ "Scoping", SNIPPET_NODE, G_STRUCT_OFFSET(LassoLibAuthnRequest, Scoping), NULL, NULL, NULL},
/*
* mono_arch_get_call_filter:
*
* Returns a pointer to a method which calls an exception filter. We
* also use this function to call finally handlers (we pass NULL as
* @exc object in this case).
*/
gpointer
mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
{
guint8* start;
guint8 *code;
MonoJumpInfo *ji = NULL;
GSList *unwind_ops = NULL;
guint kMaxCodeSize = NACL_SIZE (64, 128);
/* call_filter (MonoContext *ctx, unsigned long eip) */
start = code = mono_global_codeman_reserve (kMaxCodeSize);
x86_push_reg (code, X86_EBP);
x86_mov_reg_reg (code, X86_EBP, X86_ESP, 4);
x86_push_reg (code, X86_EBX);
x86_push_reg (code, X86_EDI);
x86_push_reg (code, X86_ESI);
/* load ctx */
x86_mov_reg_membase (code, X86_EAX, X86_EBP, 8, 4);
/* load eip */
x86_mov_reg_membase (code, X86_ECX, X86_EBP, 12, 4);
/* save EBP */
x86_push_reg (code, X86_EBP);
/* set new EBP */
x86_mov_reg_membase (code, X86_EBP, X86_EAX, G_STRUCT_OFFSET (MonoContext, ebp), 4);
/* restore registers used by global register allocation (EBX & ESI) */
x86_mov_reg_membase (code, X86_EBX, X86_EAX, G_STRUCT_OFFSET (MonoContext, ebx), 4);
x86_mov_reg_membase (code, X86_ESI, X86_EAX, G_STRUCT_OFFSET (MonoContext, esi), 4);
x86_mov_reg_membase (code, X86_EDI, X86_EAX, G_STRUCT_OFFSET (MonoContext, edi), 4);
/* align stack and save ESP */
x86_mov_reg_reg (code, X86_EDX, X86_ESP, 4);
x86_alu_reg_imm (code, X86_AND, X86_ESP, -MONO_ARCH_FRAME_ALIGNMENT);
g_assert (MONO_ARCH_FRAME_ALIGNMENT >= 8);
x86_alu_reg_imm (code, X86_SUB, X86_ESP, MONO_ARCH_FRAME_ALIGNMENT - 8);
x86_push_reg (code, X86_EDX);
/* call the handler */
x86_call_reg (code, X86_ECX);
/* restore ESP */
x86_pop_reg (code, X86_ESP);
/* restore EBP */
x86_pop_reg (code, X86_EBP);
/* restore saved regs */
x86_pop_reg (code, X86_ESI);
x86_pop_reg (code, X86_EDI);
x86_pop_reg (code, X86_EBX);
x86_leave (code);
x86_ret (code);
nacl_global_codeman_validate(&start, kMaxCodeSize, &code);
if (info)
*info = mono_tramp_info_create (g_strdup_printf ("call_filter"), start, code - start, ji, unwind_ops);
else {
GSList *l;
for (l = unwind_ops; l; l = l->next)
g_free (l->data);
g_slist_free (unwind_ops);
}
g_assert ((code - start) < kMaxCodeSize);
return start;
}
static void
gst_multi_socket_sink_class_init (GstMultiSocketSinkClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstBaseSinkClass *gstbasesink_class;
GstMultiHandleSinkClass *gstmultihandlesink_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gstbasesink_class = (GstBaseSinkClass *) klass;
gstmultihandlesink_class = (GstMultiHandleSinkClass *) klass;
gobject_class->set_property = gst_multi_socket_sink_set_property;
gobject_class->get_property = gst_multi_socket_sink_get_property;
gobject_class->finalize = gst_multi_socket_sink_finalize;
/**
* GstMultiSocketSink::add:
* @gstmultisocketsink: the multisocketsink element to emit this signal on
* @socket: the socket to add to multisocketsink
*
* Hand the given open socket to multisocketsink to write to.
*/
gst_multi_socket_sink_signals[SIGNAL_ADD] =
g_signal_new ("add", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstMultiSocketSinkClass, add), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 1, G_TYPE_SOCKET);
/**
* GstMultiSocketSink::add-full:
* @gstmultisocketsink: the multisocketsink element to emit this signal on
* @socket: the socket to add to multisocketsink
* @sync: the sync method to use
* @format_min: the format of @value_min
* @value_min: the minimum amount of data to burst expressed in
* @format_min units.
* @format_max: the format of @value_max
* @value_max: the maximum amount of data to burst expressed in
* @format_max units.
*
* Hand the given open socket to multisocketsink to write to and
* specify the burst parameters for the new connection.
*/
gst_multi_socket_sink_signals[SIGNAL_ADD_BURST] =
g_signal_new ("add-full", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstMultiSocketSinkClass, add_full), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 6,
G_TYPE_SOCKET, GST_TYPE_SYNC_METHOD, GST_TYPE_FORMAT, G_TYPE_UINT64,
GST_TYPE_FORMAT, G_TYPE_UINT64);
/**
* GstMultiSocketSink::remove:
* @gstmultisocketsink: the multisocketsink element to emit this signal on
* @socket: the socket to remove from multisocketsink
*
* Remove the given open socket from multisocketsink.
*/
gst_multi_socket_sink_signals[SIGNAL_REMOVE] =
g_signal_new ("remove", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstMultiSocketSinkClass, remove), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 1, G_TYPE_SOCKET);
/**
* GstMultiSocketSink::remove-flush:
* @gstmultisocketsink: the multisocketsink element to emit this signal on
* @socket: the socket to remove from multisocketsink
*
* Remove the given open socket from multisocketsink after flushing all
* the pending data to the socket.
*/
gst_multi_socket_sink_signals[SIGNAL_REMOVE_FLUSH] =
g_signal_new ("remove-flush", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstMultiSocketSinkClass, remove_flush), NULL, NULL,
g_cclosure_marshal_generic, G_TYPE_NONE, 1, G_TYPE_SOCKET);
/**
* GstMultiSocketSink::get-stats:
* @gstmultisocketsink: the multisocketsink element to emit this signal on
* @socket: the socket to get stats of from multisocketsink
*
* Get statistics about @socket. This function returns a GstStructure.
*
* Returns: a GstStructure with the statistics. The structure contains
* values that represent: total number of bytes sent, time
* when the client was added, time when the client was
* disconnected/removed, time the client is/was active, last activity
* time (in epoch seconds), number of buffers dropped.
* All times are expressed in nanoseconds (GstClockTime).
*/
gst_multi_socket_sink_signals[SIGNAL_GET_STATS] =
g_signal_new ("get-stats", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GstMultiSocketSinkClass, get_stats), NULL, NULL,
g_cclosure_marshal_generic, GST_TYPE_STRUCTURE, 1, G_TYPE_SOCKET);
/**
* GstMultiSocketSink::client-added:
* @gstmultisocketsink: the multisocketsink element that emitted this signal
* @socket: the socket that was added to multisocketsink
*
* The given socket was added to multisocketsink. This signal will
* be emitted from the streaming thread so application should be prepared
* for that.
*/
gst_multi_socket_sink_signals[SIGNAL_CLIENT_ADDED] =
g_signal_new ("client-added", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
/**
* GstMultiSocketSink::client-removed:
* @gstmultisocketsink: the multisocketsink element that emitted this signal
* @socket: the socket that is to be removed from multisocketsink
* @status: the reason why the client was removed
*
* The given socket is about to be removed from multisocketsink. This
* signal will be emitted from the streaming thread so applications should
* be prepared for that.
*
* @gstmultisocketsink still holds a handle to @socket so it is possible to call
* the get-stats signal from this callback. For the same reason it is
* not safe to close() and reuse @socket in this callback.
*/
gst_multi_socket_sink_signals[SIGNAL_CLIENT_REMOVED] =
g_signal_new ("client-removed", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,
G_TYPE_NONE, 2, G_TYPE_INT, GST_TYPE_CLIENT_STATUS);
/**
* GstMultiSocketSink::client-socket-removed:
* @gstmultisocketsink: the multisocketsink element that emitted this signal
* @socket: the socket that was removed from multisocketsink
*
* The given socket was removed from multisocketsink. This signal will
* be emitted from the streaming thread so applications should be prepared
* for that.
*
* In this callback, @gstmultisocketsink has removed all the information
* associated with @socket and it is therefore not possible to call get-stats
* with @socket. It is however safe to close() and reuse @fd in the callback.
*/
gst_multi_socket_sink_signals[SIGNAL_CLIENT_SOCKET_REMOVED] =
g_signal_new ("client-socket-removed", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_generic,
G_TYPE_NONE, 1, G_TYPE_SOCKET);
gst_element_class_set_static_metadata (gstelement_class,
"Multi socket sink", "Sink/Network",
"Send data to multiple sockets",
"Thomas Vander Stichele <thomas at apestaart dot org>, "
"Wim Taymans <*****@*****.**>, "
"Sebastian Dröge <*****@*****.**>");
gstbasesink_class->unlock = GST_DEBUG_FUNCPTR (gst_multi_socket_sink_unlock);
gstbasesink_class->unlock_stop =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_unlock_stop);
klass->add = GST_DEBUG_FUNCPTR (gst_multi_socket_sink_add);
klass->add_full = GST_DEBUG_FUNCPTR (gst_multi_socket_sink_add_full);
klass->remove = GST_DEBUG_FUNCPTR (gst_multi_socket_sink_remove);
klass->remove_flush = GST_DEBUG_FUNCPTR (gst_multi_socket_sink_remove_flush);
klass->get_stats = GST_DEBUG_FUNCPTR (gst_multi_socket_sink_get_stats);
gstmultihandlesink_class->emit_client_added =
gst_multi_socket_sink_emit_client_added;
gstmultihandlesink_class->emit_client_removed =
gst_multi_socket_sink_emit_client_removed;
gstmultihandlesink_class->stop_pre =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_stop_pre);
gstmultihandlesink_class->stop_post =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_stop_post);
gstmultihandlesink_class->start_pre =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_start_pre);
gstmultihandlesink_class->thread =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_thread);
gstmultihandlesink_class->new_client =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_new_client);
gstmultihandlesink_class->client_get_fd =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_client_get_fd);
gstmultihandlesink_class->client_free =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_client_free);
gstmultihandlesink_class->handle_debug =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_handle_debug);
gstmultihandlesink_class->handle_hash_key =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_handle_hash_key);
gstmultihandlesink_class->hash_adding =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_hash_adding);
gstmultihandlesink_class->hash_removing =
GST_DEBUG_FUNCPTR (gst_multi_socket_sink_hash_removing);
GST_DEBUG_CATEGORY_INIT (multisocketsink_debug, "multisocketsink", 0,
"Multi socket sink");
}
*
* <xs:complexType name="RedirectRequestType">
* <xs:attribute name="redirectURL" type="xs:anyURI" use="required"/>
* </xs:complexType>
* ]]></programlisting>
* </figure>
*/
/*****************************************************************************/
/* private methods */
/*****************************************************************************/
static struct XmlSnippet schema_snippets[] = {
{ "redirectURL", SNIPPET_ATTRIBUTE,
G_STRUCT_OFFSET(LassoIdWsf2Sb2RedirectRequest, redirectURL), NULL, NULL, NULL},
{NULL, 0, 0, NULL, NULL, NULL}
};
static LassoNodeClass *parent_class = NULL;
/*****************************************************************************/
/* instance and class init functions */
/*****************************************************************************/
static void
class_init(LassoIdWsf2Sb2RedirectRequestClass *klass)
{
LassoNodeClass *nclass = LASSO_NODE_CLASS(klass);
static void
gedit_multi_notebook_class_init (GeditMultiNotebookClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = gedit_multi_notebook_dispose;
object_class->finalize = gedit_multi_notebook_finalize;
object_class->get_property = gedit_multi_notebook_get_property;
object_class->set_property = gedit_multi_notebook_set_property;
signals[NOTEBOOK_ADDED] =
g_signal_new ("notebook-added",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GeditMultiNotebookClass, notebook_added),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
GEDIT_TYPE_NOTEBOOK);
signals[NOTEBOOK_REMOVED] =
g_signal_new ("notebook-removed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GeditMultiNotebookClass, notebook_removed),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
GEDIT_TYPE_NOTEBOOK);
signals[TAB_ADDED] =
g_signal_new ("tab-added",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GeditMultiNotebookClass, tab_added),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
GEDIT_TYPE_NOTEBOOK,
GEDIT_TYPE_TAB);
signals[TAB_REMOVED] =
g_signal_new ("tab-removed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GeditMultiNotebookClass, tab_removed),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
GEDIT_TYPE_NOTEBOOK,
GEDIT_TYPE_TAB);
signals[SWITCH_TAB] =
g_signal_new ("switch-tab",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GeditMultiNotebookClass, switch_tab),
NULL, NULL, NULL,
G_TYPE_NONE,
4,
GEDIT_TYPE_NOTEBOOK,
GEDIT_TYPE_TAB,
GEDIT_TYPE_NOTEBOOK,
GEDIT_TYPE_TAB);
signals[TAB_CLOSE_REQUEST] =
g_signal_new ("tab-close-request",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GeditMultiNotebookClass, tab_close_request),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
GEDIT_TYPE_NOTEBOOK,
GEDIT_TYPE_TAB);
signals[CREATE_WINDOW] =
g_signal_new ("create-window",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GeditMultiNotebookClass, create_window),
NULL, NULL, NULL,
GTK_TYPE_NOTEBOOK, 4,
GEDIT_TYPE_NOTEBOOK, GTK_TYPE_WIDGET,
G_TYPE_INT, G_TYPE_INT);
signals[PAGE_REORDERED] =
g_signal_new ("page-reordered",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GeditMultiNotebookClass, page_reordered),
NULL, NULL, NULL,
G_TYPE_NONE,
3,
GEDIT_TYPE_NOTEBOOK, GTK_TYPE_WIDGET,
G_TYPE_INT);
signals[SHOW_POPUP_MENU] =
g_signal_new ("show-popup-menu",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GeditMultiNotebookClass, show_popup_menu),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE,
GEDIT_TYPE_TAB);
g_object_class_install_property (object_class,
PROP_ACTIVE_NOTEBOOK,
g_param_spec_object ("active-notebook",
"Active Notebook",
"The Active Notebook",
GEDIT_TYPE_NOTEBOOK,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (object_class,
PROP_ACTIVE_TAB,
g_param_spec_object ("active-tab",
"Active Tab",
"The Active Tab",
GEDIT_TYPE_TAB,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (object_class,
PROP_SHOW_TABS_MODE,
g_param_spec_enum ("show-tabs-mode",
"Show Tabs Mode",
"When tabs should be shown",
GEDIT_TYPE_NOTEBOOK_SHOW_TABS_MODE_TYPE,
GEDIT_NOTEBOOK_SHOW_TABS_ALWAYS,
G_PARAM_READWRITE));
}
static void
tp_tests_text_channel_group_class_init (TpTestsTextChannelGroupClass *klass)
{
GObjectClass *object_class = (GObjectClass *) klass;
GParamSpec *param_spec;
static TpDBusPropertiesMixinPropImpl channel_props[] = {
{ "TargetHandleType", "handle-type", NULL },
{ "TargetHandle", "handle", NULL },
{ "ChannelType", "channel-type", NULL },
{ "Interfaces", "interfaces", NULL },
{ "TargetID", "target-id", NULL },
{ "Requested", "requested", NULL },
{ "InitiatorHandle", "initiator-handle", NULL },
{ "InitiatorID", "initiator-id", NULL },
{ NULL }
};
static TpDBusPropertiesMixinIfaceImpl prop_interfaces[] = {
{ TP_IFACE_CHANNEL,
tp_dbus_properties_mixin_getter_gobject_properties,
NULL,
channel_props,
},
{ NULL }
};
g_type_class_add_private (klass, sizeof (TpTestsTextChannelGroupPrivate));
object_class->constructor = constructor;
object_class->set_property = set_property;
object_class->get_property = get_property;
object_class->dispose = dispose;
object_class->finalize = finalize;
g_object_class_override_property (object_class, PROP_OBJECT_PATH,
"object-path");
g_object_class_override_property (object_class, PROP_CHANNEL_TYPE,
"channel-type");
g_object_class_override_property (object_class, PROP_HANDLE_TYPE,
"handle-type");
g_object_class_override_property (object_class, PROP_HANDLE, "handle");
param_spec = g_param_spec_object ("connection", "TpBaseConnection object",
"Connection object that owns this channel",
TP_TYPE_BASE_CONNECTION,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB);
g_object_class_install_property (object_class, PROP_CONNECTION, param_spec);
param_spec = g_param_spec_boxed ("interfaces", "Extra D-Bus interfaces",
"Additional Channel.Interface.* interfaces",
G_TYPE_STRV,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_INTERFACES, param_spec);
param_spec = g_param_spec_string ("target-id", "Peer's ID",
"Always the empty string on this channel",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_TARGET_ID, param_spec);
param_spec = g_param_spec_uint ("initiator-handle", "Initiator's handle",
"The contact who initiated the channel",
0, G_MAXUINT32, 0,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_INITIATOR_HANDLE,
param_spec);
param_spec = g_param_spec_string ("initiator-id", "Initiator's ID",
"The string obtained by inspecting the initiator-handle",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_INITIATOR_ID,
param_spec);
param_spec = g_param_spec_boolean ("requested", "Requested?",
"True if this channel was requested by the local user",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_REQUESTED, param_spec);
param_spec = g_param_spec_boolean ("detailed",
"Has the Members_Changed_Detailed flag?",
"True if the Members_Changed_Detailed group flag should be set",
TRUE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_DETAILED, param_spec);
param_spec = g_param_spec_boolean ("properties",
"Has the Properties flag?",
"True if the Properties group flag should be set",
TRUE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class, PROP_PROPERTIES, param_spec);
tp_text_mixin_class_init (object_class,
G_STRUCT_OFFSET (TpTestsTextChannelGroupClass, text_class));
tp_group_mixin_class_init (object_class,
G_STRUCT_OFFSET (TpTestsTextChannelGroupClass, group_class), add_member,
NULL);
klass->dbus_properties_class.interfaces = prop_interfaces;
tp_dbus_properties_mixin_class_init (object_class,
G_STRUCT_OFFSET (TpTestsTextChannelGroupClass, dbus_properties_class));
tp_group_mixin_init_dbus_properties (object_class);
}
static void
gst_fake_src_class_init (GstFakeSrcClass * klass)
{
GObjectClass *gobject_class;
GstBaseSrcClass *gstbase_src_class;
gobject_class = G_OBJECT_CLASS (klass);
gstbase_src_class = GST_BASE_SRC_CLASS (klass);
gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_fake_src_finalize);
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_fake_src_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_fake_src_get_property);
/*
FIXME: this is not implemented; would make sense once basesrc and fakesrc
support multiple pads
g_object_class_install_property (gobject_class, PROP_OUTPUT,
g_param_spec_enum ("output", "output", "Output method (currently unused)",
GST_TYPE_FAKE_SRC_OUTPUT, DEFAULT_OUTPUT, G_PARAM_READWRITE));
*/
g_object_class_install_property (gobject_class, PROP_DATA,
g_param_spec_enum ("data", "data", "Data allocation method",
GST_TYPE_FAKE_SRC_DATA, DEFAULT_DATA,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_SIZETYPE,
g_param_spec_enum ("sizetype", "sizetype",
"How to determine buffer sizes", GST_TYPE_FAKE_SRC_SIZETYPE,
DEFAULT_SIZETYPE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SIZEMIN,
g_param_spec_int ("sizemin", "sizemin", "Minimum buffer size", 0,
G_MAXINT, DEFAULT_SIZEMIN,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SIZEMAX,
g_param_spec_int ("sizemax", "sizemax", "Maximum buffer size", 0,
G_MAXINT, DEFAULT_SIZEMAX,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_PARENTSIZE,
g_param_spec_int ("parentsize", "parentsize",
"Size of parent buffer for sub-buffered allocation", 0, G_MAXINT,
DEFAULT_PARENTSIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_FILLTYPE,
g_param_spec_enum ("filltype", "filltype",
"How to fill the buffer, if at all", GST_TYPE_FAKE_SRC_FILLTYPE,
DEFAULT_FILLTYPE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_DATARATE,
g_param_spec_int ("datarate", "Datarate",
"Timestamps buffers with number of bytes per second (0 = none)", 0,
G_MAXINT, DEFAULT_DATARATE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SYNC,
g_param_spec_boolean ("sync", "Sync", "Sync to the clock to the datarate",
DEFAULT_SYNC, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_PATTERN,
g_param_spec_string ("pattern", "pattern", "pattern", DEFAULT_PATTERN,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_LAST_MESSAGE,
g_param_spec_string ("last-message", "last-message",
"The last status message", NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SILENT,
g_param_spec_boolean ("silent", "Silent",
"Don't produce last_message events", DEFAULT_SILENT,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_SIGNAL_HANDOFFS,
g_param_spec_boolean ("signal-handoffs", "Signal handoffs",
"Send a signal before pushing the buffer", DEFAULT_SIGNAL_HANDOFFS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_DUMP,
g_param_spec_boolean ("dump", "Dump", "Dump buffer contents to stdout",
DEFAULT_DUMP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_CAN_ACTIVATE_PUSH,
g_param_spec_boolean ("can-activate-push", "Can activate push",
"Can activate in push mode", DEFAULT_CAN_ACTIVATE_PUSH,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_CAN_ACTIVATE_PULL,
g_param_spec_boolean ("can-activate-pull", "Can activate pull",
"Can activate in pull mode", DEFAULT_CAN_ACTIVATE_PULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_IS_LIVE,
g_param_spec_boolean ("is-live", "Is this a live source",
"True if the element cannot produce data in PAUSED", FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
/**
* GstFakeSrc:format
*
* Set the format of the newsegment events to produce.
*
* Since: 0.10.20
*/
g_object_class_install_property (gobject_class, PROP_FORMAT,
g_param_spec_enum ("format", "Format",
"The format of the segment events", GST_TYPE_FORMAT,
DEFAULT_FORMAT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstFakeSrc::handoff:
* @fakesrc: the fakesrc instance
* @buffer: the buffer that will be pushed
* @pad: the pad that will sent it
*
* This signal gets emitted before sending the buffer.
*/
gst_fake_src_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstFakeSrcClass, handoff), NULL, NULL,
marshal_VOID__MINIOBJECT_OBJECT, G_TYPE_NONE, 2, GST_TYPE_BUFFER,
GST_TYPE_PAD);
gstbase_src_class->is_seekable = GST_DEBUG_FUNCPTR (gst_fake_src_is_seekable);
gstbase_src_class->start = GST_DEBUG_FUNCPTR (gst_fake_src_start);
gstbase_src_class->stop = GST_DEBUG_FUNCPTR (gst_fake_src_stop);
gstbase_src_class->event = GST_DEBUG_FUNCPTR (gst_fake_src_event_handler);
gstbase_src_class->get_times = GST_DEBUG_FUNCPTR (gst_fake_src_get_times);
gstbase_src_class->create = GST_DEBUG_FUNCPTR (gst_fake_src_create);
}
}
static void
exchange_delegates_user_class_init (ExchangeDelegatesUserClass *class)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (class);
object_class->finalize = finalize;
/* signals */
signals[EDITED] =
g_signal_new ("edited",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ExchangeDelegatesUserClass, edited),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
exchange_delegates_user_init (ExchangeDelegatesUser *user)
{
}
static inline gboolean
is_delegate_role (E2kPermissionsRole role)
{
return (role == E2K_PERMISSIONS_ROLE_NONE ||
role == E2K_PERMISSIONS_ROLE_REVIEWER ||