void
gb_keybindings_set_mode (GbKeybindings *self,
const gchar *mode)
{
g_return_if_fail (GB_IS_KEYBINDINGS (self));
if (mode != self->mode)
{
g_free (self->mode);
self->mode = g_strdup (mode);
if (self->constructed)
gb_keybindings_reload (self);
g_object_notify_by_pspec (G_OBJECT (self), gParamSpecs [PROP_MODE]);
}
}
static void
update_identifier (PolariRoom *room)
{
PolariRoomPrivate *priv = room->priv;
const char *id = NULL;
if (priv->channel)
id = tp_channel_get_identifier (priv->channel);
g_clear_pointer (&priv->display_name, g_free);
if (id)
priv->display_name = g_strdup (id + (id[0] == '#' ? 1 : 0));
g_object_notify_by_pspec (G_OBJECT (room), props[PROP_DISPLAY_NAME]);
}
void
gb_project_tree_set_show_ignored_files (GbProjectTree *self,
gboolean show_ignored_files)
{
g_return_if_fail (GB_IS_PROJECT_TREE (self));
show_ignored_files = !!show_ignored_files;
if (show_ignored_files != self->show_ignored_files)
{
self->show_ignored_files = show_ignored_files;
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SHOW_IGNORED_FILES]);
ide_tree_rebuild (IDE_TREE (self));
}
}
void
gb_command_provider_set_priority (GbCommandProvider *provider,
gint priority)
{
GbCommandProviderPrivate *priv = gb_command_provider_get_instance_private (provider);
g_return_if_fail (GB_IS_COMMAND_PROVIDER (provider));
if (priv->priority != priority)
{
priv->priority = priority;
g_object_notify_by_pspec (G_OBJECT (provider),
gParamSpecs [PROP_PRIORITY]);
}
}
void
gb_source_view_snippet_insert (GbSourceViewSnippet *snippet,
GtkTextBuffer *buffer,
GtkTextIter *location)
{
GbSourceViewSnippetPrivate *priv;
GbSourceViewSnippetChunk *chunk;
guint i;
g_return_if_fail(GB_IS_SOURCE_VIEW_SNIPPET(snippet));
g_return_if_fail(location);
priv = snippet->priv;
if (priv->mark_begin || priv->mark_end) {
g_warning("Cannot overwrite previous snippet position.");
return;
}
priv->mark_begin = gtk_text_buffer_create_mark(buffer, NULL, location, TRUE);
for (i = 0; i < priv->chunks->len; i++) {
chunk = g_ptr_array_index(priv->chunks, i);
gb_source_view_snippet_chunk_insert(chunk, buffer, location);
}
priv->mark_end = gtk_text_buffer_create_mark(buffer, NULL, location, FALSE);
for (i = 0; i < priv->chunks->len; i++) {
chunk = g_ptr_array_index(priv->chunks, i);
gb_source_view_snippet_chunk_build_marks(chunk, buffer);
}
g_object_notify_by_pspec(G_OBJECT(snippet), gParamSpecs[PROP_MARK_BEGIN]);
g_object_notify_by_pspec(G_OBJECT(snippet), gParamSpecs[PROP_MARK_END]);
}
void
gthree_basic_material_set_vertex_colors (GthreeBasicMaterial *basic,
GthreeColorType color_type)
{
GthreeBasicMaterialPrivate *priv = gthree_basic_material_get_instance_private (basic);
if (priv->vertex_colors == color_type)
return;
priv->vertex_colors = color_type;
gthree_material_set_needs_update (GTHREE_MATERIAL (basic), TRUE);
g_object_notify_by_pspec (G_OBJECT (basic), obj_props[PROP_VERTEX_COLORS]);
}
void
aws_s3_client_set_host (AwsS3Client *client,
const gchar *host)
{
AwsS3ClientPrivate *priv = aws_s3_client_get_instance_private (client);
g_return_if_fail(AWS_IS_S3_CLIENT(client));
if (g_strcmp0 (priv->host, host) != 0)
{
g_free (priv->host);
priv->host = g_strdup (host);
g_object_notify_by_pspec (G_OBJECT (client), properties [PROP_HOST]);
}
}
/**
* gtk_level_bar_set_mode:
* @self: a #GtkLevelBar
* @mode: a #GtkLevelBarMode
*
* Sets the value of the #GtkLevelBar:mode property.
*
* Since: 3.6
*/
void
gtk_level_bar_set_mode (GtkLevelBar *self,
GtkLevelBarMode mode)
{
g_return_if_fail (GTK_IS_LEVEL_BAR (self));
if (self->priv->bar_mode != mode)
{
self->priv->bar_mode = mode;
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MODE]);
gtk_level_bar_update_mode_style_classes (self);
gtk_widget_queue_resize (GTK_WIDGET (self));
}
}
static void
gb_search_context_set_search_text (GbSearchContext *context,
const gchar *search_text)
{
g_return_if_fail (GB_IS_SEARCH_CONTEXT (context));
g_return_if_fail (search_text);
if (search_text != context->priv->search_text)
{
g_free (context->priv->search_text);
context->priv->search_text = g_strdup (search_text);
g_object_notify_by_pspec (G_OBJECT (context),
gParamSpecs [PROP_SEARCH_TEXT]);
}
}
void
pnl_dock_overlay_edge_set_edge (PnlDockOverlayEdge *self,
GtkPositionType edge)
{
g_return_if_fail (PNL_IS_DOCK_OVERLAY_EDGE (self));
g_return_if_fail (edge >= 0);
g_return_if_fail (edge <= 3);
if (edge != self->edge)
{
self->edge = edge;
pnl_dock_overlay_edge_update_edge (self);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_EDGE]);
}
}
static void
ide_project_file_set_path (IdeProjectFile *self,
const gchar *path)
{
IdeProjectFilePrivate *priv = ide_project_file_get_instance_private (self);
g_return_if_fail (IDE_IS_PROJECT_FILE (self));
if (priv->path != path)
{
g_free (priv->path);
priv->path = g_strdup (path);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_PATH]);
}
}
static void
ide_highlight_engine_set_highlighter (IdeHighlightEngine *self,
IdeHighlighter *highlighter)
{
g_return_if_fail (IDE_IS_HIGHLIGHT_ENGINE (self));
g_return_if_fail (!highlighter || IDE_IS_HIGHLIGHTER (highlighter));
if (g_set_object (&self->highlighter, highlighter))
{
if (highlighter != NULL)
IDE_HIGHLIGHTER_GET_IFACE (highlighter)->set_engine (highlighter, self);
ide_highlight_engine_reload (self);
g_object_notify_by_pspec (G_OBJECT (self), gParamSpecs [PROP_HIGHLIGHTER]);
}
}
/**
* gtk_revealer_set_transition_type:
* @revealer: a #GtkRevealer
* @transition: the new transition type
*
* Sets the type of animation that will be used for
* transitions in @revealer. Available types include
* various kinds of fades and slides.
*
* Since: 3.10
*/
void
gtk_revealer_set_transition_type (GtkRevealer *revealer,
GtkRevealerTransitionType transition)
{
GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);
g_return_if_fail (GTK_IS_REVEALER (revealer));
if (priv->transition_type == transition)
return;
priv->transition_type = transition;
gtk_widget_queue_resize (GTK_WIDGET (revealer));
g_object_notify_by_pspec (G_OBJECT (revealer), props[PROP_TRANSITION_TYPE]);
}
/**
* clutter_zoom_action_set_zoom_axis:
* @action: a #ClutterZoomAction
* @axis: the axis to constraint the zooming to
*
* Restricts the zooming action to a specific axis
*
*
*/
void
clutter_zoom_action_set_zoom_axis (ClutterZoomAction *action,
ClutterZoomAxis axis)
{
g_return_if_fail (CLUTTER_IS_ZOOM_ACTION (action));
g_return_if_fail (axis >= CLUTTER_ZOOM_X_AXIS &&
axis <= CLUTTER_ZOOM_BOTH);
if (action->priv->zoom_axis == axis)
return;
action->priv->zoom_axis = axis;
g_object_notify_by_pspec (G_OBJECT (action), zoom_props[PROP_ZOOM_AXIS]);
}
void
gthree_basic_material_set_color (GthreeBasicMaterial *basic,
const GdkRGBA *color)
{
GthreeBasicMaterialPrivate *priv = gthree_basic_material_get_instance_private (basic);
if (gdk_rgba_equal (color, &priv->color))
return;
priv->color = *color;
gthree_material_set_needs_update (GTHREE_MATERIAL (basic), TRUE);
g_object_notify_by_pspec (G_OBJECT (basic), obj_props[PROP_COLOR]);
}
void
ide_configuration_set_debug (IdeConfiguration *self,
gboolean debug)
{
g_return_if_fail (IDE_IS_CONFIGURATION (self));
debug = !!debug;
if (debug != self->debug)
{
self->debug = debug;
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_DEBUG]);
ide_configuration_set_dirty (self, TRUE);
}
}
void
gthree_basic_material_set_shading_type (GthreeBasicMaterial *basic,
GthreeShadingType shading_type)
{
GthreeBasicMaterialPrivate *priv = gthree_basic_material_get_instance_private (basic);
if (priv->shading_type == shading_type)
return;
priv->shading_type = shading_type;
gthree_material_set_needs_update (GTHREE_MATERIAL (basic), TRUE);
g_object_notify_by_pspec (G_OBJECT (basic), obj_props[PROP_SHADING_TYPE]);
}
/**
* egg_scrolled_window_set_max_content_height:
* @max_content_height: the max allowed height request or -1 to ignore.
*
* This function will set the "max-content-height" property. This property is
* used to determine the maximum height that the scrolled window will request.
*
* This is useful if you want to have a scrolled window grow with the child
* allocation, but only up to a certain height.
*/
void
egg_scrolled_window_set_max_content_height (EggScrolledWindow *self,
gint max_content_height)
{
EggScrolledWindowPrivate *priv = egg_scrolled_window_get_instance_private (self);
g_return_if_fail (EGG_IS_SCROLLED_WINDOW (self));
if (max_content_height != priv->max_content_height)
{
priv->max_content_height = max_content_height;
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_MAX_CONTENT_HEIGHT]);
gtk_widget_queue_resize (GTK_WIDGET (self));
}
}
void
gthree_basic_material_set_combine (GthreeBasicMaterial *basic,
GthreeOperation combine)
{
GthreeBasicMaterialPrivate *priv = gthree_basic_material_get_instance_private (basic);
if (priv->combine == combine)
return;
priv->combine = combine;
gthree_material_set_needs_update (GTHREE_MATERIAL (basic), TRUE);
g_object_notify_by_pspec (G_OBJECT (basic), obj_props[PROP_COMBINE]);
}
static void
mail_task_set_fraction (MailTask *task,
gdouble fraction)
{
MailTaskPrivate *priv;
g_return_if_fail(MAIL_IS_TASK(task));
g_return_if_fail(fraction >= 0.0);
g_return_if_fail(fraction <= 1.0);
priv = task->priv;
priv->fraction = fraction;
g_object_notify_by_pspec(G_OBJECT(task), pspecs[PROP_FRACTION]);
}
/**
* gedit_document_set_short_name_for_display:
* @doc:
* @short_name: (allow-none):
*
* Deprecated: 3.18: Unused function. The intent is to change the
* #GeditDocument:shortname property to be read-only.
*/
void
gedit_document_set_short_name_for_display (GeditDocument *doc,
const gchar *short_name)
{
GeditDocumentPrivate *priv;
g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
priv = gedit_document_get_instance_private (doc);
g_free (priv->short_name);
priv->short_name = g_strdup (short_name);
g_object_notify_by_pspec (G_OBJECT (doc), properties[PROP_SHORTNAME]);
}
void
gb_source_view_set_search_text (GbSourceView *view,
const gchar *search_text)
{
GbSourceViewPrivate *priv;
g_return_if_fail(GB_IS_SOURCE_VIEW(view));
priv = view->priv;
g_clear_pointer(&priv->search_text, g_free);
g_clear_pointer(&priv->search_regex, g_regex_unref);
priv->search_text = g_strdup(search_text);
gb_source_view_update_search(view);
if (priv->has_matches) {
gb_source_view_move_next_match(view);
}
g_object_notify_by_pspec(G_OBJECT(view), gParamSpecs[PROP_SEARCH_REGEX]);
g_object_notify_by_pspec(G_OBJECT(view), gParamSpecs[PROP_SEARCH_TEXT]);
}
static void
meta_background_actor_set_dim_factor (MetaBackgroundActor *self,
gfloat dim_factor)
{
MetaBackgroundActorPrivate *priv = self->priv;
if (priv->dim_factor == dim_factor)
return;
priv->dim_factor = dim_factor;
clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_DIM_FACTOR]);
}
/**
* gb_scrolled_window_set_max_content_height:
* @max_content_height: the max allowed height request or -1 to ignore.
*
* This function will set the "max-content-height" property. This property is
* used to determine the maximum height that the scrolled window will request.
*
* This is useful if you want to have a scrolled window grow with the child
* allocation, but only up to a certain height.
*/
static void
gb_scrolled_window_set_max_content_height (GbScrolledWindow *self,
gint max_content_height)
{
GbScrolledWindowPrivate *priv = gb_scrolled_window_get_instance_private (self);
g_return_if_fail (GB_IS_SCROLLED_WINDOW (self));
if (max_content_height != priv->max_content_height)
{
priv->max_content_height = max_content_height;
g_object_notify_by_pspec (G_OBJECT (self), gParamSpecs [PROP_MAX_CONTENT_HEIGHT]);
gtk_widget_queue_resize (GTK_WIDGET (self));
}
}
void
gb_source_view_snippet_finish (GbSourceViewSnippet *snippet)
{
GbSourceViewSnippetPrivate *priv;
GbSourceViewSnippetChunk *chunk;
GtkTextBuffer *buffer;
guint i;
g_return_if_fail(GB_IS_SOURCE_VIEW_SNIPPET(snippet));
priv = snippet->priv;
if (!priv->mark_begin || !priv->mark_end) {
g_warning("Cannot finish snippet as it has not been inserted.");
return;
}
buffer = gtk_text_mark_get_buffer(priv->mark_begin);
/*
* TODO: Remove all our GtkTextTag in the range.
*/
for (i = 0; i < priv->chunks->len; i++) {
chunk = g_ptr_array_index(priv->chunks, i);
gb_source_view_snippet_chunk_finish(chunk);
}
gtk_text_buffer_delete_mark(buffer, priv->mark_begin);
gtk_text_buffer_delete_mark(buffer, priv->mark_end);
g_clear_object(&priv->mark_begin);
g_clear_object(&priv->mark_end);
g_object_notify_by_pspec(G_OBJECT(snippet), gParamSpecs[PROP_MARK_BEGIN]);
g_object_notify_by_pspec(G_OBJECT(snippet), gParamSpecs[PROP_MARK_END]);
}
/**
* clutter_actor_meta_set_enabled:
* @meta: a #ClutterActorMeta
* @is_enabled: whether @meta is enabled
*
* Sets whether @meta should be enabled or not
*
* Since: 1.4
*/
void
clutter_actor_meta_set_enabled (ClutterActorMeta *meta,
gboolean is_enabled)
{
g_return_if_fail (CLUTTER_IS_ACTOR_META (meta));
is_enabled = !!is_enabled;
if (meta->priv->is_enabled == is_enabled)
return;
meta->priv->is_enabled = is_enabled;
g_object_notify_by_pspec (G_OBJECT (meta), obj_props[PROP_ENABLED]);
}
/**
* clutter_canvas_set_scale_factor:
* @canvas: a #ClutterCanvas
* @scale: the scale factor, or -1 for the default
*
* Sets the scaling factor for the Cairo surface used by @canvas.
*
* This function should rarely be used.
*
* The default scaling factor of a #ClutterCanvas content uses the
* #ClutterSettings:window-scaling-factor property, which is set by
* the windowing system. By using this function it is possible to
* override that setting.
*
* Changing the scale factor will invalidate the @canvas.
*
* Since: 1.18
*/
void
clutter_canvas_set_scale_factor (ClutterCanvas *canvas,
int scale)
{
ClutterCanvasPrivate *priv;
GObject *obj;
g_return_if_fail (CLUTTER_IS_CANVAS (canvas));
g_return_if_fail (scale != 0);
priv = canvas->priv;
if (scale < 0)
{
if (!priv->scale_factor_set)
return;
priv->scale_factor_set = FALSE;
priv->scale_factor = -1;
}
else
{
if (priv->scale_factor_set && priv->scale_factor == scale)
return;
priv->scale_factor_set = TRUE;
priv->scale_factor = scale;
}
clutter_content_invalidate (CLUTTER_CONTENT (canvas));
obj = G_OBJECT (canvas);
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_FACTOR]);
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_FACTOR_SET]);
}
void
pnl_dock_revealer_set_reveal_child (PnlDockRevealer *self,
gboolean reveal_child)
{
PnlDockRevealerPrivate *priv = pnl_dock_revealer_get_instance_private (self);
g_return_if_fail (PNL_IS_DOCK_REVEALER (self));
reveal_child = !!reveal_child;
if (reveal_child != priv->reveal_child)
{
PnlAnimation *animation;
GtkWidget *child;
priv->reveal_child = reveal_child;
child = gtk_bin_get_child (GTK_BIN (self));
if (child != NULL)
{
guint duration;
if (priv->animation != NULL)
{
pnl_animation_stop (priv->animation);
pnl_clear_weak_pointer (&priv->animation);
}
gtk_widget_set_child_visible (child, TRUE);
duration = pnl_dock_revealer_calculate_duration (self);
animation = pnl_object_animate_full (priv->adjustment,
PNL_ANIMATION_EASE_IN_OUT_CUBIC,
duration,
gtk_widget_get_frame_clock (GTK_WIDGET (self)),
pnl_dock_revealer_animation_done,
g_object_ref (self),
"value", reveal_child ? 1.0 : 0.0,
NULL);
pnl_set_weak_pointer (&priv->animation, animation);
}
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_REVEAL_CHILD]);
}
}
/**
* clutter_bind_constraint_set_offset:
* @constraint: a #ClutterBindConstraint
* @offset: the offset to apply, in pixels
*
* Sets the offset to be applied to the constraint
*
* Since: 1.4
*/
void
clutter_bind_constraint_set_offset (ClutterBindConstraint *constraint,
gfloat offset)
{
g_return_if_fail (CLUTTER_IS_BIND_CONSTRAINT (constraint));
if (fabs (constraint->offset - offset) < 0.00001f)
return;
constraint->offset = offset;
if (constraint->actor != NULL)
clutter_actor_queue_relayout (constraint->actor);
g_object_notify_by_pspec (G_OBJECT (constraint), obj_props[PROP_OFFSET]);
}
/**
* clutter_bind_constraint_set_coordinate:
* @constraint: a #ClutterBindConstraint
* @coordinate: the coordinate to bind
*
* Sets the coordinate to bind in the constraint
*
* Since: 1.4
*/
void
clutter_bind_constraint_set_coordinate (ClutterBindConstraint *constraint,
ClutterBindCoordinate coordinate)
{
g_return_if_fail (CLUTTER_IS_BIND_CONSTRAINT (constraint));
if (constraint->coordinate == coordinate)
return;
constraint->coordinate = coordinate;
if (constraint->actor != NULL)
clutter_actor_queue_relayout (constraint->actor);
g_object_notify_by_pspec (G_OBJECT (constraint), obj_props[PROP_COORDINATE]);
}