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)); }