static void
nm_device_bt_class_init (NMDeviceBtClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
NMDeviceClass *device_class = NM_DEVICE_CLASS (klass);
g_type_class_add_private (object_class, sizeof (NMDeviceBtPrivate));
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->dispose = dispose;
object_class->finalize = finalize;
device_class->get_best_auto_connection = get_best_auto_connection;
device_class->get_generic_capabilities = get_generic_capabilities;
device_class->deactivate = deactivate;
device_class->act_stage2_config = act_stage2_config;
device_class->act_stage3_ip4_config_start = act_stage3_ip4_config_start;
device_class->act_stage3_ip6_config_start = act_stage3_ip6_config_start;
device_class->check_connection_compatible = check_connection_compatible;
device_class->check_connection_available = check_connection_available;
device_class->complete_connection = complete_connection;
device_class->hwaddr_matches = hwaddr_matches;
device_class->get_hw_address = get_hw_address;
device_class->is_available = is_available;
device_class->state_changed = device_state_changed;
/* Properties */
g_object_class_install_property
(object_class, PROP_HW_ADDRESS,
g_param_spec_string (NM_DEVICE_BT_HW_ADDRESS,
"Bluetooth address",
"Bluetooth address",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_BT_NAME,
g_param_spec_string (NM_DEVICE_BT_NAME,
"Bluetooth device name",
"Bluetooth device name",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_BT_CAPABILITIES,
g_param_spec_uint (NM_DEVICE_BT_CAPABILITIES,
"Bluetooth device capabilities",
"Bluetooth device capabilities",
NM_BT_CAPABILITY_NONE, G_MAXUINT, NM_BT_CAPABILITY_NONE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
/* Signals */
signals[PPP_STATS] =
g_signal_new ("ppp-stats",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMDeviceBtClass, ppp_stats),
NULL, NULL,
_nm_marshal_VOID__UINT_UINT,
G_TYPE_NONE, 2,
G_TYPE_UINT, G_TYPE_UINT);
signals[PROPERTIES_CHANGED] =
nm_properties_changed_signal_new (object_class,
G_STRUCT_OFFSET (NMDeviceBtClass, properties_changed));
dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (klass),
&dbus_glib_nm_device_bt_object_info);
dbus_g_error_domain_register (NM_BT_ERROR, NULL, NM_TYPE_BT_ERROR);
}
static void
nm_active_connection_class_init (NMActiveConnectionClass *vpn_class)
{
GObjectClass *object_class = G_OBJECT_CLASS (vpn_class);
g_type_class_add_private (vpn_class, sizeof (NMActiveConnectionPrivate));
/* virtual methods */
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->dispose = dispose;
/* properties */
g_object_class_install_property (object_class, PROP_CONNECTION,
g_param_spec_boxed (NM_ACTIVE_CONNECTION_CONNECTION,
"Connection",
"Connection",
DBUS_TYPE_G_OBJECT_PATH,
G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_UUID,
g_param_spec_string (NM_ACTIVE_CONNECTION_UUID,
"Connection UUID",
"Connection UUID",
NULL,
G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_SPECIFIC_OBJECT,
g_param_spec_boxed (NM_ACTIVE_CONNECTION_SPECIFIC_OBJECT,
"Specific object",
"Specific object",
DBUS_TYPE_G_OBJECT_PATH,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_DEVICES,
g_param_spec_boxed (NM_ACTIVE_CONNECTION_DEVICES,
"Devices",
"Devices",
DBUS_TYPE_G_ARRAY_OF_OBJECT_PATH,
G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_STATE,
g_param_spec_uint (NM_ACTIVE_CONNECTION_STATE,
"State",
"State",
NM_ACTIVE_CONNECTION_STATE_UNKNOWN,
NM_ACTIVE_CONNECTION_STATE_DEACTIVATING,
NM_ACTIVE_CONNECTION_STATE_UNKNOWN,
G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_DEFAULT,
g_param_spec_boolean (NM_ACTIVE_CONNECTION_DEFAULT,
"Default",
"Is the default IPv4 active connection",
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_DEFAULT6,
g_param_spec_boolean (NM_ACTIVE_CONNECTION_DEFAULT6,
"Default6",
"Is the default IPv6 active connection",
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_VPN,
g_param_spec_boolean (NM_ACTIVE_CONNECTION_VPN,
"VPN",
"Is a VPN connection",
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_MASTER,
g_param_spec_boxed (NM_ACTIVE_CONNECTION_MASTER,
"Master",
"Path of master device",
DBUS_TYPE_G_OBJECT_PATH,
G_PARAM_READABLE));
/* Signals */
signals[PROPERTIES_CHANGED] =
nm_properties_changed_signal_new (object_class,
G_STRUCT_OFFSET (NMActiveConnectionClass, properties_changed));
dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (vpn_class),
&dbus_glib_nm_active_connection_object_info);
}
static void
e_minicard_label_class_init (EMinicardLabelClass *klass)
{
GObjectClass *object_class;
GnomeCanvasItemClass *item_class;
object_class = G_OBJECT_CLASS (klass);
item_class = (GnomeCanvasItemClass *) klass;
klass->style_set = e_minicard_label_style_set;
parent_class = g_type_class_peek_parent (klass);
object_class->set_property = e_minicard_label_set_property;
object_class->get_property = e_minicard_label_get_property;
/* object_class->destroy = e_minicard_label_destroy; */
g_object_class_install_property (object_class, PROP_WIDTH,
g_param_spec_double ("width",
"Width",
NULL,
0.0, G_MAXDOUBLE, 10.0,
G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_HEIGHT,
g_param_spec_double ("height",
"Height",
NULL,
0.0, G_MAXDOUBLE, 10.0,
G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_HAS_FOCUS,
g_param_spec_boolean ("has_focus",
"Has Focus",
NULL,
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_FIELD,
g_param_spec_string ("field",
"Field",
NULL,
NULL,
G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_FIELDNAME,
g_param_spec_string ("fieldname",
"Field Name",
NULL,
NULL,
G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_TEXT_MODEL,
g_param_spec_object ("text_model",
"Text Model",
NULL,
E_TYPE_TEXT_MODEL,
G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_MAX_FIELD_NAME_WIDTH,
g_param_spec_double ("max_field_name_length",
"Max field name length",
NULL,
-1.0, G_MAXDOUBLE, -1.0,
G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_EDITABLE,
g_param_spec_boolean ("editable",
"Editable",
NULL,
FALSE,
G_PARAM_READWRITE));
e_minicard_label_signals[STYLE_SET] =
g_signal_new ("style_set",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (EMinicardLabelClass, style_set),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GTK_TYPE_STYLE);
/* GnomeCanvasItem method overrides */
item_class->realize = e_minicard_label_realize;
item_class->unrealize = e_minicard_label_unrealize;
item_class->event = e_minicard_label_event;
}
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
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
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
mate_color_picker_class_init (MateColorPickerClass *class)
{
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,
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));
}
static void
ibus_input_context_class_init (IBusInputContextClass *klass)
{
IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (klass);
IBusProxyClass *proxy_class = IBUS_PROXY_CLASS (klass);
g_type_class_add_private (klass, sizeof (IBusInputContextPrivate));
ibus_object_class->destroy = (IBusObjectDestroyFunc) ibus_input_context_real_destroy;
proxy_class->ibus_signal = ibus_input_context_ibus_signal;
/* install signals */
/**
* IBusInputContext::enabled:
* @context: An IBusInputContext.
*
* Emitted when an IME is enabled.
*/
context_signals[ENABLED] =
g_signal_new (I_("enabled"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::disabled:
* @context: An IBusInputContext.
*
* Emitted when an IME is disabled.
*/
context_signals[DISABLED] =
g_signal_new (I_("disabled"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::commit-text:
* @context: An IBusInputContext.
* @text: Text to be committed.
*
* Emitted when the text is going to be committed.
*
* (Note: The text object is floating, and it will be released after the signal.
* If singal handler want to keep the object, the handler should use g_object_ref_sink()
* to get the ownership of the object.)
*/
context_signals[COMMIT_TEXT] =
g_signal_new (I_("commit-text"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
IBUS_TYPE_TEXT);
/**
* IBusInputContext::forward-key-event:
* @context: An IBusInputContext.
* @keyval: Key symbol of the keyboard event.
* @keycode: Key symbol of the keyboard event.
* @modifiers: Key modifier flags.
*
* Emitted to forward key event from IME to client of IME.
*/
context_signals[FORWARD_KEY_EVENT] =
g_signal_new (I_("forward-key-event"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__UINT_UINT_UINT,
G_TYPE_NONE,
3,
G_TYPE_UINT,
G_TYPE_UINT,
G_TYPE_UINT);
/**
* IBusInputContext::delete-surrounding-text:
* @context: An IBusInputContext.
* @offset: the character offset from the cursor position of the text to be deleted.
* A negative value indicates a position before the cursor.
* @n_chars: the number of characters to be deleted.
*
* Emitted to delete surrounding text event from IME to client of IME.
*/
context_signals[DELETE_SURROUNDING_TEXT] =
g_signal_new (I_("delete-surrounding-text"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__INT_UINT,
G_TYPE_NONE,
2,
G_TYPE_INT,
G_TYPE_UINT);
/**
* IBusInputContext::update-preedit-text:
* @context: An IBusInputContext.
* @text: Text to be updated.
* @cursor_pos: Cursor position.
* @visible: Whether the update is visible.
*
* Emitted to update preedit text.
*
* (Note: The text object is floating, and it will be released after the signal.
* If singal handler want to keep the object, the handler should use g_object_ref_sink()
* to get the ownership of the object.)
*/
context_signals[UPDATE_PREEDIT_TEXT] =
g_signal_new (I_("update-preedit-text"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__OBJECT_UINT_BOOLEAN,
G_TYPE_NONE,
3,
IBUS_TYPE_TEXT,
G_TYPE_UINT,
G_TYPE_BOOLEAN);
/**
* IBusInputContext::show-preedit-text:
* @context: An IBusInputContext.
*
* Emitted to show preedit text.
*/
context_signals[SHOW_PREEDIT_TEXT] =
g_signal_new (I_("show-preedit-text"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::hide-preedit-text:
* @context: An IBusInputContext.
*
* Emitted to hide preedit text.
*/
context_signals[HIDE_PREEDIT_TEXT] =
g_signal_new (I_("hide-preedit-text"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::update-auxiliary-text:
* @context: An IBusInputContext.
*
* Emitted to hide auxilary text.
*
* (Note: The text object is floating, and it will be released after the signal.
* If singal handler want to keep the object, the handler should use g_object_ref_sink()
* to get the ownership of the object.)
*/
context_signals[UPDATE_AUXILIARY_TEXT] =
g_signal_new (I_("update-auxiliary-text"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__OBJECT_BOOLEAN,
G_TYPE_NONE, 2,
IBUS_TYPE_TEXT,
G_TYPE_BOOLEAN);
/**
* IBusInputContext::show-auxiliary-text:
* @context: An IBusInputContext.
*
* Emitted to show auxiliary text.
*/
context_signals[SHOW_AUXILIARY_TEXT] =
g_signal_new (I_("show-auxiliary-text"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::hide-auxiliary-text:
* @context: An IBusInputContext.
*
* Emitted to hide auxiliary text.
*/
context_signals[HIDE_AUXILIARY_TEXT] =
g_signal_new (I_("hide-auxiliary-text"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::update-lookup-table:
* @context: An IBusInputContext.
* @table: An IBusLookupTable to be updated.
* @visible: Whether the table should be visible.
*
* Emitted to update lookup table.
*
* (Note: The table object is floating, and it will be released after the signal.
* If singal handler want to keep the object, the handler should use g_object_ref_sink()
* to get the ownership of the object.)
*/
context_signals[UPDATE_LOOKUP_TABLE] =
g_signal_new (I_("update-lookup-table"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__OBJECT_BOOLEAN,
G_TYPE_NONE, 2,
IBUS_TYPE_LOOKUP_TABLE,
G_TYPE_BOOLEAN);
/**
* IBusInputContext::show-lookup-table:
* @context: An IBusInputContext.
*
* Emitted to show lookup table.
*/
context_signals[SHOW_LOOKUP_TABLE] =
g_signal_new (I_("show-lookup-table"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::hide-lookup-table:
* @context: An IBusInputContext.
*
* Emitted to hide lookup table.
*/
context_signals[HIDE_LOOKUP_TABLE] =
g_signal_new (I_("hide-lookup-table"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::page-up-lookup-table:
* @context: An IBusInputContext.
*
* Emitted to view the previous page of lookup table.
*/
context_signals[PAGE_UP_LOOKUP_TABLE] =
g_signal_new (I_("page-up-lookup-table"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::page-down-lookup-table:
* @context: An IBusInputContext.
*
* Emitted to view the next page of lookup table.
*/
context_signals[PAGE_DOWN_LOOKUP_TABLE] =
g_signal_new (I_("page-down-lookup-table"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::cursor-up-lookup-table:
* @context: An IBusInputContext.
*
* Emitted to select previous candidate of lookup table.
*/
context_signals[CURSOR_UP_LOOKUP_TABLE] =
g_signal_new (I_("cursor-up-lookup-table"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* IBusInputContext::cursor-down-lookup-table:
* @context: An IBusInputContext.
*
* Emitted to select next candidate of lookup table.
*/
context_signals[CURSOR_DOWN_LOOKUP_TABLE] =
g_signal_new (I_("cursor-down-lookup-table"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__VOID,
G_TYPE_NONE,
0);
/**
* IBusInputContext::register-properties:
* @context: An IBusInputContext.
* @props: An IBusPropList that contains properties.
*
* Emitted to register the properties in @props.
*
* (Note: The props object is floating, and it will be released after the signal.
* If singal handler want to keep the object, the handler should use g_object_ref_sink()
* to get the ownership of the object.)
*/
context_signals[REGISTER_PROPERTIES] =
g_signal_new (I_("register-properties"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
IBUS_TYPE_PROP_LIST);
/**
* IBusInputContext::update-property:
* @context: An IBusInputContext.
* @prop: The IBusProperty to be updated.
*
* Emitted to update the property @prop.
*
* (Note: The prop object is floating, and it will be released after the signal.
* If singal handler want to keep the object, the handler should use g_object_ref_sink()
* to get the ownership of the object.)
*/
context_signals[UPDATE_PROPERTY] =
g_signal_new (I_("update-property"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
ibus_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
IBUS_TYPE_PROPERTY);
}
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
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
thunar_folder_class_init (ThunarFolderClass *klass)
{
GObjectClass *gobject_class;
/* determine the parent type class */
thunar_folder_parent_class = g_type_class_peek_parent (klass);
gobject_class = G_OBJECT_CLASS (klass);
gobject_class->finalize = thunar_folder_finalize;
gobject_class->get_property = thunar_folder_get_property;
/**
* ThunarFolder::loading:
*
* Tells whether the contents of the #ThunarFolder are
* currently being loaded.
**/
g_object_class_install_property (gobject_class,
PROP_LOADING,
g_param_spec_boolean ("loading",
"loading",
"loading",
FALSE,
EXO_PARAM_READABLE));
/**
* ThunarFolder::error:
* @folder : a #ThunarFolder.
* @error : the #GError describing the problem.
*
* Emitted when the #ThunarFolder fails to completly
* load the directory content because of an error.
**/
folder_signals[ERROR] =
g_signal_new (I_("error"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ThunarFolderClass, error),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_POINTER);
/**
* ThunarFolder::files-added:
*
* Emitted by the #ThunarFolder whenever new files have
* been added to a particular folder.
**/
folder_signals[FILES_ADDED] =
g_signal_new (I_("files-added"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ThunarFolderClass, files_added),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_POINTER);
/**
* ThunarFolder::files-removed:
*
* Emitted by the #ThunarFolder whenever a bunch of files
* is removed from the folder, which means they are not
* necessarily deleted from disk. This can be used to implement
* the reload of folders, which take longer to load.
**/
folder_signals[FILES_REMOVED] =
g_signal_new (I_("files-removed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ThunarFolderClass, files_removed),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_POINTER);
}
static void
matecomponent_control_class_init (MateComponentControlClass *klass)
{
GObjectClass *object_class = (GObjectClass *)klass;
MateComponentObjectClass *matecomponent_object_class = (MateComponentObjectClass *)klass;
POA_MateComponent_Control__epv *epv;
matecomponent_control_parent_class = g_type_class_peek_parent (klass);
control_signals [PLUG_CREATED] =
g_signal_new ("plug_created",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MateComponentControlClass, plug_created),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
control_signals [DISCONNECTED] =
g_signal_new ("disconnected",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MateComponentControlClass, disconnected),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
control_signals [SET_FRAME] =
g_signal_new ("set_frame",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MateComponentControlClass, set_frame),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
control_signals [ACTIVATE] =
g_signal_new ("activate",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MateComponentControlClass, activate),
NULL, NULL,
g_cclosure_marshal_VOID__BOOLEAN,
G_TYPE_NONE, 1,
G_TYPE_BOOLEAN);
object_class->finalize = matecomponent_control_finalize;
matecomponent_object_class->destroy = matecomponent_control_destroy;
epv = &klass->epv;
epv->getProperties = impl_MateComponent_Control_getProperties;
epv->getDesiredSize = impl_MateComponent_Control_getDesiredSize;
epv->getAccessible = NULL;
epv->getWindowId = impl_MateComponent_Control_getWindowId;
epv->getPopupContainer = impl_MateComponent_Control_getPopupContainer;
epv->setFrame = impl_MateComponent_Control_setFrame;
epv->setSize = impl_MateComponent_Control_setSize;
epv->setState = impl_MateComponent_Control_setState;
epv->activate = impl_MateComponent_Control_activate;
epv->focus = impl_MateComponent_Control_focus;
}
static void
gegl_gtk_view_class_init(GeglGtkViewClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
gobject_class->finalize = finalize;
gobject_class->set_property = set_property;
gobject_class->get_property = get_property;
#ifdef HAVE_GTK2
widget_class->expose_event = expose_event;
#endif
#ifdef HAVE_GTK3
widget_class->draw = draw;
#endif
g_object_class_install_property(gobject_class, PROP_X,
g_param_spec_float("x",
"X",
"X origin",
-G_MAXFLOAT, G_MAXFLOAT, 0.0,
G_PARAM_CONSTRUCT |
G_PARAM_READWRITE));
g_object_class_install_property(gobject_class, PROP_Y,
g_param_spec_float("y",
"Y",
"Y origin",
-G_MAXFLOAT, G_MAXFLOAT, 0.0,
G_PARAM_CONSTRUCT |
G_PARAM_READWRITE));
g_object_class_install_property(gobject_class, PROP_SCALE,
g_param_spec_double("scale",
"Scale",
"Zoom factor",
0.0, 100.0, 1.00,
G_PARAM_CONSTRUCT |
G_PARAM_READWRITE));
g_object_class_install_property(gobject_class, PROP_NODE,
g_param_spec_object("node",
"Node",
"The node to render",
G_TYPE_OBJECT,
G_PARAM_CONSTRUCT |
G_PARAM_READWRITE));
g_object_class_install_property(gobject_class, PROP_BLOCK,
g_param_spec_boolean("block",
"Blocking render",
"Make sure all data requested to blit is generated.",
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property(gobject_class, PROP_AUTOSCALE_POLICY,
g_param_spec_enum("autoscale-policy",
"Autoscale policy", "The autoscaling behavior used",
GEGL_GTK_TYPE_VIEW_AUTOSCALE,
GEGL_GTK_VIEW_AUTOSCALE_CONTENT,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
/* XXX: maybe we should just allow a second GeglNode to be specified for background? */
/**
* GeglGtkView::draw-background:
* @widget: the #GeglGtkView widget that emitted the signal
* @cr: the #CairoContext to render to
* @rect: the area that was updated, view coordinates
*
* Emitted during painting, before the node contents has been rendered.
* Allows consumers to draw a custom background for the widget.
*
* Note:
* Manipulating the view widget in the signal handler is not supported.
* This signal is only available if GEGL-GTK was build with Cairo GObject support.
**/
/**
* GeglGtkView::draw-overlay:
* @widget: the #GeglGtkView widget that emitted the signal
* @cr: the #CairoContext to render to
* @rect: the area that was updated, in view coordinates
*
* Emitted during painting, before the node contents has been rendered.
*
* Allows consumers to draw an overlay for the widget, for instance
* for simple user interface elements.
*
* Note:
* Manipulating the view widget in the signal handler is not supported.
* This signal is only available if GEGL-GTK was build with Cairo GObject support.
**/
#ifdef HAVE_CAIRO_GOBJECT
gegl_view_signals[SIGNAL_DRAW_BACKGROUND] =
g_signal_new("draw-background",
G_TYPE_FROM_CLASS(klass),
0,
0,
NULL,
NULL,
gegl_gtk_marshal_VOID__BOXED_BOXED,
G_TYPE_NONE, 2, CAIRO_GOBJECT_TYPE_CONTEXT, GDK_TYPE_RECTANGLE);
gegl_view_signals[SIGNAL_DRAW_OVERLAY] =
g_signal_new("draw-overlay",
G_TYPE_FROM_CLASS(klass),
0,
0,
NULL,
NULL,
gegl_gtk_marshal_VOID__BOXED_BOXED,
G_TYPE_NONE, 2, CAIRO_GOBJECT_TYPE_CONTEXT, GDK_TYPE_RECTANGLE);
#endif
}
static VALUE
rg_hash(VALUE self)
{
flags_holder* p = flags_get_holder(self);
return UINT2NUM(p->value ^ G_TYPE_FROM_CLASS(p->gclass));
}
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_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);
}
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
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");
}
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;
}
/* MudSubwindow class functions */
static void
mud_subwindow_class_init (MudSubwindowClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
/* Override base object constructor */
object_class->constructor = mud_subwindow_constructor;
object_class->constructed = mud_subwindow_constructed;
/* Override base object's finalize */
object_class->finalize = mud_subwindow_finalize;
/* Override base object property methods */
object_class->set_property = mud_subwindow_set_property;
object_class->get_property = mud_subwindow_get_property;
/* Add private data to class */
g_type_class_add_private(klass, sizeof(MudSubwindowPrivate));
/* Install Properties */
g_object_class_install_property(object_class,
PROP_PARENT,
g_param_spec_object("parent-view",
"Parent View",
"The parent MudSubwindow",
MUD_TYPE_CONNECTION_VIEW,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property(object_class,
PROP_TITLE,
g_param_spec_string("title",
"Title",
"The visible Title of the subwindow.",
NULL,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT));
g_object_class_install_property(object_class,
PROP_IDENT,
g_param_spec_string("identifier",
"Ident",
"The identifier of the subwindow.",
NULL,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property(object_class,
PROP_WIDTH,
g_param_spec_uint("width",
"Width",
"The width of the terminal in columns.",
1,
1024,
40,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property(object_class,
PROP_HEIGHT,
g_param_spec_uint("height",
"Height",
"The height of the terminal in rows.",
1,
1024,
40,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property(object_class,
PROP_OLD_HEIGHT,
g_param_spec_uint("old-height",
"Old Height",
"The old height of the terminal in rows.",
0,
1024,
0,
G_PARAM_READWRITE));
g_object_class_install_property(object_class,
PROP_OLD_WIDTH,
g_param_spec_uint("old-width",
"Old Width",
"The old width of the terminal in rows.",
0,
1024,
0,
G_PARAM_READWRITE));
g_object_class_install_property(object_class,
PROP_VISIBLE,
g_param_spec_boolean("visible",
"Visible",
"True if subwindow is visible.",
TRUE,
G_PARAM_READWRITE));
g_object_class_install_property(object_class,
PROP_VIEW_HIDDEN,
g_param_spec_boolean("view-hidden",
"View Hidden",
"True if subwindow is hidden by the view.",
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property(object_class,
PROP_INPUT,
g_param_spec_boolean("input-enabled",
"Input Enabled",
"True if subwindow accepts input.",
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property(object_class,
PROP_SCROLL,
g_param_spec_boolean("scroll-enabled",
"Scroll Enabled",
"True if subwindow scrolls.",
TRUE,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT));
/* Register Signals */
mud_subwindow_signal[RESIZED] =
g_signal_new("resized",
G_TYPE_FROM_CLASS(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
mud_subwindow_signal[INPUT] =
g_signal_new("input-received",
G_TYPE_FROM_CLASS(object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_HOOKS,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
}
static void
ges_track_object_class_init (GESTrackObjectClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackObjectPrivate));
object_class->get_property = ges_track_object_get_property;
object_class->set_property = ges_track_object_set_property;
object_class->dispose = ges_track_object_dispose;
object_class->finalize = ges_track_object_finalize;
/**
* GESTrackObject:start
*
* The position of the object in the container #GESTrack (in nanoseconds).
*/
properties[PROP_START] = g_param_spec_uint64 ("start", "Start",
"The position in the container", 0, G_MAXUINT64, 0, G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_START,
properties[PROP_START]);
/**
* GESTrackObject:in-point
*
* The in-point at which this #GESTrackObject will start outputting data
* from its contents (in nanoseconds).
*
* Ex : an in-point of 5 seconds means that the first outputted buffer will
* be the one located 5 seconds in the controlled resource.
*/
properties[PROP_INPOINT] =
g_param_spec_uint64 ("in-point", "In-point", "The in-point", 0,
G_MAXUINT64, 0, G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_INPOINT,
properties[PROP_INPOINT]);
/**
* GESTrackObject:duration
*
* The duration (in nanoseconds) which will be used in the container #GESTrack
* starting from 'in-point'.
*
*/
properties[PROP_DURATION] =
g_param_spec_uint64 ("duration", "Duration", "The duration to use", 0,
G_MAXUINT64, GST_SECOND, G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_DURATION,
properties[PROP_DURATION]);
/**
* GESTrackObject:priority
*
* The priority of the object within the containing #GESTrack.
* If two objects intersect over the same region of time, the @priority
* property is used to decide which one takes precedence.
*
* The highest priority (that supercedes everything) is 0, and then lowering
* priorities go in increasing numerical value (with #G_MAXUINT64 being the
* lowest priority).
*/
properties[PROP_PRIORITY] = g_param_spec_uint ("priority", "Priority",
"The priority of the object", 0, G_MAXUINT, 0, G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_PRIORITY,
properties[PROP_PRIORITY]);
/**
* GESTrackObject:active
*
* Whether the object should be taken into account in the #GESTrack output.
* If #FALSE, then its contents will not be used in the resulting track.
*/
properties[PROP_ACTIVE] =
g_param_spec_boolean ("active", "Active", "Use object in output", TRUE,
G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_ACTIVE,
properties[PROP_ACTIVE]);
/**
* GESTrackObject::deep-notify:
* @track_object: a #GESTrackObject
* @prop_object: the object that originated the signal
* @prop: the property that changed
*
* The deep notify signal is used to be notified of property changes of all
* the childs of @track_object
*/
ges_track_object_signals[DEEP_NOTIFY] =
g_signal_new ("deep-notify", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED |
G_SIGNAL_NO_HOOKS, 0, NULL, NULL, gst_marshal_VOID__OBJECT_PARAM,
G_TYPE_NONE, 2, GST_TYPE_ELEMENT, G_TYPE_PARAM);
klass->create_gnl_object = ges_track_object_create_gnl_object_func;
/* There is no 'get_props_hashtable' default implementation */
klass->get_props_hastable = NULL;
klass->list_children_properties = default_list_children_properties;
}
static void
gst_v4l2src_class_init (GstV4l2SrcClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
GstBaseSrcClass *basesrc_class;
GstPushSrcClass *pushsrc_class;
gobject_class = G_OBJECT_CLASS (klass);
element_class = GST_ELEMENT_CLASS (klass);
basesrc_class = GST_BASE_SRC_CLASS (klass);
pushsrc_class = GST_PUSH_SRC_CLASS (klass);
gobject_class->finalize = (GObjectFinalizeFunc) gst_v4l2src_finalize;
gobject_class->set_property = gst_v4l2src_set_property;
gobject_class->get_property = gst_v4l2src_get_property;
element_class->change_state = gst_v4l2src_change_state;
gst_v4l2_object_install_properties_helper (gobject_class,
DEFAULT_PROP_DEVICE);
/**
* GstV4l2Src::prepare-format:
* @v4l2src: the v4l2src instance
* @fd: the file descriptor of the current device
* @caps: the caps of the format being set
*
* This signal gets emitted before calling the v4l2 VIDIOC_S_FMT ioctl
* (set format). This allows for any custom configuration of the device to
* happen prior to the format being set.
* This is mostly useful for UVC H264 encoding cameras which need the H264
* Probe & Commit to happen prior to the normal Probe & Commit.
*
* Since: 0.10.32
*/
gst_v4l2_signals[SIGNAL_PRE_SET_FORMAT] = g_signal_new ("prepare-format",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL, G_TYPE_NONE, 2, G_TYPE_INT, GST_TYPE_CAPS);
gst_element_class_set_static_metadata (element_class,
"Video (video4linux2) Source", "Source/Video",
"Reads frames from a Video4Linux2 device",
"Edgard Lima <*****@*****.**>, "
"Stefan Kost <*****@*****.**>");
gst_element_class_add_pad_template
(element_class,
gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
gst_v4l2_object_get_all_caps ()));
basesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_v4l2src_get_caps);
basesrc_class->set_caps = GST_DEBUG_FUNCPTR (gst_v4l2src_set_caps);
basesrc_class->start = GST_DEBUG_FUNCPTR (gst_v4l2src_start);
basesrc_class->unlock = GST_DEBUG_FUNCPTR (gst_v4l2src_unlock);
basesrc_class->unlock_stop = GST_DEBUG_FUNCPTR (gst_v4l2src_unlock_stop);
basesrc_class->stop = GST_DEBUG_FUNCPTR (gst_v4l2src_stop);
basesrc_class->query = GST_DEBUG_FUNCPTR (gst_v4l2src_query);
basesrc_class->fixate = GST_DEBUG_FUNCPTR (gst_v4l2src_fixate);
basesrc_class->negotiate = GST_DEBUG_FUNCPTR (gst_v4l2src_negotiate);
basesrc_class->decide_allocation =
GST_DEBUG_FUNCPTR (gst_v4l2src_decide_allocation);
pushsrc_class->fill = GST_DEBUG_FUNCPTR (gst_v4l2src_fill);
klass->v4l2_class_devices = NULL;
GST_DEBUG_CATEGORY_INIT (v4l2src_debug, "v4l2src", 0, "V4L2 source element");
}
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
gst_app_src_class_init (GstAppSrcClass * klass)
{
GObjectClass *gobject_class = (GObjectClass *) klass;
GstBaseSrcClass *basesrc_class = (GstBaseSrcClass *) klass;
gobject_class->dispose = gst_app_src_dispose;
gobject_class->finalize = gst_app_src_finalize;
gobject_class->set_property = gst_app_src_set_property;
gobject_class->get_property = gst_app_src_get_property;
/**
* GstAppSrc::caps
*
* The GstCaps that will negotiated downstream and will be put
* on outgoing buffers.
*/
g_object_class_install_property (gobject_class, PROP_CAPS,
g_param_spec_boxed ("caps", "Caps",
"The allowed caps for the src pad", GST_TYPE_CAPS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::format
*
* The format to use for segment events. When the source is producing
* timestamped buffers this property should be set to GST_FORMAT_TIME.
*/
g_object_class_install_property (gobject_class, PROP_FORMAT,
g_param_spec_enum ("format", "Format",
"The format of the segment events and seek", GST_TYPE_FORMAT,
DEFAULT_PROP_FORMAT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::size
*
* The total size in bytes of the data stream. If the total size is known, it
* is recommended to configure it with this property.
*/
g_object_class_install_property (gobject_class, PROP_SIZE,
g_param_spec_int64 ("size", "Size",
"The size of the data stream in bytes (-1 if unknown)",
-1, G_MAXINT64, DEFAULT_PROP_SIZE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::stream-type
*
* The type of stream that this source is producing. For seekable streams the
* application should connect to the seek-data signal.
*/
g_object_class_install_property (gobject_class, PROP_STREAM_TYPE,
g_param_spec_enum ("stream-type", "Stream Type",
"the type of the stream", GST_TYPE_APP_STREAM_TYPE,
DEFAULT_PROP_STREAM_TYPE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::max-bytes
*
* The maximum amount of bytes that can be queued internally.
* After the maximum amount of bytes are queued, appsrc will emit the
* "enough-data" signal.
*/
g_object_class_install_property (gobject_class, PROP_MAX_BYTES,
g_param_spec_uint64 ("max-bytes", "Max bytes",
"The maximum number of bytes to queue internally (0 = unlimited)",
0, G_MAXUINT64, DEFAULT_PROP_MAX_BYTES,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::block
*
* When max-bytes are queued and after the enough-data signal has been emited,
* block any further push-buffer calls until the amount of queued bytes drops
* below the max-bytes limit.
*/
g_object_class_install_property (gobject_class, PROP_BLOCK,
g_param_spec_boolean ("block", "Block",
"Block push-buffer when max-bytes are queued",
DEFAULT_PROP_BLOCK, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::is-live
*
* Instruct the source to behave like a live source. This includes that it
* will only push out buffers in the PLAYING state.
*/
g_object_class_install_property (gobject_class, PROP_IS_LIVE,
g_param_spec_boolean ("is-live", "Is Live",
"Whether to act as a live source",
DEFAULT_PROP_IS_LIVE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::min-latency
*
* The minimum latency of the source. A value of -1 will use the default
* latency calculations of #GstBaseSrc.
*/
g_object_class_install_property (gobject_class, PROP_MIN_LATENCY,
g_param_spec_int64 ("min-latency", "Min Latency",
"The minimum latency (-1 = default)",
-1, G_MAXINT64, DEFAULT_PROP_MIN_LATENCY,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::max-latency
*
* The maximum latency of the source. A value of -1 means an unlimited amout
* of latency.
*/
g_object_class_install_property (gobject_class, PROP_MAX_LATENCY,
g_param_spec_int64 ("max-latency", "Max Latency",
"The maximum latency (-1 = unlimited)",
-1, G_MAXINT64, DEFAULT_PROP_MAX_LATENCY,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::emit-signals
*
* Make appsrc emit the "need-data", "enough-data" and "seek-data" signals.
* This option is by default enabled for backwards compatibility reasons but
* can disabled when needed because signal emission is expensive.
*
* Since: 0.10.23
*/
g_object_class_install_property (gobject_class, PROP_EMIT_SIGNALS,
g_param_spec_boolean ("emit-signals", "Emit signals",
"Emit new-preroll and new-buffer signals", DEFAULT_PROP_EMIT_SIGNALS,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstAppSrc::need-data:
* @appsrc: the appsrc element that emited the signal
* @length: the amount of bytes needed.
*
* Signal that the source needs more data. In the callback or from another
* thread you should call push-buffer or end-of-stream.
*
* @length is just a hint and when it is set to -1, any number of bytes can be
* pushed into @appsrc.
*
* You can call push-buffer multiple times until the enough-data signal is
* fired.
*/
gst_app_src_signals[SIGNAL_NEED_DATA] =
g_signal_new ("need-data", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstAppSrcClass, need_data),
NULL, NULL, __gst_app_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
/**
* GstAppSrc::enough-data:
* @appsrc: the appsrc element that emited the signal
*
* Signal that the source has enough data. It is recommended that the
* application stops calling push-buffer until the need-data signal is
* emited again to avoid excessive buffer queueing.
*/
gst_app_src_signals[SIGNAL_ENOUGH_DATA] =
g_signal_new ("enough-data", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstAppSrcClass, enough_data),
NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
/**
* GstAppSrc::seek-data:
* @appsrc: the appsrc element that emited the signal
* @offset: the offset to seek to
*
* Seek to the given offset. The next push-buffer should produce buffers from
* the new @offset.
* This callback is only called for seekable stream types.
*
* Returns: %TRUE if the seek succeeded.
*/
gst_app_src_signals[SIGNAL_SEEK_DATA] =
g_signal_new ("seek-data", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstAppSrcClass, seek_data),
NULL, NULL, __gst_app_marshal_BOOLEAN__UINT64, G_TYPE_BOOLEAN, 1,
G_TYPE_UINT64);
/**
* GstAppSrc::push-buffer:
* @appsrc: the appsrc
* @buffer: a buffer to push
*
* Adds a buffer to the queue of buffers that the appsrc element will
* push to its source pad. This function does not take ownership of the
* buffer so the buffer needs to be unreffed after calling this function.
*
* When the block property is TRUE, this function can block until free space
* becomes available in the queue.
*/
gst_app_src_signals[SIGNAL_PUSH_BUFFER] =
g_signal_new ("push-buffer", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSrcClass,
push_buffer), NULL, NULL, __gst_app_marshal_ENUM__OBJECT,
GST_TYPE_FLOW_RETURN, 1, GST_TYPE_BUFFER);
/**
* GstAppSrc::end-of-stream:
* @appsrc: the appsrc
*
* Notify @appsrc that no more buffer are available.
*/
gst_app_src_signals[SIGNAL_END_OF_STREAM] =
g_signal_new ("end-of-stream", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstAppSrcClass,
end_of_stream), NULL, NULL, __gst_app_marshal_ENUM__VOID,
GST_TYPE_FLOW_RETURN, 0, G_TYPE_NONE);
basesrc_class->create = gst_app_src_create;
basesrc_class->start = gst_app_src_start;
basesrc_class->stop = gst_app_src_stop;
basesrc_class->unlock = gst_app_src_unlock;
basesrc_class->unlock_stop = gst_app_src_unlock_stop;
basesrc_class->do_seek = gst_app_src_do_seek;
basesrc_class->is_seekable = gst_app_src_is_seekable;
basesrc_class->check_get_range = gst_app_src_check_get_range;
basesrc_class->get_size = gst_app_src_do_get_size;
basesrc_class->get_size = gst_app_src_do_get_size;
basesrc_class->query = gst_app_src_query;
klass->push_buffer = gst_app_src_push_buffer_action;
klass->end_of_stream = gst_app_src_end_of_stream;
g_type_class_add_private (klass, sizeof (GstAppSrcPrivate));
}
static void
gst_render_bridge_class_init (GstBufferClassSinkClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
GstBaseSinkClass *basesink_class;
GST_DEBUG ("ENTER");
gobject_class = G_OBJECT_CLASS (klass);
element_class = GST_ELEMENT_CLASS (klass);
basesink_class = GST_BASE_SINK_CLASS (klass);
gobject_class->dispose = gst_render_bridge_dispose;
gobject_class->finalize = (GObjectFinalizeFunc) gst_render_bridge_finalize;
gobject_class->set_property = gst_render_bridge_set_property;
gobject_class->get_property = gst_render_bridge_get_property;
element_class->change_state = gst_render_bridge_change_state;
/**
* GstBufferClassSink:device
*
* The path to bc_cat device file
*/
g_object_class_install_property (gobject_class, PROP_DEVICE,
g_param_spec_string ("device", "Device", "Device location",
PROP_DEF_DEVICE, G_PARAM_READWRITE));
/**
* GstBufferClassSink:queue-size
*
* Number of buffers to be enqueued in the driver in streaming mode
*/
g_object_class_install_property (gobject_class, PROP_QUEUE_SIZE,
g_param_spec_uint ("queue-size", "Queue size",
"Number of buffers to be enqueued in the driver in streaming mode",
GST_BC_MIN_BUFFERS, GST_BC_MAX_BUFFERS, PROP_DEF_QUEUE_SIZE,
G_PARAM_READWRITE));
/**
* GstBufferClassSink:gl-example
*
* Controls which example 3d code to use if application does not register
* it's own render callback
*/
g_object_class_install_property (gobject_class, PROP_GL_EXAMPLE,
g_param_spec_uint ("gl-example",
"Whether to use OpenGLES 1.x or 2.x example",
"Controls which example 3d code to use if application does not register "
"it's own render callback", 1, 2, 1, G_PARAM_WRITABLE));
/**
* GstBufferClassSink::init:
* @bcsink: the #GstBufferClassSink
* @buffercount: the number of buffers used
*
* Will be emitted after buffers are allocated, to give the application
* an opportunity to bind the surfaces
*/
signals[SIG_INIT] =
g_signal_new ("init", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, 0,
NULL, NULL, gst_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
/**
* GstBufferClassSink::render:
* @bcsink: the #GstBufferClassSink
* @bufferindex: the index of the buffer to render
*
* Will be emitted when a new buffer is ready to be rendered
*/
signals[SIG_RENDER] =
g_signal_new ("render", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, 0,
NULL, NULL, gst_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
/**
* GstBufferClassSink::close:
* @bcsink: the #GstBufferClassSink
*
* Will be emitted when the device is closed
*/
signals[SIG_CLOSE] =
g_signal_new ("close", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, 0,
NULL, NULL, gst_marshal_VOID__VOID, G_TYPE_NONE, 0);
#if 0
basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_render_bridge_get_caps);
#endif
basesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_render_bridge_set_caps);
basesink_class->buffer_alloc = GST_DEBUG_FUNCPTR (gst_render_bridge_buffer_alloc);
basesink_class->render = GST_DEBUG_FUNCPTR (gst_render_bridge_show_frame);
}
static void
empathy_account_class_init (EmpathyAccountClass *empathy_account_class)
{
GObjectClass *object_class = G_OBJECT_CLASS (empathy_account_class);
g_type_class_add_private (empathy_account_class,
sizeof (EmpathyAccountPriv));
object_class->set_property = empathy_account_set_property;
object_class->get_property = empathy_account_get_property;
object_class->dispose = empathy_account_dispose;
object_class->finalize = empathy_account_finalize;
object_class->constructed = empathy_account_constructed;
g_object_class_install_property (object_class, PROP_ENABLED,
g_param_spec_boolean ("enabled",
"Enabled",
"Whether this account is enabled or not",
FALSE,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
g_object_class_install_property (object_class, PROP_READY,
g_param_spec_boolean ("ready",
"Ready",
"Whether this account is ready to be used",
FALSE,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_PRESENCE,
g_param_spec_uint ("presence",
"Presence",
"The account connections presence type",
0,
NUM_TP_CONNECTION_PRESENCE_TYPES,
TP_CONNECTION_PRESENCE_TYPE_UNSET,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_STATUS,
g_param_spec_string ("status",
"Status",
"The Status string of the account",
NULL,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_STATUS_MESSAGE,
g_param_spec_string ("status-message",
"status-message",
"The Status message string of the account",
NULL,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_CONNECTION_STATUS,
g_param_spec_uint ("connection-status",
"ConnectionStatus",
"The accounts connections status type",
0,
NUM_TP_CONNECTION_STATUSES,
TP_CONNECTION_STATUS_DISCONNECTED,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_CONNECTION_STATUS_REASON,
g_param_spec_uint ("connection-status-reason",
"ConnectionStatusReason",
"The account connections status reason",
0,
NUM_TP_CONNECTION_STATUS_REASONS,
TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_CONNECTION,
g_param_spec_object ("connection",
"Connection",
"The accounts connection",
TP_TYPE_CONNECTION,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_UNIQUE_NAME,
g_param_spec_string ("unique-name",
"UniqueName",
"The accounts unique name",
NULL,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_DBUS_DAEMON,
g_param_spec_object ("dbus-daemon",
"dbus-daemon",
"The Tp Dbus daemon on which this account exists",
TP_TYPE_DBUS_DAEMON,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_DISPLAY_NAME,
g_param_spec_string ("display-name",
"DisplayName",
"The accounts display name",
NULL,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
signals[STATUS_CHANGED] = g_signal_new ("status-changed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
_empathy_marshal_VOID__UINT_UINT_UINT,
G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
signals[PRESENCE_CHANGED] = g_signal_new ("presence-changed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
_empathy_marshal_VOID__UINT_STRING_STRING,
G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING);
signals[REMOVED] = g_signal_new ("removed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static guint
resolve_flags_value(VALUE klass, GFlagsClass *gclass, VALUE flag_or_flags)
{
guint value = 0;
switch (TYPE(flag_or_flags)) {
case RUBY_T_NIL:
value = 0;
break;
case RUBY_T_FIXNUM:
case RUBY_T_BIGNUM:
value = NUM2UINT(flag_or_flags);
break;
case RUBY_T_STRING:
case RUBY_T_SYMBOL:
{
const gchar *name;
GFlagsValue *info;
name = RVAL2CSTR_ACCEPT_SYMBOL(flag_or_flags);
info = g_flags_get_value_by_name(gclass, name);
if (!info) {
gchar *nick;
nick = rbg_name_to_nick(name);
info = g_flags_get_value_by_nick(gclass, nick);
g_free(nick);
}
if (!info) {
rb_raise(rb_eArgError,
"unknown flag name: <%s>(%s)",
name,
g_type_name(G_TYPE_FROM_CLASS(gclass)));
}
value = info->value;
break;
}
case RUBY_T_ARRAY:
{
int i, n;
n = RARRAY_LEN(flag_or_flags);
for (i = 0; i < n; i++) {
value |= resolve_flags_value(klass,
gclass,
RARRAY_PTR(flag_or_flags)[i]);
}
break;
}
default:
if (RVAL2CBOOL(rb_obj_is_kind_of(flag_or_flags, klass))) {
value = NUM2UINT(rb_funcall(flag_or_flags, id_to_i, 0));
} else {
rb_raise(rb_eArgError,
"flag value must be one of "
"nil, Fixnum, String, Symbol, %s or Array of them: "
"<%s>(%s)",
RBG_INSPECT(klass),
RBG_INSPECT(flag_or_flags),
g_type_name(G_TYPE_FROM_CLASS(gclass)));
}
break;
}
return value;
}
static void
shell_button_box_class_init (ShellButtonBoxClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
gobject_class->get_property = shell_button_box_get_property;
gobject_class->set_property = shell_button_box_set_property;
actor_class->enter_event = shell_button_box_enter_event;
actor_class->leave_event = shell_button_box_leave_event;
actor_class->button_press_event = shell_button_box_button_press_event;
actor_class->button_release_event = shell_button_box_button_release_event;
/**
* ShellButtonBox::activate
* @box: The #ShellButtonBox
* @event: Release event which triggered the activation
*
* This signal is emitted when the button should take the action
* associated with button click+release.
*/
shell_button_box_signals[ACTIVATE] =
g_signal_new ("activate",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 1, CLUTTER_TYPE_EVENT);
/**
* ShellButtonBox:active
*
* The property allows the button to be used as a "toggle button"; it's up to the
* application to update the active property in response to the activate signal;
* it doesn't happen automatically.
*/
g_object_class_install_property (gobject_class,
PROP_ACTIVE,
g_param_spec_boolean ("active",
"Active",
"Whether the button persistently active",
FALSE,
G_PARAM_READWRITE));
/**
* ShellButtonBox:hover
*
* This property tracks whether the mouse is over the button; note this
* state is independent of whether the button is pressed.
*/
g_object_class_install_property (gobject_class,
PROP_HOVER,
g_param_spec_boolean ("hover",
"Hovering state",
"Whether the mouse is over the button",
FALSE,
G_PARAM_READABLE));
/**
* ShellButtonBox:pressed
*
* This property tracks whether the button should have a "pressed in"
* effect.
*/
g_object_class_install_property (gobject_class,
PROP_PRESSED,
g_param_spec_boolean ("pressed",
"Pressed state",
"Whether the button is currently pressed",
FALSE,
G_PARAM_READABLE));
g_type_class_add_private (gobject_class, sizeof (ShellButtonBoxPrivate));
}
static void
gdl_dock_class_init (GdlDockClass *klass)
{
GObjectClass *g_object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
GdlDockObjectClass *object_class;
g_object_class = G_OBJECT_CLASS (klass);
widget_class = GTK_WIDGET_CLASS (klass);
container_class = GTK_CONTAINER_CLASS (klass);
object_class = GDL_DOCK_OBJECT_CLASS (klass);
g_object_class->constructor = gdl_dock_constructor;
g_object_class->set_property = gdl_dock_set_property;
g_object_class->get_property = gdl_dock_get_property;
g_object_class->dispose = gdl_dock_dispose;
/* properties */
g_object_class_install_property (
g_object_class, PROP_FLOATING,
g_param_spec_boolean ("floating", _("Floating"),
_("Whether the dock is floating in its own window"),
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
GDL_DOCK_PARAM_EXPORT));
g_object_class_install_property (
g_object_class, PROP_DEFAULT_TITLE,
g_param_spec_string ("default-title", _("Default title"),
_("Default title for the newly created floating docks"),
NULL,
G_PARAM_READWRITE));
g_object_class_install_property (
g_object_class, PROP_WIDTH,
g_param_spec_int ("width", _("Width"),
_("Width for the dock when it's of floating type"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT |
GDL_DOCK_PARAM_EXPORT));
g_object_class_install_property (
g_object_class, PROP_HEIGHT,
g_param_spec_int ("height", _("Height"),
_("Height for the dock when it's of floating type"),
-1, G_MAXINT, -1,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT |
GDL_DOCK_PARAM_EXPORT));
g_object_class_install_property (
g_object_class, PROP_FLOAT_X,
g_param_spec_int ("floatx", _("Float X"),
_("X coordinate for a floating dock"),
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT |
GDL_DOCK_PARAM_EXPORT));
g_object_class_install_property (
g_object_class, PROP_FLOAT_Y,
g_param_spec_int ("floaty", _("Float Y"),
_("Y coordinate for a floating dock"),
G_MININT, G_MAXINT, 0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT |
GDL_DOCK_PARAM_EXPORT));
/**
* GdlDock:skip-taskbar:
*
* Whether or not to prevent a floating dock window from appearing in the
* taskbar. Note that this only affects floating windows that are created
* after this flag is set; existing windows are not affected. Usually,
* this property is used when you create the dock.
*
* Since: 3.6
*/
g_object_class_install_property (
g_object_class, PROP_SKIP_TASKBAR,
g_param_spec_boolean ("skip-taskbar",
_("Skip taskbar"),
_("Whether or not to prevent a floating dock window from appearing in the taskbar"),
TRUE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT |
GDL_DOCK_PARAM_EXPORT));
widget_class->get_preferred_width = gdl_dock_get_preferred_width;
widget_class->get_preferred_height = gdl_dock_get_preferred_height;
widget_class->size_allocate = gdl_dock_size_allocate;
widget_class->map = gdl_dock_map;
widget_class->unmap = gdl_dock_unmap;
widget_class->show = gdl_dock_show;
widget_class->hide = gdl_dock_hide;
container_class->add = gdl_dock_add;
container_class->remove = gdl_dock_remove;
container_class->forall = gdl_dock_forall;
container_class->child_type = gdl_dock_child_type;
gtk_container_class_handle_border_width (container_class);
gdl_dock_object_class_set_is_compound (object_class, TRUE);
object_class->detach = gdl_dock_detach;
object_class->reduce = gdl_dock_reduce;
object_class->dock_request = gdl_dock_dock_request;
object_class->dock = gdl_dock_dock;
object_class->reorder = gdl_dock_reorder;
object_class->child_placement = gdl_dock_child_placement;
object_class->present = gdl_dock_present;
/* signals */
/**
* GdlDock::layout-changed:
*
* Signals that the layout has changed, one or more widgets have been moved,
* added or removed.
*/
dock_signals [LAYOUT_CHANGED] =
g_signal_new ("layout-changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdlDockClass, layout_changed),
NULL, /* accumulator */
NULL, /* accu_data */
gdl_marshal_VOID__VOID,
G_TYPE_NONE, /* return type */
0);
klass->layout_changed = NULL;
g_type_class_add_private (object_class, sizeof (GdlDockPrivate));
}
