static void
dialog_response (GtkDialog *dialog,
gint response,
gpointer data)
{
if (response == GTK_RESPONSE_CANCEL)
gtk_widget_hide (GTK_WIDGET (dialog));
else if (response == GTK_RESPONSE_OK)
{
GtkColorButton *button = GTK_COLOR_BUTTON (data);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (dialog),
&button->priv->rgba);
gtk_widget_hide (GTK_WIDGET (dialog));
gtk_widget_queue_draw (button->priv->draw_area);
g_signal_emit (button, color_button_signals[COLOR_SET], 0);
g_object_freeze_notify (G_OBJECT (button));
g_object_notify (G_OBJECT (button), "color");
g_object_notify (G_OBJECT (button), "alpha");
g_object_notify (G_OBJECT (button), "rgba");
g_object_thaw_notify (G_OBJECT (button));
}
}
/**
* clutter_behaviour_rotate_set_center:
* @rotate: a #ClutterBehaviourRotate
* @x: X axis center of rotation
* @y: Y axis center of rotation
* @z: Z axis center of rotation
*
* Sets the center of rotation. The coordinates are relative to the plane
* normal to the rotation axis set with clutter_behaviour_rotate_set_axis().
*
* Since: 0.4
*/
void
clutter_behaviour_rotate_set_center (ClutterBehaviourRotate *rotate,
gint x,
gint y,
gint z)
{
ClutterBehaviourRotatePrivate *priv;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ROTATE (rotate));
priv = rotate->priv;
g_object_freeze_notify (G_OBJECT (rotate));
if (priv->center_x != x)
{
priv->center_x = x;
g_object_notify_by_pspec (G_OBJECT (rotate), obj_props[PROP_CENTER_X]);
}
if (priv->center_y != y)
{
priv->center_y = y;
g_object_notify_by_pspec (G_OBJECT (rotate), obj_props[PROP_CENTER_Y]);
}
if (priv->center_z != z)
{
priv->center_z = z;
g_object_notify_by_pspec (G_OBJECT (rotate), obj_props[PROP_CENTER_Z]);
}
g_object_thaw_notify (G_OBJECT (rotate));
}
/**
* clutter_drag_action_set_drag_threshold:
* @action: a #ClutterDragAction
* @x_threshold: a distance on the horizontal axis, in pixels
* @y_threshold: a distance on the vertical axis, in pixels
*
* Sets the horizontal and vertical drag thresholds that must be
* cleared by the pointer before @action can begin the dragging
*
* Since: 1.4
*/
void
clutter_drag_action_set_drag_threshold (ClutterDragAction *action,
guint x_threshold,
guint y_threshold)
{
ClutterDragActionPrivate *priv;
GObject *self;
g_return_if_fail (CLUTTER_IS_DRAG_ACTION (action));
self = G_OBJECT (action);
priv = action->priv;
g_object_freeze_notify (self);
if (priv->x_drag_threshold != x_threshold)
{
priv->x_drag_threshold = x_threshold;
_clutter_notify_by_pspec (self, drag_props[PROP_X_DRAG_THRESHOLD]);
}
if (priv->y_drag_threshold != y_threshold)
{
priv->y_drag_threshold = y_threshold;
_clutter_notify_by_pspec (self, drag_props[PROP_Y_DRAG_THRESHOLD]);
}
g_object_thaw_notify (self);
}
/**
* st_scroll_view_set_policy:
* @scroll: A #StScrollView
* @hscroll: Whether to enable horizontal scrolling
* @vscroll: Whether to enable vertical scrolling
*
* Set the scroll policy.
*/
void
st_scroll_view_set_policy (StScrollView *scroll,
GtkPolicyType hscroll,
GtkPolicyType vscroll)
{
StScrollViewPrivate *priv;
g_return_if_fail (ST_IS_SCROLL_VIEW (scroll));
priv = ST_SCROLL_VIEW (scroll)->priv;
if (priv->hscrollbar_policy == hscroll && priv->vscrollbar_policy == vscroll)
return;
g_object_freeze_notify ((GObject *) scroll);
if (priv->hscrollbar_policy != hscroll)
{
priv->hscrollbar_policy = hscroll;
g_object_notify ((GObject *) scroll, "hscrollbar-policy");
}
if (priv->vscrollbar_policy != vscroll)
{
priv->vscrollbar_policy = vscroll;
g_object_notify ((GObject *) scroll, "vscrollbar-policy");
}
clutter_actor_queue_relayout (CLUTTER_ACTOR (scroll));
g_object_thaw_notify ((GObject *) scroll);
}
static void
reload_tun_properties (NMDeviceTun *self)
{
NMDeviceTunPrivate *priv = NM_DEVICE_TUN_GET_PRIVATE (self);
GObject *object = G_OBJECT (self);
NMPlatformTunProperties props;
if (!nm_platform_tun_get_properties (NM_PLATFORM_GET, nm_device_get_ifindex (NM_DEVICE (self)), &props)) {
_LOGD (LOGD_HW, "could not read tun properties");
return;
}
g_object_freeze_notify (object);
if (priv->props.owner != props.owner)
g_object_notify (object, NM_DEVICE_TUN_OWNER);
if (priv->props.group != props.group)
g_object_notify (object, NM_DEVICE_TUN_GROUP);
if (priv->props.no_pi != props.no_pi)
g_object_notify (object, NM_DEVICE_TUN_NO_PI);
if (priv->props.vnet_hdr != props.vnet_hdr)
g_object_notify (object, NM_DEVICE_TUN_VNET_HDR);
if (priv->props.multi_queue != props.multi_queue)
g_object_notify (object, NM_DEVICE_TUN_MULTI_QUEUE);
memcpy (&priv->props, &props, sizeof (NMPlatformTunProperties));
g_object_thaw_notify (object);
}
/**
* clutter_behaviour_opacity_set_bounds:
* @behaviour: a #ClutterBehaviourOpacity
* @opacity_start: minimum level of opacity
* @opacity_end: maximum level of opacity
*
* Sets the initial and final levels of the opacity applied by @behaviour
* on each actor it controls.
*
* Since: 0.6
*
* Deprecated: 1.6
*/
void
clutter_behaviour_opacity_set_bounds (ClutterBehaviourOpacity *behaviour,
guint8 opacity_start,
guint8 opacity_end)
{
ClutterBehaviourOpacityPrivate *priv;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_OPACITY (behaviour));
priv = behaviour->priv;
g_object_freeze_notify (G_OBJECT (behaviour));
if (priv->opacity_start != opacity_start)
{
priv->opacity_start = opacity_start;
g_object_notify_by_pspec (G_OBJECT (behaviour), obj_props[PROP_OPACITY_START]);
}
if (priv->opacity_end != opacity_end)
{
priv->opacity_end = opacity_end;
g_object_notify_by_pspec (G_OBJECT (behaviour), obj_props[PROP_OPACITY_END]);
}
g_object_thaw_notify (G_OBJECT (behaviour));
}
/**
* gimp_ruler_set_range:
* @ruler: a #GimpRuler
* @lower: the lower limit of the ruler
* @upper: the upper limit of the ruler
* @max_size: the maximum size of the ruler used when calculating the space to
* leave for the text
*
* This sets the range of the ruler.
*
* Since: GIMP 2.8
*/
void
gimp_ruler_set_range (GimpRuler *ruler,
gdouble lower,
gdouble upper,
gdouble max_size)
{
GimpRulerPrivate *priv;
g_return_if_fail (GIMP_IS_RULER (ruler));
priv = GIMP_RULER_GET_PRIVATE (ruler);
g_object_freeze_notify (G_OBJECT (ruler));
if (priv->lower != lower)
{
priv->lower = lower;
g_object_notify (G_OBJECT (ruler), "lower");
}
if (priv->upper != upper)
{
priv->upper = upper;
g_object_notify (G_OBJECT (ruler), "upper");
}
if (priv->max_size != max_size)
{
priv->max_size = max_size;
g_object_notify (G_OBJECT (ruler), "max-size");
}
g_object_thaw_notify (G_OBJECT (ruler));
gtk_widget_queue_draw (GTK_WIDGET (ruler));
}
/* Set monitor index this object belongs to and to monitor */
static void _xfdashboard_window_tracker_monitor_set_index(XfdashboardWindowTrackerMonitor *self, gint inIndex)
{
XfdashboardWindowTrackerMonitorPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_WINDOW_TRACKER_MONITOR(self));
g_return_if_fail(inIndex>=0);
g_return_if_fail(inIndex<gdk_screen_get_n_monitors(self->priv->screen));
priv=self->priv;
/* Freeze notification */
g_object_freeze_notify(G_OBJECT(self));
/* Set value if changed */
if(priv->monitorIndex!=inIndex)
{
/* Set value */
priv->monitorIndex=inIndex;
/* Update primary monitor flag */
_xfdashboard_window_tracker_monitor_update_primary(self);
/* Update geometry of monitor */
_xfdashboard_window_tracker_monitor_update_geometry(self);
}
/* Thaw notification */
g_object_thaw_notify(G_OBJECT(self));
}
static void
gimp_thumbnail_set_info_from_pixbuf (GimpThumbnail *thumbnail,
GdkPixbuf *pixbuf)
{
const gchar *option;
gint num;
g_object_freeze_notify (G_OBJECT (thumbnail));
gimp_thumbnail_reset_info (thumbnail);
g_free (thumbnail->image_mimetype);
thumbnail->image_mimetype =
g_strdup (gdk_pixbuf_get_option (pixbuf, TAG_THUMB_MIMETYPE));
option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_IMAGE_WIDTH);
if (option && sscanf (option, "%d", &num) == 1)
thumbnail->image_width = num;
option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_IMAGE_HEIGHT);
if (option && sscanf (option, "%d", &num) == 1)
thumbnail->image_height = num;
thumbnail->image_type =
g_strdup (gdk_pixbuf_get_option (pixbuf, TAG_THUMB_GIMP_TYPE));
option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_GIMP_LAYERS);
if (option && sscanf (option, "%d", &num) == 1)
thumbnail->image_num_layers = num;
g_object_thaw_notify (G_OBJECT (thumbnail));
}
static void
gucharmap_charmap_set_font_desc_internal (GucharmapCharmap *charmap,
PangoFontDescription *font_desc /* adopting */,
gboolean in_notification)
{
GucharmapCharmapPrivate *priv = charmap->priv;
GObject *object = G_OBJECT (charmap);
gboolean equal;
g_object_freeze_notify (object);
equal = priv->font_desc != NULL &&
pango_font_description_equal (priv->font_desc, font_desc);
if (priv->font_desc)
pango_font_description_free (priv->font_desc);
priv->font_desc = font_desc; /* adopted */
if (!in_notification)
gucharmap_chartable_set_font_desc (priv->chartable, font_desc);
if (gtk_widget_get_style (GTK_WIDGET (priv->details_view)))
gucharmap_charmap_update_text_tags (charmap);
if (!equal)
g_object_notify (G_OBJECT (charmap), "font-desc");
g_object_thaw_notify (object);
}
/**
* gtk_menu_button_set_use_popover:
* @menu_button: a #GtkMenuButton
* @use_popover: %TRUE to construct a popover from the menu model
*
* Sets whether to construct a #GtkPopover instead of #GtkMenu
* when gtk_menu_button_set_menu_model() is called. Note that
* this property is only consulted when a new menu model is set.
*
* Since: 3.12
*/
void
gtk_menu_button_set_use_popover (GtkMenuButton *menu_button,
gboolean use_popover)
{
GtkMenuButtonPrivate *priv;
g_return_if_fail (GTK_IS_MENU_BUTTON (menu_button));
priv = menu_button->priv;
use_popover = use_popover != FALSE;
if (priv->use_popover == use_popover)
return;
priv->use_popover = use_popover;
g_object_freeze_notify (G_OBJECT (menu_button));
if (priv->model)
gtk_menu_button_set_menu_model (menu_button, priv->model);
g_object_notify_by_pspec (G_OBJECT (menu_button), menu_button_props[PROP_USE_POPOVER]);
g_object_thaw_notify (G_OBJECT (menu_button));
}
/**
* egg_find_bar_set_case_sensitive:
*
* Sets whether the search is case sensitive
*
* Since: 2.6
*/
void
egg_find_bar_set_case_sensitive (EggFindBar *find_bar,
gboolean case_sensitive)
{
EggFindBarPrivate *priv;
g_return_if_fail (EGG_IS_FIND_BAR (find_bar));
priv = (EggFindBarPrivate *)find_bar->priv;
g_object_freeze_notify (G_OBJECT (find_bar));
case_sensitive = case_sensitive != FALSE;
if (priv->case_sensitive != case_sensitive)
{
priv->case_sensitive = case_sensitive;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->case_button),
priv->case_sensitive);
g_object_notify (G_OBJECT (find_bar),
"case_sensitive");
}
g_object_thaw_notify (G_OBJECT (find_bar));
}
/*!
\brief sets the current points to empty array
\param curve (MtxCurve *) pointer to curve
\param num_points (gint) size of array to create
*/
gboolean mtx_curve_set_empty_array (MtxCurve *curve, gint num_points)
{
gint i = 0;
MtxCurvePrivate *priv = MTX_CURVE_GET_PRIVATE(curve);
g_return_val_if_fail (MTX_IS_CURVE (curve),FALSE);
g_object_freeze_notify (G_OBJECT (curve));
if (priv->coords)
g_free(priv->coords);
priv->coords = g_new0(MtxCurveCoord,num_points);
priv->num_points = num_points;
priv->highest_x = 0;
priv->highest_y = 0;
priv->lowest_x = 0;
priv->lowest_y = 0;
for (i=0;i<num_points;i++)
{
priv->coords[i].x = 0;
priv->coords[i].y = 0;
}
g_object_thaw_notify (G_OBJECT (curve));
#if GTK_MINOR_VERSION >= 18
if (!gtk_widget_is_sensitive(GTK_WIDGET(curve)))
return TRUE;
#else
if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(curve)))
return TRUE;
#endif
if (priv->auto_rescale_id == 0)
priv->auto_rescale_id = g_timeout_add(1000,(GSourceFunc)auto_rescale,priv);
return TRUE;
}
/*!
\brief sets the current points
\param curve (MtxCurve *) pointer to curve
\param num_points (gint) new value
\param array (MtxCurveCoord*) Array of points
*/
gboolean mtx_curve_set_coords (MtxCurve *curve, gint num_points, MtxCurveCoord *array)
{
/* gint i = 0; */
MtxCurvePrivate *priv = MTX_CURVE_GET_PRIVATE(curve);
g_return_val_if_fail (MTX_IS_CURVE (curve),FALSE);
g_object_freeze_notify (G_OBJECT (curve));
if (priv->coords)
g_free(priv->coords);
priv->coords = g_memdup(array,(num_points*sizeof(MtxCurveCoord)));
priv->num_points = num_points;
recalc_extremes(priv);
/*
for (i=0;i<num_points;i++)
printf("new coord %f,%f\n",priv->coords[i].x,priv->coords[i].y);
*/
g_object_thaw_notify (G_OBJECT (curve));
#if GTK_MINOR_VERSION >= 18
if (!gtk_widget_is_sensitive(GTK_WIDGET(curve)))
return TRUE;
#else
if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(curve)))
return TRUE;
#endif
if (priv->auto_rescale_id == 0)
priv->auto_rescale_id = g_timeout_add(1000,(GSourceFunc)auto_rescale,priv);
return TRUE;
}
/**
* thunarx_property_page_set_label_widget:
* @property_page : a #ThunarxPropertyPage.
* @label_widget : the new label widget.
*
* Sets the label widget for the @property_page. This is the widget
* that will appear in the notebook header for the @property_page.
**/
void
thunarx_property_page_set_label_widget (ThunarxPropertyPage *property_page,
GtkWidget *label_widget)
{
g_return_if_fail (THUNARX_IS_PROPERTY_PAGE (property_page));
g_return_if_fail (label_widget == NULL || (GTK_IS_WIDGET (label_widget) && label_widget->parent == NULL));
if (G_UNLIKELY (label_widget == property_page->priv->label_widget))
return;
/* disconnect from the previous label widget */
if (G_LIKELY (property_page->priv->label_widget != NULL))
g_object_unref (G_OBJECT (property_page->priv->label_widget));
/* activate the new label widget */
property_page->priv->label_widget = label_widget;
/* connect to the new label widget */
if (G_LIKELY (label_widget != NULL))
{
g_object_ref (G_OBJECT (label_widget));
gtk_object_sink (GTK_OBJECT (label_widget));
}
/* notify listeners */
g_object_freeze_notify (G_OBJECT (property_page));
g_object_notify (G_OBJECT (property_page), "label");
g_object_notify (G_OBJECT (property_page), "label-widget");
g_object_thaw_notify (G_OBJECT (property_page));
}
/**
* up_device_coldplug:
*
* Return %TRUE on success, %FALSE if we failed to get data and should be removed
**/
gboolean
up_device_coldplug (UpDevice *device, UpDaemon *daemon, GObject *native)
{
gboolean ret;
const gchar *native_path;
UpDeviceClass *klass = UP_DEVICE_GET_CLASS (device);
gchar *id = NULL;
g_return_val_if_fail (UP_IS_DEVICE (device), FALSE);
/* save */
device->priv->native = g_object_ref (native);
device->priv->daemon = g_object_ref (daemon);
native_path = up_native_get_native_path (native);
device->priv->native_path = g_strdup (native_path);
/* stop signals and callbacks */
g_object_freeze_notify (G_OBJECT(device));
device->priv->during_coldplug = TRUE;
/* coldplug source */
if (klass->coldplug != NULL) {
ret = klass->coldplug (device);
if (!ret) {
g_debug ("failed to coldplug %s", device->priv->native_path);
goto out;
}
}
/* only put on the bus if we succeeded */
ret = up_device_register_device (device);
if (!ret) {
g_warning ("failed to register device %s", device->priv->native_path);
goto out;
}
/* force a refresh, although failure isn't fatal */
ret = up_device_refresh_internal (device);
if (!ret) {
g_debug ("failed to refresh %s", device->priv->native_path);
/* TODO: refresh should really have seporate
* success _and_ changed parameters */
ret = TRUE;
goto out;
}
/* get the id so we can load the old history */
id = up_device_get_id (device);
if (id != NULL)
up_history_set_id (device->priv->history, id);
out:
/* start signals and callbacks */
g_object_thaw_notify (G_OBJECT(device));
device->priv->during_coldplug = FALSE;
g_free (id);
return ret;
}
static void
gimp_curves_tool_reset (GimpImageMapTool *image_map_tool)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);
GimpCurvesConfig *default_config;
GimpHistogramChannel channel;
default_config = GIMP_CURVES_CONFIG (image_map_tool->default_config);
for (channel = GIMP_HISTOGRAM_VALUE;
channel <= GIMP_HISTOGRAM_ALPHA;
channel++)
{
if (default_config)
{
GimpCurveType curve_type = tool->config->curve[channel]->curve_type;
g_object_freeze_notify (G_OBJECT (tool->config->curve[channel]));
gimp_config_copy (GIMP_CONFIG (default_config->curve[channel]),
GIMP_CONFIG (tool->config->curve[channel]),
0);
g_object_set (tool->config->curve[channel],
"curve-type", curve_type,
NULL);
g_object_thaw_notify (G_OBJECT (tool->config->curve[channel]));
}
else
{
gimp_curve_reset (tool->config->curve[channel], FALSE);
}
}
}
static void
gimp_color_balance_tool_reset (GimpImageMapTool *im_tool)
{
GimpColorBalanceTool *cb_tool = GIMP_COLOR_BALANCE_TOOL (im_tool);
GimpTransferMode range = cb_tool->config->range;
g_object_freeze_notify (im_tool->config);
if (im_tool->default_config)
{
gimp_config_copy (GIMP_CONFIG (im_tool->default_config),
GIMP_CONFIG (im_tool->config),
0);
}
else
{
gimp_config_reset (GIMP_CONFIG (im_tool->config));
}
g_object_set (cb_tool->config,
"range", range,
NULL);
g_object_thaw_notify (im_tool->config);
}
/**
* clutter_snap_constraint_set_edges:
* @constraint: a #ClutterSnapConstraint
* @from_edge: the edge on the actor
* @to_edge: the edge on the source
*
* Sets the edges to be used by the @constraint
*
* The @from_edge is the edge on the #ClutterActor to which @constraint
* has been added. The @to_edge is the edge of the #ClutterActor inside
* the #ClutterSnapConstraint:source property.
*
*
*/
void
clutter_snap_constraint_set_edges (ClutterSnapConstraint *constraint,
ClutterSnapEdge from_edge,
ClutterSnapEdge to_edge)
{
gboolean from_changed = FALSE, to_changed = FALSE;
g_return_if_fail (CLUTTER_IS_SNAP_CONSTRAINT (constraint));
g_object_freeze_notify (G_OBJECT (constraint));
if (constraint->from_edge != from_edge)
{
constraint->from_edge = from_edge;
g_object_notify_by_pspec (G_OBJECT (constraint),
obj_props[PROP_FROM_EDGE]);
from_changed = TRUE;
}
if (constraint->to_edge != to_edge)
{
constraint->to_edge = to_edge;
g_object_notify_by_pspec (G_OBJECT (constraint),
obj_props[PROP_TO_EDGE]);
to_changed = TRUE;
}
if ((from_changed || to_changed) &&
constraint->actor != NULL)
{
clutter_actor_queue_relayout (constraint->actor);
}
g_object_thaw_notify (G_OBJECT (constraint));
}
void
_cinnamon_app_add_window (CinnamonApp *app,
MetaWindow *window)
{
guint32 user_time;
if (app->running_state && g_slist_find (app->running_state->windows, window))
return;
g_object_freeze_notify (G_OBJECT (app));
if (!app->running_state)
create_running_state (app);
app->running_state->window_sort_stale = TRUE;
app->running_state->windows = g_slist_prepend (app->running_state->windows, g_object_ref (window));
g_signal_connect (window, "unmanaged", G_CALLBACK(cinnamon_app_on_unmanaged), app);
g_signal_connect (window, "notify::user-time", G_CALLBACK(cinnamon_app_on_user_time_changed), app);
user_time = meta_window_get_user_time (window);
if (user_time > app->running_state->last_user_time)
app->running_state->last_user_time = user_time;
if (app->state != CINNAMON_APP_STATE_STARTING)
cinnamon_app_state_transition (app, CINNAMON_APP_STATE_RUNNING);
g_object_thaw_notify (G_OBJECT (app));
g_signal_emit (app, cinnamon_app_signals[WINDOWS_CHANGED], 0);
}
static gboolean
purple_circular_buffer_real_mark_read(PurpleCircularBuffer *buffer,
gsize len)
{
PurpleCircularBufferPrivate *priv = NULL;
GObject *obj;
g_return_val_if_fail(purple_circular_buffer_get_max_read(buffer) >= len, FALSE);
priv = PURPLE_CIRCULAR_BUFFER_GET_PRIVATE(buffer);
priv->output += len;
priv->bufused -= len;
/* wrap to the start if we're at the end */
if ((gsize)(priv->output - priv->buffer) == priv->buflen)
priv->output = priv->buffer;
obj = G_OBJECT(buffer);
g_object_freeze_notify(obj);
g_object_notify_by_pspec(obj, properties[PROP_BUFFER_USED]);
g_object_notify_by_pspec(obj, properties[PROP_OUTPUT]);
g_object_thaw_notify(obj);
return TRUE;
}
static void
update_properties (NMDevice *device)
{
NMDeviceMacvlan *self = NM_DEVICE_MACVLAN (device);
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE (device);
GObject *object = G_OBJECT (device);
NMPlatformMacvlanProperties props;
if (!nm_platform_macvlan_get_properties (nm_device_get_ifindex (device), &props)) {
_LOGW (LOGD_HW, "could not read macvlan properties");
return;
}
g_object_freeze_notify (object);
if (priv->props.parent_ifindex != props.parent_ifindex)
g_object_notify (object, NM_DEVICE_MACVLAN_PARENT);
if (g_strcmp0 (priv->props.mode, props.mode) != 0)
g_object_notify (object, NM_DEVICE_MACVLAN_MODE);
if (priv->props.no_promisc != props.no_promisc)
g_object_notify (object, NM_DEVICE_MACVLAN_NO_PROMISC);
memcpy (&priv->props, &props, sizeof (NMPlatformMacvlanProperties));
g_object_thaw_notify (object);
}
/**
* g_permission_impl_update:
* @permission: a #GPermission instance
* @allowed: the new value for the 'allowed' property
* @can_acquire: the new value for the 'can-acquire' property
* @can_release: the new value for the 'can-release' property
*
* This function is called by the #GPermission implementation to update
* the properties of the permission. You should never call this
* function except from a #GPermission implementation.
*
* GObject notify signals are generated, as appropriate.
*
* Since: 2.26
**/
void
g_permission_impl_update (GPermission *permission,
gboolean allowed,
gboolean can_acquire,
gboolean can_release)
{
GObject *object = G_OBJECT (permission);
g_object_freeze_notify (object);
if (allowed != permission->priv->allowed)
{
permission->priv->allowed = !!allowed;
g_object_notify (object, "allowed");
}
if (can_acquire != permission->priv->can_acquire)
{
permission->priv->can_acquire = !!can_acquire;
g_object_notify (object, "can-acquire");
}
if (can_release != permission->priv->can_release)
{
permission->priv->can_release = !!can_release;
g_object_notify (object, "can-release");
}
g_object_thaw_notify (object);
}
static void
nmt_newt_entry_set_text_internal (NmtNewtEntry *entry,
const char *text,
newtComponent co)
{
NmtNewtEntryPrivate *priv = NMT_NEWT_ENTRY_GET_PRIVATE (entry);
if (!text)
text = "";
if (!strcmp (priv->text, text))
return;
g_free (priv->text);
priv->text = g_strdup (text);
if (co) {
char *text_lc;
text_lc = priv->text ? nmt_newt_locale_from_utf8 (priv->text) : NULL;
newtEntrySet (co, text_lc, TRUE);
g_free (text_lc);
priv->last_cursor_pos = -1;
}
g_object_freeze_notify (G_OBJECT (entry));
nmt_newt_entry_check_valid (entry);
g_object_notify (G_OBJECT (entry), "text");
g_object_thaw_notify (G_OBJECT (entry));
}
/**
* clutter_behaviour_rotate_set_bounds:
* @rotate: a #ClutterBehaviourRotate
* @angle_start: initial angle in degrees, between 0 and 360.
* @angle_end: final angle in degrees, between 0 and 360.
*
* Sets the initial and final angles of a rotation behaviour; angles >= 360
* degrees get clamped to the canonical interval <0, 360).
*
* Since: 0.4
*/
void
clutter_behaviour_rotate_set_bounds (ClutterBehaviourRotate *rotate,
gdouble angle_start,
gdouble angle_end)
{
ClutterBehaviourRotatePrivate *priv;
g_return_if_fail (CLUTTER_IS_BEHAVIOUR_ROTATE (rotate));
priv = rotate->priv;
g_object_freeze_notify (G_OBJECT (rotate));
if (priv->angle_start != angle_start)
{
priv->angle_start = clamp_angle (angle_start);
g_object_notify_by_pspec (G_OBJECT (rotate), obj_props[PROP_ANGLE_START]);
}
if (priv->angle_end != angle_end)
{
priv->angle_end = clamp_angle (angle_end);
g_object_notify_by_pspec (G_OBJECT (rotate), obj_props[PROP_ANGLE_END]);
}
g_object_thaw_notify (G_OBJECT (rotate));
}
/**
* mx_bin_set_fill:
* @bin: a #MxBin
* @x_fill: %TRUE if the child should fill horizontally the @bin
* @y_fill: %TRUE if the child should fill vertically the @bin
*
* Sets whether the child of @bin should fill out the horizontal
* and/or vertical allocation of the parent
*/
void
mx_bin_set_fill (MxBin *bin,
gboolean x_fill,
gboolean y_fill)
{
MxBinPrivate *priv;
gboolean changed = FALSE;
g_return_if_fail (MX_IS_BIN (bin));
priv = bin->priv;
g_object_freeze_notify (G_OBJECT (bin));
if (priv->x_fill != x_fill)
{
priv->x_fill = x_fill;
changed = TRUE;
g_object_notify (G_OBJECT (bin), "x-fill");
}
if (priv->y_fill != y_fill)
{
priv->y_fill = y_fill;
changed = TRUE;
g_object_notify (G_OBJECT (bin), "y-fill");
}
if (changed)
clutter_actor_queue_relayout (CLUTTER_ACTOR (bin));
g_object_thaw_notify (G_OBJECT (bin));
}
static void
gimp_levels_tool_reset (GimpImageMapTool *image_map_tool)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool);
GimpHistogramChannel channel = tool->config->channel;
g_object_freeze_notify (image_map_tool->config);
if (image_map_tool->default_config)
{
gimp_config_copy (GIMP_CONFIG (image_map_tool->default_config),
GIMP_CONFIG (image_map_tool->config),
0);
}
else
{
gimp_config_reset (GIMP_CONFIG (image_map_tool->config));
}
g_object_set (tool->config,
"channel", channel,
NULL);
g_object_thaw_notify (image_map_tool->config);
}
void
st_icon_set_icon_name (StIcon *icon,
const gchar *icon_name)
{
StIconPrivate *priv = icon->priv;
GIcon *gicon = NULL;
g_return_if_fail (ST_IS_ICON (icon));
if (icon_name)
gicon = g_themed_icon_new_with_default_fallbacks (icon_name);
if (g_icon_equal (priv->gicon, gicon)) /* do nothing */
{
g_object_unref (gicon);
return;
}
if (priv->gicon)
g_object_unref (priv->gicon);
g_object_freeze_notify (G_OBJECT (icon));
priv->gicon = gicon;
g_object_notify (G_OBJECT (icon), "gicon");
g_object_notify (G_OBJECT (icon), "icon-name");
g_object_thaw_notify (G_OBJECT (icon));
st_icon_update (icon);
}
/**
* st_bin_set_alignment:
* @bin: a #StBin
* @x_align: horizontal alignment
* @y_align: vertical alignment
*
* Sets the horizontal and vertical alignment of the child
* inside a #StBin.
*/
void
st_bin_set_alignment (StBin *bin,
StAlign x_align,
StAlign y_align)
{
StBinPrivate *priv;
gboolean changed = FALSE;
g_return_if_fail (ST_IS_BIN (bin));
priv = bin->priv;
g_object_freeze_notify (G_OBJECT (bin));
if (priv->x_align != x_align)
{
priv->x_align = x_align;
g_object_notify (G_OBJECT (bin), "x-align");
changed = TRUE;
}
if (priv->y_align != y_align)
{
priv->y_align = y_align;
g_object_notify (G_OBJECT (bin), "y-align");
changed = TRUE;
}
if (changed)
clutter_actor_queue_relayout (CLUTTER_ACTOR (bin));
g_object_thaw_notify (G_OBJECT (bin));
}
NMAccessPoint *
nm_ap_new_from_properties (GHashTable *properties)
{
NMAccessPoint *ap;
GTimeVal cur_time;
const struct ether_addr * addr;
const char bad_bssid1[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
const char bad_bssid2[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
g_return_val_if_fail (properties != NULL, NULL);
ap = nm_ap_new ();
g_object_freeze_notify (G_OBJECT (ap));
g_hash_table_foreach (properties, foreach_property_cb, ap);
/* ignore APs with invalid BSSIDs */
addr = nm_ap_get_address (ap);
if ( !(memcmp (addr->ether_addr_octet, bad_bssid1, ETH_ALEN))
|| !(memcmp (addr->ether_addr_octet, bad_bssid2, ETH_ALEN))) {
g_object_unref (ap);
return NULL;
}
g_get_current_time (&cur_time);
nm_ap_set_last_seen (ap, cur_time.tv_sec);
if (!nm_ap_get_ssid (ap))
nm_ap_set_broadcast (ap, FALSE);
g_object_thaw_notify (G_OBJECT (ap));
return ap;
}