gtk_cell_renderer_toggle_class_init (GtkCellRendererToggleClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class); object_class->get_property = gtk_cell_renderer_toggle_get_property; object_class->set_property = gtk_cell_renderer_toggle_set_property; cell_class->get_size = gtk_cell_renderer_toggle_get_size; cell_class->snapshot = gtk_cell_renderer_toggle_snapshot; cell_class->activate = gtk_cell_renderer_toggle_activate; g_object_class_install_property (object_class, PROP_ACTIVE, g_param_spec_boolean ("active", P_("Toggle state"), P_("The toggle state of the button"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); g_object_class_install_property (object_class, PROP_INCONSISTENT, g_param_spec_boolean ("inconsistent", P_("Inconsistent state"), P_("The inconsistent state of the button"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); g_object_class_install_property (object_class, PROP_ACTIVATABLE, g_param_spec_boolean ("activatable",
static void gtk_cell_view_class_init (GtkCellViewClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); gobject_class->constructor = gtk_cell_view_constructor; gobject_class->get_property = gtk_cell_view_get_property; gobject_class->set_property = gtk_cell_view_set_property; gobject_class->finalize = gtk_cell_view_finalize; gobject_class->dispose = gtk_cell_view_dispose; widget_class->draw = gtk_cell_view_draw; widget_class->size_allocate = gtk_cell_view_size_allocate; widget_class->get_request_mode = gtk_cell_view_get_request_mode; widget_class->get_preferred_width = gtk_cell_view_get_preferred_width; widget_class->get_preferred_height = gtk_cell_view_get_preferred_height; widget_class->get_preferred_width_for_height = gtk_cell_view_get_preferred_width_for_height; widget_class->get_preferred_height_for_width = gtk_cell_view_get_preferred_height_for_width; /* properties */ g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation"); g_object_class_install_property (gobject_class, PROP_BACKGROUND, g_param_spec_string ("background", P_("Background color name"), P_("Background color as a string"), NULL, GTK_PARAM_WRITABLE)); /** * GtkCellView:background-gdk: * * The background color as a #GdkColor * * Deprecated: 3.4: Use #GtkCellView:background-rgba instead. */ g_object_class_install_property (gobject_class, PROP_BACKGROUND_GDK, g_param_spec_boxed ("background-gdk", P_("Background color"), P_("Background color as a GdkColor"), GDK_TYPE_COLOR, GTK_PARAM_READWRITE | G_PARAM_DEPRECATED)); /** * GtkCellView:background-rgba: * * The background color as a #GdkRGBA * * Since: 3.0 */ g_object_class_install_property (gobject_class, PROP_BACKGROUND_RGBA, g_param_spec_boxed ("background-rgba", P_("Background RGBA color"), P_("Background color as a GdkRGBA"), GDK_TYPE_RGBA, GTK_PARAM_READWRITE)); /** * GtkCellView:model: * * The model for cell view * * since 2.10 */ g_object_class_install_property (gobject_class, PROP_MODEL, g_param_spec_object ("model", P_("CellView model"), P_("The model for cell view"), GTK_TYPE_TREE_MODEL, GTK_PARAM_READWRITE)); /** * GtkCellView:cell-area: * * The #GtkCellArea rendering cells * * If no area is specified when creating the cell view with gtk_cell_view_new_with_context() * a horizontally oriented #GtkCellAreaBox will be used. * * since 3.0 */ g_object_class_install_property (gobject_class, PROP_CELL_AREA, g_param_spec_object ("cell-area", P_("Cell Area"), P_("The GtkCellArea used to layout cells"), GTK_TYPE_CELL_AREA, GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); /** * GtkCellView:cell-area-context: * * The #GtkCellAreaContext used to compute the geometry of the cell view. * * A group of cell views can be assigned the same context in order to * ensure the sizes and cell alignments match across all the views with * the same context. * * #GtkComboBox menus uses this to assign the same context to all cell views * in the menu items for a single menu (each submenu creates its own * context since the size of each submenu does not depend on parent * or sibling menus). * * since 3.0 */ g_object_class_install_property (gobject_class, PROP_CELL_AREA_CONTEXT, g_param_spec_object ("cell-area-context", P_("Cell Area Context"), P_("The GtkCellAreaContext used to " "compute the geometry of the cell view"), GTK_TYPE_CELL_AREA_CONTEXT, GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); /** * GtkCellView:draw-sensitive: * * Whether all cells should be draw as sensitive for this view regardless * of the actual cell properties (used to make menus with submenus appear * sensitive when the items in submenus might be insensitive). * * since 3.0 */ g_object_class_install_property (gobject_class, PROP_DRAW_SENSITIVE, g_param_spec_boolean ("draw-sensitive", P_("Draw Sensitive"), P_("Whether to force cells to be drawn in a " "sensitive state"), FALSE, GTK_PARAM_READWRITE)); /** * GtkCellView:fit-model: * * Whether the view should request enough space to always fit * the size of every row in the model (used by the combo box to * ensure the combo box size doesnt change when different items * are selected). * * since 3.0 */ g_object_class_install_property (gobject_class, PROP_FIT_MODEL, g_param_spec_boolean ("fit-model", P_("Fit Model"), P_("Whether to request enough space for " "every row in the model"), FALSE, GTK_PARAM_READWRITE)); #define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (gobject_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE)) ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET, P_("Background set"), P_("Whether this tag affects the background color")); g_type_class_add_private (gobject_class, sizeof (GtkCellViewPrivate)); }
static void gtk_check_menu_item_class_init (GtkCheckMenuItemClass *klass) { GObjectClass *gobject_class; GtkWidgetClass *widget_class; GtkMenuItemClass *menu_item_class; gobject_class = G_OBJECT_CLASS (klass); widget_class = (GtkWidgetClass*) klass; menu_item_class = (GtkMenuItemClass*) klass; gobject_class->set_property = gtk_check_menu_item_set_property; gobject_class->get_property = gtk_check_menu_item_get_property; g_object_class_install_property (gobject_class, PROP_ACTIVE, g_param_spec_boolean ("active", P_("Active"), P_("Whether the menu item is checked"), FALSE, GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_INCONSISTENT, g_param_spec_boolean ("inconsistent", P_("Inconsistent"), P_("Whether to display an \"inconsistent\" state"), FALSE, GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_DRAW_AS_RADIO, g_param_spec_boolean ("draw-as-radio", P_("Draw as radio menu item"), P_("Whether the menu item looks like a radio menu item"), FALSE, GTK_PARAM_READWRITE)); gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("indicator-size", P_("Indicator Size"), P_("Size of check or radio indicator"), 0, G_MAXINT, INDICATOR_SIZE, GTK_PARAM_READABLE)); widget_class->draw = gtk_check_menu_item_draw; gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE); menu_item_class->activate = gtk_check_menu_item_activate; menu_item_class->hide_on_activate = FALSE; menu_item_class->toggle_size_request = gtk_check_menu_item_toggle_size_request; klass->toggled = NULL; klass->draw_indicator = gtk_real_check_menu_item_draw_indicator; /** * GtkCheckMenuItem::toggled: * @checkmenuitem: the object which received the signal. * * This signal is emitted when the state of the check box is changed. * * A signal handler can use gtk_check_menu_item_get_active() * to discover the new state. */ check_menu_item_signals[TOGGLED] = g_signal_new (I_("toggled"), G_OBJECT_CLASS_TYPE (gobject_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkCheckMenuItemClass, toggled), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); g_type_class_add_private (klass, sizeof (GtkCheckMenuItemPrivate)); }
static void g_binding_class_init (GBindingClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); quark_gbinding = g_quark_from_static_string ("g-binding"); gobject_class->constructed = g_binding_constructed; gobject_class->set_property = g_binding_set_property; gobject_class->get_property = g_binding_get_property; gobject_class->finalize = g_binding_finalize; /** * GBinding:source: * * The #GObject that should be used as the source of the binding * * Since: 2.26 */ g_object_class_install_property (gobject_class, PROP_SOURCE, g_param_spec_object ("source", P_("Source"), P_("The source of the binding"), G_TYPE_OBJECT, G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GBinding:target: * * The #GObject that should be used as the target of the binding * * Since: 2.26 */ g_object_class_install_property (gobject_class, PROP_TARGET, g_param_spec_object ("target", P_("Target"), P_("The target of the binding"), G_TYPE_OBJECT, G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GBinding:source-property: * * The name of the property of #GBinding:source that should be used * as the source of the binding * * Since: 2.26 */ g_object_class_install_property (gobject_class, PROP_SOURCE_PROPERTY, g_param_spec_string ("source-property", P_("Source Property"), P_("The property on the source to bind"), NULL, G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GBinding:target-property: * * The name of the property of #GBinding:target that should be used * as the target of the binding * * Since: 2.26 */ g_object_class_install_property (gobject_class, PROP_TARGET_PROPERTY, g_param_spec_string ("target-property", P_("Target Property"), P_("The property on the target to bind"), NULL, G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GBinding:flags: * * Flags to be used to control the #GBinding * * Since: 2.26 */ g_object_class_install_property (gobject_class, PROP_FLAGS, g_param_spec_flags ("flags", P_("Flags"), P_("The binding flags"), G_TYPE_BINDING_FLAGS, G_BINDING_DEFAULT, G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); }
g_signal_new (I_("incoming"), G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GSocketServiceClass, incoming), g_signal_accumulator_true_handled, NULL, NULL, G_TYPE_BOOLEAN, 2, G_TYPE_SOCKET_CONNECTION, G_TYPE_OBJECT); /** * GSocketService:active: * * Whether the service is currently accepting connections. * * Since: 2.46 */ g_object_class_install_property (gobject_class, PROP_ACTIVE, g_param_spec_boolean ("active", P_("Active"), P_("Whether the service is currently accepting connections"), TRUE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); } static void g_socket_service_ready (GObject *object, GAsyncResult *result, gpointer user_data) { GSocketListener *listener = G_SOCKET_LISTENER (object); GSocketService *service = G_SOCKET_SERVICE (object); GSocketConnection *connection; GObject *source_object; GError *error = NULL;
gobject_class = G_OBJECT_CLASS (class); widget_class = (GtkWidgetClass*) class; button_class = (GtkButtonClass*) class; gobject_class->set_property = gtk_toggle_button_set_property; gobject_class->get_property = gtk_toggle_button_get_property; widget_class->mnemonic_activate = gtk_toggle_button_mnemonic_activate; button_class->clicked = gtk_toggle_button_clicked; class->toggled = NULL; toggle_button_props[PROP_ACTIVE] = g_param_spec_boolean ("active", P_("Active"), P_("If the toggle button should be pressed in"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); toggle_button_props[PROP_INCONSISTENT] = g_param_spec_boolean ("inconsistent", P_("Inconsistent"), P_("If the toggle button is in an “in between” state"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY); toggle_button_props[PROP_DRAW_INDICATOR] = g_param_spec_boolean ("draw-indicator", P_("Draw Indicator"), P_("If the toggle part of the button is displayed"),
static void gtk_app_chooser_widget_class_init (GtkAppChooserWidgetClass *klass) { GObjectClass *gobject_class; GParamSpec *pspec; gobject_class = G_OBJECT_CLASS (klass); gobject_class->dispose = gtk_app_chooser_widget_dispose; gobject_class->finalize = gtk_app_chooser_widget_finalize; gobject_class->set_property = gtk_app_chooser_widget_set_property; gobject_class->get_property = gtk_app_chooser_widget_get_property; gobject_class->constructed = gtk_app_chooser_widget_constructed; g_object_class_override_property (gobject_class, PROP_CONTENT_TYPE, "content-type"); /** * GtkAppChooserWidget:show-default: * * The ::show-default property determines whether the app chooser * should show the default handler for the content type in a * separate section. If %FALSE, the default handler is listed * among the recommended applications. */ pspec = g_param_spec_boolean ("show-default", P_("Show default app"), P_("Whether the widget should show the default application"), FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_SHOW_DEFAULT, pspec); /** * GtkAppChooserWidget:show-recommended: * * The #GtkAppChooserWidget:show-recommended property determines * whether the app chooser should show a section for recommended * applications. If %FALSE, the recommended applications are listed * among the other applications. */ pspec = g_param_spec_boolean ("show-recommended", P_("Show recommended apps"), P_("Whether the widget should show recommended applications"), TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_SHOW_RECOMMENDED, pspec); /** * GtkAppChooserWidget:show-fallback: * * The #GtkAppChooserWidget:show-fallback property determines whether * the app chooser should show a section for fallback applications. * If %FALSE, the fallback applications are listed among the other * applications. */ pspec = g_param_spec_boolean ("show-fallback", P_("Show fallback apps"), P_("Whether the widget should show fallback applications"), FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_SHOW_FALLBACK, pspec); /** * GtkAppChooserWidget:show-other: * * The #GtkAppChooserWidget:show-other property determines whether * the app chooser should show a section for other applications. */ pspec = g_param_spec_boolean ("show-other", P_("Show other apps"), P_("Whether the widget should show other applications"), FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_SHOW_OTHER, pspec); /** * GtkAppChooserWidget:show-all: * * If the #GtkAppChooserWidget:show-all property is %TRUE, the app * chooser presents all applications in a single list, without * subsections for default, recommended or related applications. */ pspec = g_param_spec_boolean ("show-all", P_("Show all apps"), P_("Whether the widget should show all applications"), FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_SHOW_ALL, pspec); /** * GtkAppChooserWidget:default-text: * * The #GtkAppChooserWidget:default-text property determines the text * that appears in the widget when there are no applications for the * given content type. * See also gtk_app_chooser_widget_set_default_text(). */ pspec = g_param_spec_string ("default-text", P_("Widget's default text"), P_("The default text appearing when there are no applications"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_DEFAULT_TEXT, pspec); /** * GtkAppChooserWidget::application-selected: * @self: the object which received the signal * @application: the selected #GAppInfo * * Emitted when an application item is selected from the widget's list. */ signals[SIGNAL_APPLICATION_SELECTED] = g_signal_new ("application-selected", GTK_TYPE_APP_CHOOSER_WIDGET, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkAppChooserWidgetClass, application_selected), NULL, NULL, _gtk_marshal_VOID__OBJECT, G_TYPE_NONE, 1, G_TYPE_APP_INFO); /** * GtkAppChooserWidget::application-activated: * @self: the object which received the signal * @application: the activated #GAppInfo * * Emitted when an application item is activated from the widget's list. * * This usually happens when the user double clicks an item, or an item * is selected and the user presses one of the keys Space, Shift+Space, * Return or Enter. */ signals[SIGNAL_APPLICATION_ACTIVATED] = g_signal_new ("application-activated", GTK_TYPE_APP_CHOOSER_WIDGET, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkAppChooserWidgetClass, application_activated), NULL, NULL, _gtk_marshal_VOID__OBJECT, G_TYPE_NONE, 1, G_TYPE_APP_INFO); /** * GtkAppChooserWidget::populate-popup: * @self: the object which received the signal * @menu: the #GtkMenu to populate * @application: the current #GAppInfo * * Emitted when a context menu is about to popup over an application item. * Clients can insert menu items into the provided #GtkMenu object in the * callback of this signal; the context menu will be shown over the item * if at least one item has been added to the menu. */ signals[SIGNAL_POPULATE_POPUP] = g_signal_new ("populate-popup", GTK_TYPE_APP_CHOOSER_WIDGET, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkAppChooserWidgetClass, populate_popup), NULL, NULL, _gtk_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2, GTK_TYPE_MENU, G_TYPE_APP_INFO); g_type_class_add_private (klass, sizeof (GtkAppChooserWidgetPrivate)); }
static void clutter_pan_action_class_init (ClutterPanActionClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass); ClutterGestureActionClass *gesture_class = CLUTTER_GESTURE_ACTION_CLASS (klass); g_type_class_add_private (klass, sizeof (ClutterPanActionPrivate)); klass->pan = clutter_pan_action_real_pan; gesture_class->gesture_prepare = gesture_prepare; gesture_class->gesture_begin = gesture_begin; gesture_class->gesture_progress = gesture_progress; gesture_class->gesture_cancel = gesture_cancel; gesture_class->gesture_end = gesture_end; meta_class->set_actor = clutter_pan_action_set_actor; /** * ClutterPanAction:pan-axis: * * Constraints the panning action to the specified axis */ pan_props[PROP_PAN_AXIS] = g_param_spec_enum ("pan-axis", P_("Pan Axis"), P_("Constraints the panning to an axis"), CLUTTER_TYPE_PAN_AXIS, CLUTTER_PAN_AXIS_NONE, CLUTTER_PARAM_READWRITE); /** * ClutterPanAction:interpolate: * * Whether interpolated events emission is enabled. */ pan_props[PROP_INTERPOLATE] = g_param_spec_boolean ("interpolate", P_("Interpolate"), P_("Whether interpolated events emission is enabled."), FALSE, CLUTTER_PARAM_READWRITE); /** * ClutterPanAction:deceleration: * * The rate at which the interpolated panning will decelerate in * * #ClutterPanAction will emit interpolated ::pan events with decreasing * scroll deltas, using the rate specified by this property. */ pan_props[PROP_DECELERATION] = g_param_spec_double ("deceleration", P_("Deceleration"), P_("Rate at which the interpolated panning will decelerate in"), FLOAT_EPSILON, 1.0, default_deceleration_rate, CLUTTER_PARAM_READWRITE); /** * ClutterPanAction:acceleration-factor: * * The initial acceleration factor * * The kinetic momentum measured at the time of releasing the pointer will * be multiplied by the factor specified by this property before being used * to generate interpolated ::pan events. */ pan_props[PROP_ACCELERATION_FACTOR] = g_param_spec_double ("acceleration-factor", P_("Initial acceleration factor"), P_("Factor applied to the momentum when starting the interpolated phase"), 1.0, G_MAXDOUBLE, default_acceleration_factor, CLUTTER_PARAM_READWRITE); gobject_class->set_property = clutter_pan_action_set_property; gobject_class->get_property = clutter_pan_action_get_property; gobject_class->dispose = clutter_pan_action_dispose; g_object_class_install_properties (gobject_class, PROP_LAST, pan_props); /** * ClutterPanAction::pan: * @action: the #ClutterPanAction that emitted the signal * @actor: the #ClutterActor attached to the @action * @is_interpolated: if the event is the result of interpolating * the motion velocity at the end of the drag * * The ::pan signal is emitted to keep track of the motion during * a pan gesture. @is_interpolated is set to %TRUE during the * interpolation phase of the pan, after the drag has ended and * the :interpolate property was set to %TRUE. * * Return value: %TRUE if the pan should continue, and %FALSE if * the pan should be cancelled. */ pan_signals[PAN] = g_signal_new (I_("pan"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (ClutterPanActionClass, pan), _clutter_boolean_continue_accumulator, NULL, _clutter_marshal_BOOLEAN__OBJECT_BOOLEAN, G_TYPE_BOOLEAN, 2, CLUTTER_TYPE_ACTOR, G_TYPE_BOOLEAN); /** * ClutterPanAction::pan-stopped: * @action: the #ClutterPanAction that emitted the signal * @actor: the #ClutterActor attached to the @action * * The ::pan-stopped signal is emitted at the end of the interpolation * phase of the pan action, only when :interpolate is set to %TRUE. */ pan_signals[PAN_STOPPED] = g_signal_new (I_("pan-stopped"), G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (ClutterPanActionClass, pan_stopped), NULL, NULL, _clutter_marshal_VOID__OBJECT, G_TYPE_NONE, 1, CLUTTER_TYPE_ACTOR); }
signals[ACTIVATE] = g_signal_new ("activate", GTK_TYPE_COLOR_SWATCH, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkColorSwatchClass, activate), NULL, NULL, NULL, G_TYPE_NONE, 0); signals[CUSTOMIZE] = g_signal_new ("customize", GTK_TYPE_COLOR_SWATCH, G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkColorSwatchClass, customize), NULL, NULL, NULL, G_TYPE_NONE, 0); g_object_class_install_property (object_class, PROP_RGBA, g_param_spec_boxed ("rgba", P_("RGBA Color"), P_("Color as RGBA"), GDK_TYPE_RGBA, GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_SELECTABLE, g_param_spec_boolean ("selectable", P_("Selectable"), P_("Whether the swatch is selectable"), TRUE, GTK_PARAM_READWRITE)); gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_COLOR_SWATCH_ACCESSIBLE); } /* Public API {{{1 */ GtkWidget * gtk_color_swatch_new (void) { return (GtkWidget *) g_object_new (GTK_TYPE_COLOR_SWATCH, NULL); }
static void clutter_behaviour_class_init (ClutterBehaviourClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->dispose = clutter_behaviour_dispose; object_class->set_property = clutter_behaviour_set_property; object_class->get_property = clutter_behaviour_get_property; /** * ClutterBehaviour:alpha: * * The #ClutterAlpha object used to drive this behaviour. A #ClutterAlpha * object binds a #ClutterTimeline and a function which computes a value * (the "alpha") depending on the time. Each time the alpha value changes * the alpha-notify virtual function is called. * * Since: 0.2 */ obj_props[PROP_ALPHA] = g_param_spec_object ("alpha", P_("Alpha"), P_("Alpha Object to drive the behaviour"), CLUTTER_TYPE_ALPHA, CLUTTER_PARAM_READWRITE); g_object_class_install_properties (object_class, PROP_LAST, obj_props); klass->alpha_notify = clutter_behaviour_alpha_notify_unimplemented; /** * ClutterBehaviour::applied: * @behaviour: the #ClutterBehaviour that received the signal * @actor: the actor the behaviour was applied to. * * The ::apply signal is emitted each time the behaviour is applied * to an actor. * * Since: 0.4 */ behave_signals[APPLIED] = g_signal_new ("applied", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (ClutterBehaviourClass, applied), NULL, NULL, _clutter_marshal_VOID__OBJECT, G_TYPE_NONE, 1, CLUTTER_TYPE_ACTOR); /** * ClutterBehaviour::removed: * @behaviour: the #ClutterBehaviour that received the signal * @actor: the removed actor * * The ::removed signal is emitted each time a behaviour is not applied * to an actor anymore. * * Since: 0.4 */ behave_signals[REMOVED] = g_signal_new ("removed", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (ClutterBehaviourClass, removed), NULL, NULL, _clutter_marshal_VOID__OBJECT, G_TYPE_NONE, 1, CLUTTER_TYPE_ACTOR); g_type_class_add_private (klass, sizeof (ClutterBehaviourPrivate)); }
gobject_class = (GObjectClass*) class; widget_class = (GtkWidgetClass*) class; container_class = (GtkContainerClass*) class; gobject_class->set_property = gtk_layout_set_property; gobject_class->get_property = gtk_layout_get_property; gobject_class->finalize = gtk_layout_finalize; container_class->set_child_property = gtk_layout_set_child_property; container_class->get_child_property = gtk_layout_get_child_property; gtk_container_class_install_child_property (container_class, CHILD_PROP_X, g_param_spec_int ("x", P_("X position"), P_("X position of child widget"), G_MININT, G_MAXINT, 0, GTK_PARAM_READWRITE)); gtk_container_class_install_child_property (container_class, CHILD_PROP_Y, g_param_spec_int ("y", P_("Y position"), P_("Y position of child widget"), G_MININT, G_MAXINT, 0, GTK_PARAM_READWRITE));
class->mod_name_shift = g_strdup ("\xe2\x87\xa7"); /* U+2303 UP ARROWHEAD */ class->mod_name_control = g_strdup ("\xe2\x8c\x83"); /* U+2325 OPTION KEY */ class->mod_name_alt = g_strdup ("\xe2\x8c\xa5"); class->mod_separator = g_strdup (""); #endif /* GDK_WINDOWING_QUARTZ */ class->accel_seperator = g_strdup (" / "); class->latin1_to_char = TRUE; g_object_class_install_property (gobject_class, PROP_ACCEL_CLOSURE, g_param_spec_boxed ("accel-closure", P_("Accelerator Closure"), P_("The closure to be monitored for accelerator changes"), G_TYPE_CLOSURE, GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_ACCEL_WIDGET, g_param_spec_object ("accel-widget", P_("Accelerator Widget"), P_("The widget to be monitored for accelerator changes"), GTK_TYPE_WIDGET, GTK_PARAM_READWRITE)); } static void gtk_accel_label_set_property (GObject *object, guint prop_id,
container_class->check_resize = gtk_plug_check_resize; window_class->set_focus = gtk_plug_set_focus; window_class->keys_changed = gtk_plug_keys_changed; /** * GtkPlug:embedded: * * %TRUE if the plug is embedded in a socket. * * Since: 2.12 */ g_object_class_install_property (gobject_class, PROP_EMBEDDED, g_param_spec_boolean ("embedded", P_("Embedded"), P_("Whether the plug is embedded"), FALSE, GTK_PARAM_READABLE)); /** * GtkPlug:socket-window: * * The window of the socket the plug is embedded in. * * Since: 2.14 */ g_object_class_install_property (gobject_class, PROP_SOCKET_WINDOW, g_param_spec_object ("socket-window", P_("Socket Window"),
object_class->set_property = g_application_set_property; class->before_emit = g_application_real_before_emit; class->after_emit = g_application_real_after_emit; class->startup = g_application_real_startup; class->activate = g_application_real_activate; class->open = g_application_real_open; class->command_line = g_application_real_command_line; class->local_command_line = g_application_real_local_command_line; class->add_platform_data = g_application_real_add_platform_data; class->quit_mainloop = g_application_real_quit_mainloop; class->run_mainloop = g_application_real_run_mainloop; g_object_class_install_property (object_class, PROP_APPLICATION_ID, g_param_spec_string ("application-id", P_("Application identifier"), P_("The unique identifier for the application"), NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, PROP_FLAGS, g_param_spec_flags ("flags", P_("Application flags"), P_("Flags specifying the behaviour of the application"), G_TYPE_APPLICATION_FLAGS, G_APPLICATION_FLAGS_NONE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, PROP_IS_REGISTERED, g_param_spec_boolean ("is-registered", P_("Is registered"), P_("If g_application_register() has been called"),
static void show_stats(e2fsck_t ctx) { ext2_filsys fs = ctx->fs; ext2_ino_t inodes, inodes_used; blk_t blocks, blocks_used; int dir_links; int num_files, num_links; int frag_percent; dir_links = 2 * ctx->fs_directory_count - 1; num_files = ctx->fs_total_count - dir_links; num_links = ctx->fs_links_count - dir_links; inodes = fs->super->s_inodes_count; inodes_used = (fs->super->s_inodes_count - fs->super->s_free_inodes_count); blocks = fs->super->s_blocks_count; blocks_used = (fs->super->s_blocks_count - fs->super->s_free_blocks_count); frag_percent = (10000 * ctx->fs_fragmented) / inodes_used; frag_percent = (frag_percent + 5) / 10; if (!verbose) { printf(_("%s: %u/%u files (%0d.%d%% non-contiguous), %u/%u blocks\n"), ctx->device_name, inodes_used, inodes, frag_percent / 10, frag_percent % 10, blocks_used, blocks); return; } printf (P_("\n%8u inode used (%2.2f%%)\n", "\n%8u inodes used (%2.2f%%)\n", inodes_used), inodes_used, 100.0 * inodes_used / inodes); printf (P_("%8u non-contiguous inode (%0d.%d%%)\n", "%8u non-contiguous inodes (%0d.%d%%)\n", ctx->fs_fragmented), ctx->fs_fragmented, frag_percent / 10, frag_percent % 10); printf (_(" # of inodes with ind/dind/tind blocks: %u/%u/%u\n"), ctx->fs_ind_count, ctx->fs_dind_count, ctx->fs_tind_count); printf (P_("%8u block used (%2.2f%%)\n", "%8u blocks used (%2.2f%%)\n", blocks_used), blocks_used, 100.0 * blocks_used / blocks); printf (P_("%8u bad block\n", "%8u bad blocks\n", ctx->fs_badblocks_count), ctx->fs_badblocks_count); printf (P_("%8u large file\n", "%8u large files\n", ctx->large_files), ctx->large_files); printf (P_("\n%8u regular file\n", "\n%8u regular files\n", ctx->fs_regular_count), ctx->fs_regular_count); printf (P_("%8u directory\n", "%8u directories\n", ctx->fs_directory_count), ctx->fs_directory_count); printf (P_("%8u character device file\n", "%8u character device files\n", ctx->fs_chardev_count), ctx->fs_chardev_count); printf (P_("%8u block device file\n", "%8u block device files\n", ctx->fs_blockdev_count), ctx->fs_blockdev_count); printf (P_("%8u fifo\n", "%8u fifos\n", ctx->fs_fifo_count), ctx->fs_fifo_count); printf (P_("%8u link\n", "%8u links\n", ctx->fs_links_count - dir_links), ctx->fs_links_count - dir_links); printf (P_("%8u symbolic link", "%8u symbolic links", ctx->fs_symlinks_count), ctx->fs_symlinks_count); printf (P_(" (%u fast symbolic link)\n", " (%u fast symbolic links)\n", ctx->fs_fast_symlinks_count), ctx->fs_fast_symlinks_count); printf (P_("%8u socket\n", "%8u sockets\n", ctx->fs_sockets_count), ctx->fs_sockets_count); printf ("--------\n"); printf (P_("%8u file\n", "%8u files\n", ctx->fs_total_count - dir_links), ctx->fs_total_count - dir_links); }
/** * Verify that some programs can be found in the PATH. */ void checkpath(void) { static const char *const prog_list[] = { DEFAULTSHELL, RM, TAR, FIND, BACKEND, /* Mac OS X uses dyld (Mach-O) instead of ld.so (ELF), and does not have * an ldconfig. */ #if defined(__APPLE__) && defined(__MACH__) "update_dyld_shared_cache", #else "ldconfig", #endif #if BUILD_START_STOP_DAEMON "start-stop-daemon", #endif NULL }; const char *const *prog; const char *path_list; struct varbuf filename = VARBUF_INIT; int warned= 0; path_list = getenv("PATH"); if (!path_list) ohshit(_("PATH is not set")); for (prog = prog_list; *prog; prog++) { struct stat stab; const char *path, *path_end; size_t path_len; for (path = path_list; path; path = path_end ? path_end + 1 : NULL) { path_end = strchr(path, ':'); path_len = path_end ? (size_t)(path_end - path) : strlen(path); varbuf_reset(&filename); varbuf_add_buf(&filename, path, path_len); if (path_len) varbuf_add_char(&filename, '/'); varbuf_add_str(&filename, *prog); varbuf_end_str(&filename); if (stat(filename.buf, &stab) == 0 && (stab.st_mode & 0111)) break; } if (!path) { warning(_("'%s' not found in PATH or not executable"), *prog); warned++; } } varbuf_destroy(&filename); if (warned) forcibleerr(fc_badpath, P_("%d expected program not found in PATH or not executable\n%s", "%d expected programs not found in PATH or not executable\n%s", warned), warned, _("Note: root's PATH should usually contain " "/usr/local/sbin, /usr/sbin and /sbin")); }
widget_class->queue_draw_region = gtk_viewport_queue_draw_region; gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_VIEWPORT); container_class->add = gtk_viewport_add; /* GtkScrollable implementation */ g_object_class_override_property (gobject_class, PROP_HADJUSTMENT, "hadjustment"); g_object_class_override_property (gobject_class, PROP_VADJUSTMENT, "vadjustment"); g_object_class_override_property (gobject_class, PROP_HSCROLL_POLICY, "hscroll-policy"); g_object_class_override_property (gobject_class, PROP_VSCROLL_POLICY, "vscroll-policy"); g_object_class_install_property (gobject_class, PROP_SHADOW_TYPE, g_param_spec_enum ("shadow-type", P_("Shadow type"), P_("Determines how the shadowed box around the viewport is drawn"), GTK_TYPE_SHADOW_TYPE, GTK_SHADOW_IN, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); } static void gtk_viewport_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkViewport *viewport; viewport = GTK_VIEWPORT (object);
static void show_stats(o2fsck_state *ost) { uint32_t num_links; if (!ost->ost_show_stats) return; num_links = ost->ost_links_count - ost->ost_dir_count; printf("\n # of inodes with depth 0/1/2/3/4/5: %u/%u/%u/%u/%u/%u\n", ost->ost_tree_depth_count[0], ost->ost_tree_depth_count[1], ost->ost_tree_depth_count[2], ost->ost_tree_depth_count[3], ost->ost_tree_depth_count[4], ost->ost_tree_depth_count[5]); printf(" # of orphaned inodes found/deleted: %u/%u\n", ost->ost_orphan_count, ost->ost_orphan_deleted_count); printf(P_("\n%12u regular file", "\n%12u regular files", ost->ost_file_count), ost->ost_file_count); printf(P_(" (%u inline,", " (%u inlines,", ost->ost_inline_file_count), ost->ost_inline_file_count); printf(P_(" %u reflink)\n", " %u reflinks)\n", ost->ost_reflinks_count), ost->ost_reflinks_count); printf(P_("%12u directory", "%12u directories", ost->ost_dir_count), ost->ost_dir_count); printf(P_(" (%u inline)\n", " (%u inlines)\n", ost->ost_inline_dir_count), ost->ost_inline_dir_count); printf(P_("%12u character device file\n", "%12u character device files\n", ost->ost_chardev_count), ost->ost_chardev_count); printf(P_("%12u block device file\n", "%12u block device files\n", ost->ost_blockdev_count), ost->ost_blockdev_count); printf(P_("%12u fifo\n", "%12u fifos\n", ost->ost_fifo_count), ost->ost_fifo_count); printf(P_("%12u link\n", "%12u links\n", num_links), num_links); printf(P_("%12u symbolic link", "%12u symbolic links", ost->ost_symlinks_count), ost->ost_symlinks_count); printf(P_(" (%u fast symbolic link)\n", " (%u fast symbolic links)\n", ost->ost_fast_symlinks_count), ost->ost_fast_symlinks_count); printf(P_("%12u socket\n", "%12u sockets\n", ost->ost_sockets_count), ost->ost_sockets_count); printf("\n"); }
static void gtk_printer_cups_class_init (GtkPrinterCupsClass *class) { GObjectClass *object_class = (GObjectClass *) class; object_class->finalize = gtk_printer_cups_finalize; object_class->set_property = gtk_printer_cups_set_property; object_class->get_property = gtk_printer_cups_get_property; gtk_printer_cups_parent_class = g_type_class_peek_parent (class); g_object_class_install_property (G_OBJECT_CLASS (class), PROP_PROFILE_TITLE, g_param_spec_string ("profile-title", P_("Color Profile Title"), P_("The title of the color profile to use"), "", G_PARAM_READABLE)); } static void gtk_printer_cups_init (GtkPrinterCups *printer) { printer->device_uri = NULL; printer->printer_uri = NULL; printer->state = 0; printer->hostname = NULL; printer->port = 0; printer->ppd_name = NULL; printer->ppd_file = NULL;
G_DEFINE_TYPE (GtkStatusIcon, gtk_status_icon, G_TYPE_OBJECT) static void gtk_status_icon_class_init (GtkStatusIconClass *class) { GObjectClass *gobject_class = (GObjectClass *) class; gobject_class->finalize = gtk_status_icon_finalize; gobject_class->set_property = gtk_status_icon_set_property; gobject_class->get_property = gtk_status_icon_get_property; g_object_class_install_property (gobject_class, PROP_PIXBUF, g_param_spec_object ("pixbuf", P_("Pixbuf"), P_("A GdkPixbuf to display"), GDK_TYPE_PIXBUF, GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_FILE, g_param_spec_string ("file", P_("Filename"), P_("Filename to load and display"), NULL, GTK_PARAM_WRITABLE)); g_object_class_install_property (gobject_class, PROP_STOCK, g_param_spec_string ("stock",
void rotate( Matrix1& A, Matrix2& V, const std::size_t p, const std::size_t q ) { typedef typename Matrix1::value_type value_type; auto const one = value_type(1); auto const n = A.row(); // @calc c and s auto const theta = ( A[q][q] - A[p][p] ) / ( A[p][q] + A[p][q] ); auto const t = std::copysign( one / ( std::abs( theta ) + std::hypot( theta, one ) ), theta ); //auto const t = std::copysign( one / ( std::abs(theta) + std::sqrt(theta*theta + one ) ), theta ); auto const c = one / std::hypot( t, one ); //auto const c = one / std::sqrt(t*t + one); auto const s = t * c; // a quick explaination here: // the sparse matrix P, Givens matrix, is // [ 1 0 0 0 .... 0 0 0 0 ] // [ 0 1 0 0 .... 0 0 0 0 ] // [ 0 0 c 0 .... 0 s 0 0 ] <- pth row // [ 0 0 0 1 .... 0 0 0 0 ] // [ . . . . .... . . . . ] // [ 0 0 0 0 .... 1 0 0 0 ] // [ 0 0 -s 0 .... 0 c 0 0 ] <- qth row // [ 0 0 0 0 .... 0 0 1 0 ] // [ 0 0 0 0 .... 0 0 0 1 ] // pth qth // // is reduced to P = I + P_, where I is unit matrix and P_ is // [ 0 0 0 0 .... 0 0 0 0 ] // [ 0 0 0 0 .... 0 0 0 0 ] // [ 0 0 c-1 0 .... 0 s 0 0 ] <- pth row // [ 0 0 0 0 .... 0 0 0 0 ] // [ . . . . .... . . . . ] // [ 0 0 0 0 .... 0 0 0 0 ] // [ 0 0 -s 0 .... 0 c-1 0 0 ] <- qth row // [ 0 0 0 0 .... 0 0 0 0 ] // [ 0 0 0 0 .... 0 0 0 0 ] // pth qth // // this way, the iteratiron of V, V*P = V * (I+P_) = V + V*P_, i.e. V += V*P_ // and the iteration of A, A = P^T * A * P = (I+P_^T) * A * (I+P_) // = ( A + P_^T * A ) * (I + P_) // i.e., A += P_^T * A; A += A * P_; // in another word, here we avoid the multiplications between two dense matrices #if 0 //original version using sparse matrix sparse_matrix<value_type> P_( n, n ); P_( p, p ) = c - one; P_( p, q ) = s; P_( q, q ) = c - one; P_( q, p ) = -s; V += V * P_; // this means V's pth col and qth col changed A += P_.transpose() * A; //this means A's pth row and qth row changed A += A * P_; #endif //optimized version for ( std::size_t i = 0; i != n; ++i ) { auto const vip = V[i][p] * c - V[i][q] * s; auto const viq = V[i][q] * c + V[i][p] * s; V[i][p] = vip; V[i][q] = viq; auto const api = c * A[p][i] - s * A[q][i]; auto const aqi = c * A[q][i] + s * A[p][i]; A[p][i] = api; A[q][i] = aqi; } for ( std::size_t i = 0; i != n; ++i ) { auto const aip = A[i][p] * c - A[i][q] * s; auto const aiq = A[i][q] * c + A[i][p] * s; A[i][p] = aip; A[i][q] = aiq; } } //void rotate
scm_class->get_level = g_unix_credentials_message_get_level; scm_class->get_type = g_unix_credentials_message_get_msg_type; scm_class->serialize = g_unix_credentials_message_serialize; scm_class->deserialize = g_unix_credentials_message_deserialize; /** * GUnixCredentialsMessage:credentials: * * The credentials stored in the message. * * Since: 2.26 */ g_object_class_install_property (gobject_class, PROP_CREDENTIALS, g_param_spec_object ("credentials", P_("Credentials"), P_("The credentials stored in the message"), G_TYPE_CREDENTIALS, G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK)); } /* ---------------------------------------------------------------------------------------------------- */ /** * g_unix_credentials_message_is_supported:
static void gtk_color_button_class_init (GtkColorButtonClass *klass) { GObjectClass *gobject_class; GtkWidgetClass *widget_class; GtkButtonClass *button_class; gobject_class = G_OBJECT_CLASS (klass); widget_class = GTK_WIDGET_CLASS (klass); button_class = GTK_BUTTON_CLASS (klass); gobject_class->get_property = gtk_color_button_get_property; gobject_class->set_property = gtk_color_button_set_property; gobject_class->finalize = gtk_color_button_finalize; widget_class->state_changed = gtk_color_button_state_changed; button_class->clicked = gtk_color_button_clicked; klass->color_set = NULL; /** * GtkColorButton:use-alpha: * * If this property is set to %TRUE, the color swatch on the button is rendered against a * checkerboard background to show its opacity and the opacity slider is displayed in the * color selection dialog. * * Since: 2.4 */ g_object_class_install_property (gobject_class, PROP_USE_ALPHA, g_param_spec_boolean ("use-alpha", P_("Use alpha"), P_("Whether or not to give the color an alpha value"), FALSE, GTK_PARAM_READWRITE)); /** * GtkColorButton:title: * * The title of the color selection dialog * * Since: 2.4 */ g_object_class_install_property (gobject_class, PROP_TITLE, g_param_spec_string ("title", P_("Title"), P_("The title of the color selection dialog"), _("Pick a Color"), GTK_PARAM_READWRITE)); /** * GtkColorButton:color: * * The selected color. * * Since: 2.4 */ g_object_class_install_property (gobject_class, PROP_COLOR, g_param_spec_boxed ("color", P_("Current Color"), P_("The selected color"), GDK_TYPE_COLOR, GTK_PARAM_READWRITE)); /** * GtkColorButton:alpha: * * The selected opacity value (0 fully transparent, 65535 fully opaque). * * Since: 2.4 */ g_object_class_install_property (gobject_class, PROP_ALPHA, g_param_spec_uint ("alpha", P_("Current Alpha"), P_("The selected opacity value (0 fully transparent, 65535 fully opaque)"), 0, 65535, 65535, GTK_PARAM_READWRITE)); /** * GtkColorButton::color-set: * @widget: the object which received the signal. * * The ::color-set signal is emitted when the user selects a color. * When handling this signal, use gtk_color_button_get_color() and * gtk_color_button_get_alpha() to find out which color was just selected. * * Note that this signal is only emitted when the <emphasis>user</emphasis> * changes the color. If you need to react to programmatic color changes * as well, use the notify::color signal. * * Since: 2.4 */ color_button_signals[COLOR_SET] = g_signal_new (I_("color-set"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkColorButtonClass, color_set), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); g_type_class_add_private (gobject_class, sizeof (GtkColorButtonPrivate)); }
static void gtk_app_chooser_button_class_init (GtkAppChooserButtonClass *klass) { GObjectClass *oclass = G_OBJECT_CLASS (klass); GtkComboBoxClass *combo_class = GTK_COMBO_BOX_CLASS (klass); GParamSpec *pspec; oclass->set_property = gtk_app_chooser_button_set_property; oclass->get_property = gtk_app_chooser_button_get_property; oclass->finalize = gtk_app_chooser_button_finalize; oclass->constructed = gtk_app_chooser_button_constructed; combo_class->changed = gtk_app_chooser_button_changed; g_object_class_override_property (oclass, PROP_CONTENT_TYPE, "content-type"); /** * GtkAppChooserButton:show-dialog-item: * * The #GtkAppChooserButton:show-dialog-item property determines * whether the dropdown menu should show an item that triggers * a #GtkAppChooserDialog when clicked. */ pspec = g_param_spec_boolean ("show-dialog-item", P_("Include an 'Other…' item"), P_("Whether the combobox should include an item that triggers a GtkAppChooserDialog"), FALSE, G_PARAM_READWRITE|G_PARAM_CONSTRUCT|G_PARAM_STATIC_STRINGS|G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_property (oclass, PROP_SHOW_DIALOG_ITEM, pspec); /** * GtkAppChooserButton:show-default-item: * * The #GtkAppChooserButton:show-default-item property determines * whether the dropdown menu should show the default application * on top for the provided content type. * * Since: 3.2 */ pspec = g_param_spec_boolean ("show-default-item", P_("Show default item"), P_("Whether the combobox should show the default application on top"), FALSE, G_PARAM_READWRITE|G_PARAM_CONSTRUCT|G_PARAM_STATIC_STRINGS|G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_property (oclass, PROP_SHOW_DEFAULT_ITEM, pspec); /** * GtkAppChooserButton:heading: * * The text to show at the top of the dialog that can be * opened from the button. The string may contain Pango markup. */ pspec = g_param_spec_string ("heading", P_("Heading"), P_("The text to show at the top of the dialog"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS|G_PARAM_EXPLICIT_NOTIFY); g_object_class_install_property (oclass, PROP_HEADING, pspec); /** * GtkAppChooserButton::custom-item-activated: * @self: the object which received the signal * @item_name: the name of the activated item * * Emitted when a custom item, previously added with * gtk_app_chooser_button_append_custom_item(), is activated from the * dropdown menu. */ signals[SIGNAL_CUSTOM_ITEM_ACTIVATED] = g_signal_new ("custom-item-activated", GTK_TYPE_APP_CHOOSER_BUTTON, G_SIGNAL_RUN_FIRST | G_SIGNAL_DETAILED, G_STRUCT_OFFSET (GtkAppChooserButtonClass, custom_item_activated), NULL, NULL, _gtk_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); }
GObjectClass *gobject_class; widget_class = GTK_WIDGET_CLASS (class); gobject_class = G_OBJECT_CLASS (class); widget_class->style_updated = gtk_message_dialog_style_updated; gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_ALERT); gobject_class->constructed = gtk_message_dialog_constructed; gobject_class->set_property = gtk_message_dialog_set_property; gobject_class->get_property = gtk_message_dialog_get_property; gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("message-border", P_("label border"), P_("Width of border around the label in the message dialog"), 0, G_MAXINT, 12, GTK_PARAM_READABLE)); /** * GtkMessageDialog:message-type: * * The type of the message. */ g_object_class_install_property (gobject_class, PROP_MESSAGE_TYPE, g_param_spec_enum ("message-type", P_("Message Type"),
static void g_permission_class_init (GPermissionClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->get_property = g_permission_get_property; /** * GPermission:allowed: * * %TRUE if the caller currently has permission to perform the action that * @permission represents the permission to perform. */ g_object_class_install_property (object_class, PROP_ALLOWED, g_param_spec_boolean ("allowed", P_("Is allowed"), P_("If the caller is allowed to perform the action"), FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); /** * GPermission:can-acquire: * * %TRUE if it is generally possible to acquire the permission by calling * g_permission_acquire(). */ g_object_class_install_property (object_class, PROP_CAN_ACQUIRE, g_param_spec_boolean ("can-acquire", P_("Can acquire"), P_("If calling g_permission_acquire() makes sense"), FALSE,
gtk_cell_renderer_toggle_class_init (GtkCellRendererToggleClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class); object_class->get_property = gtk_cell_renderer_toggle_get_property; object_class->set_property = gtk_cell_renderer_toggle_set_property; cell_class->get_size = gtk_cell_renderer_toggle_get_size; cell_class->render = gtk_cell_renderer_toggle_render; cell_class->activate = gtk_cell_renderer_toggle_activate; g_object_class_install_property (object_class, PROP_ACTIVE, g_param_spec_boolean ("active", P_("Toggle state"), P_("The toggle state of the button"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); g_object_class_install_property (object_class, PROP_INCONSISTENT, g_param_spec_boolean ("inconsistent", P_("Inconsistent state"), P_("The inconsistent state of the button"), FALSE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); g_object_class_install_property (object_class, PROP_ACTIVATABLE, g_param_spec_boolean ("activatable",
static void show_stats(e2fsck_t ctx) { ext2_filsys fs = ctx->fs; ext2_ino_t inodes, inodes_used; blk_t blocks, blocks_used; int dir_links; int num_files, num_links; int frag_percent_file, frag_percent_dir, frag_percent_total; int i, j; dir_links = 2 * ctx->fs_directory_count - 1; num_files = ctx->fs_total_count - dir_links; num_links = ctx->fs_links_count - dir_links; inodes = fs->super->s_inodes_count; inodes_used = (fs->super->s_inodes_count - fs->super->s_free_inodes_count); blocks = fs->super->s_blocks_count; blocks_used = (fs->super->s_blocks_count - fs->super->s_free_blocks_count); frag_percent_file = (10000 * ctx->fs_fragmented) / inodes_used; frag_percent_file = (frag_percent_file + 5) / 10; frag_percent_dir = (10000 * ctx->fs_fragmented_dir) / inodes_used; frag_percent_dir = (frag_percent_dir + 5) / 10; frag_percent_total = ((10000 * (ctx->fs_fragmented + ctx->fs_fragmented_dir)) / inodes_used); frag_percent_total = (frag_percent_total + 5) / 10; if (!verbose) { printf(_("%s: %u/%u files (%0d.%d%% non-contiguous), %u/%u blocks\n"), ctx->device_name, inodes_used, inodes, frag_percent_total / 10, frag_percent_total % 10, blocks_used, blocks); return; } printf (P_("\n%8u inode used (%2.2f%%)\n", "\n%8u inodes used (%2.2f%%)\n", inodes_used), inodes_used, 100.0 * inodes_used / inodes); printf (P_("%8u non-contiguous file (%0d.%d%%)\n", "%8u non-contiguous files (%0d.%d%%)\n", ctx->fs_fragmented), ctx->fs_fragmented, frag_percent_file / 10, frag_percent_file % 10); printf (P_("%8u non-contiguous directory (%0d.%d%%)\n", "%8u non-contiguous directories (%0d.%d%%)\n", ctx->fs_fragmented_dir), ctx->fs_fragmented_dir, frag_percent_dir / 10, frag_percent_dir % 10); printf (_(" # of inodes with ind/dind/tind blocks: %u/%u/%u\n"), ctx->fs_ind_count, ctx->fs_dind_count, ctx->fs_tind_count); for (j=MAX_EXTENT_DEPTH_COUNT-1; j >=0; j--) if (ctx->extent_depth_count[j]) break; if (++j) { printf (_(" Extent depth histogram: ")); for (i=0; i < j; i++) { if (i) fputc('/', stdout); printf("%u", ctx->extent_depth_count[i]); } fputc('\n', stdout); } printf (P_("%8u block used (%2.2f%%)\n", "%8u blocks used (%2.2f%%)\n", blocks_used), blocks_used, 100.0 * blocks_used / blocks); printf (P_("%8u bad block\n", "%8u bad blocks\n", ctx->fs_badblocks_count), ctx->fs_badblocks_count); printf (P_("%8u large file\n", "%8u large files\n", ctx->large_files), ctx->large_files); printf (P_("\n%8u regular file\n", "\n%8u regular files\n", ctx->fs_regular_count), ctx->fs_regular_count); printf (P_("%8u directory\n", "%8u directories\n", ctx->fs_directory_count), ctx->fs_directory_count); printf (P_("%8u character device file\n", "%8u character device files\n", ctx->fs_chardev_count), ctx->fs_chardev_count); printf (P_("%8u block device file\n", "%8u block device files\n", ctx->fs_blockdev_count), ctx->fs_blockdev_count); printf (P_("%8u fifo\n", "%8u fifos\n", ctx->fs_fifo_count), ctx->fs_fifo_count); printf (P_("%8u link\n", "%8u links\n", ctx->fs_links_count - dir_links), ctx->fs_links_count - dir_links); printf (P_("%8u symbolic link", "%8u symbolic links", ctx->fs_symlinks_count), ctx->fs_symlinks_count); printf (P_(" (%u fast symbolic link)\n", " (%u fast symbolic links)\n", ctx->fs_fast_symlinks_count), ctx->fs_fast_symlinks_count); printf (P_("%8u socket\n", "%8u sockets\n", ctx->fs_sockets_count), ctx->fs_sockets_count); printf ("--------\n"); printf (P_("%8u file\n", "%8u files\n", ctx->fs_total_count - dir_links), ctx->fs_total_count - dir_links); }
int unpackchk(const char *const *argv) { int totalcount, sects; struct sectionentry *sectionentries, *se, **sep; struct pkgiterator *it; struct pkginfo *pkg; const char *thissect; char buf[20]; int width; if (*argv) badusage(_("--%s takes no arguments"), cipaction->olong); modstatdb_open(msdbrw_readonly); totalcount= 0; sectionentries = NULL; sects= 0; it = pkg_db_iter_new(); while ((pkg = pkg_db_iter_next_pkg(it))) { if (!yettobeunpacked(pkg, &thissect)) continue; for (se= sectionentries; se && strcasecmp(thissect,se->name); se= se->next); if (!se) { se= nfmalloc(sizeof(struct sectionentry)); for (sep= §ionentries; *sep && strcasecmp(thissect,(*sep)->name) > 0; sep= &(*sep)->next); se->name= thissect; se->count= 0; se->next= *sep; *sep= se; sects++; } se->count++; totalcount++; } pkg_db_iter_free(it); if (totalcount == 0) return 0; if (totalcount <= 12) { it = pkg_db_iter_new(); while ((pkg = pkg_db_iter_next_pkg(it))) { if (!yettobeunpacked(pkg, NULL)) continue; describebriefly(pkg); } pkg_db_iter_free(it); } else if (sects <= 12) { for (se= sectionentries; se; se= se->next) { sprintf(buf,"%d",se->count); printf(_(" %d in %s: "),se->count,se->name); width= 70-strlen(se->name)-strlen(buf); while (width > 59) { putchar(' '); width--; } it = pkg_db_iter_new(); while ((pkg = pkg_db_iter_next_pkg(it))) { const char *pkgname; if (!yettobeunpacked(pkg,&thissect)) continue; if (strcasecmp(thissect,se->name)) continue; pkgname = pkg_name(pkg, pnaw_nonambig); width -= strlen(pkgname); width--; if (width < 4) { printf(" ..."); break; } printf(" %s", pkgname); } pkg_db_iter_free(it); putchar('\n'); } } else { printf(P_(" %d package, from the following section:", " %d packages, from the following sections:", totalcount), totalcount); width= 0; for (se= sectionentries; se; se= se->next) { sprintf(buf,"%d",se->count); width -= (6 + strlen(se->name) + strlen(buf)); if (width < 0) { putchar('\n'); width= 73 - strlen(se->name) - strlen(buf); } printf(" %s (%d)",se->name,se->count); } putchar('\n'); } m_output(stdout, _("<standard output>")); return 0; }
gobject_class->dispatch_properties_changed = gtk_adjustment_dispatch_properties_changed; class->changed = NULL; class->value_changed = NULL; /** * GtkAdjustment:value: * * The value of the adjustment. * * Since: 2.4 */ g_object_class_install_property (gobject_class, PROP_VALUE, g_param_spec_double ("value", P_("Value"), P_("The value of the adjustment"), -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, GTK_PARAM_READWRITE)); /** * GtkAdjustment:lower: * * The minimum value of the adjustment. * * Since: 2.4 */ g_object_class_install_property (gobject_class, PROP_LOWER,