static void dialog_response (GtkWidget * widget, GtkResponseType response, gpointer data) { GSMColorButton *color_button = GSM_COLOR_BUTTON (data); GtkColorSelection *color_selection; if (response == GTK_RESPONSE_OK) { color_selection = GTK_COLOR_SELECTION (gtk_color_selection_dialog_get_color_selection (GTK_COLOR_SELECTION_DIALOG (color_button->priv->cs_dialog))); gtk_color_selection_get_current_color (color_selection, &color_button->priv->color); gtk_widget_hide (color_button->priv->cs_dialog); gtk_widget_queue_draw (GTK_WIDGET (&color_button->widget)); g_signal_emit (color_button, color_button_signals[COLOR_SET], 0); g_object_freeze_notify (G_OBJECT (color_button)); g_object_notify (G_OBJECT (color_button), "color"); g_object_thaw_notify (G_OBJECT (color_button)); } else /* (response == GTK_RESPONSE_CANCEL) */ gtk_widget_hide (color_button->priv->cs_dialog); }
/** * 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); }
/** * 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)); }
/** * 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)); }
/** * 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)); }
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 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)); }
/** * gtk_shruler_set_range: * @ruler: a #GtkSHRuler * @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: GTK 2.8 */ void gtk_shruler_set_range (GtkSHRuler *ruler, gdouble lower, gdouble upper, gdouble max_size) { GtkSHRulerPrivate *priv; g_return_if_fail (GTK_IS_SHRULER (ruler)); priv = GTK_SHRULER_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)); }
/*! \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; }
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; }
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)); } }
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); }
/** * 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_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)); }
/** * 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; }
/*! \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; }
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); }
/** * 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)); }
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); }
void gucharmap_charmap_set_chapters_model (GucharmapCharmap *charmap, GucharmapChaptersModel *model) { GucharmapCharmapPrivate *priv = charmap->priv; GObject *object = G_OBJECT (charmap); gunichar wc; g_object_freeze_notify (object); g_object_notify (G_OBJECT (charmap), "chapters-model"); gucharmap_chapters_view_set_model (priv->chapters_view, model); if (!model) { g_object_thaw_notify (object); return; } if (priv->last_character_set) { wc = gucharmap_chartable_get_active_character (priv->chartable); gucharmap_charmap_set_active_character (charmap, wc); } priv->last_character_set = TRUE; g_object_thaw_notify (object); }
/** * mx_bin_set_alignment: * @bin: a #MxBin * @x_align: horizontal alignment * @y_align: vertical alignment * * Sets the horizontal and vertical alignment of the child * inside a #MxBin. */ void mx_bin_set_alignment (MxBin *bin, MxAlign x_align, MxAlign y_align) { 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_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)); }
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); }
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); }
/** * 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)); }
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); } } }
/* 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)); }
/** * 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: 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)); priv->backing_store_valid = FALSE; gtk_widget_queue_draw (GTK_WIDGET (ruler)); }
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)); }
/** * 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 gimp_levels_config_stretch (GimpLevelsConfig *config, GimpHistogram *histogram, gboolean is_color) { g_return_if_fail (GIMP_IS_LEVELS_CONFIG (config)); g_return_if_fail (histogram != NULL); g_object_freeze_notify (G_OBJECT (config)); if (is_color) { GimpHistogramChannel channel; /* Set the overall value to defaults */ channel = config->channel; config->channel = GIMP_HISTOGRAM_VALUE; gimp_levels_config_reset_channel (config); config->channel = channel; for (channel = GIMP_HISTOGRAM_RED; channel <= GIMP_HISTOGRAM_BLUE; channel++) { gimp_levels_config_stretch_channel (config, histogram, channel); } } else { gimp_levels_config_stretch_channel (config, histogram, GIMP_HISTOGRAM_VALUE); } g_object_thaw_notify (G_OBJECT (config)); }