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,
