CreditSection *cs = data;
g_free (cs->heading);
g_strfreev (cs->people);
- g_slice_free (CreditSection, data);
+ g_free (data);
}
static void
g_return_if_fail (section_name != NULL);
g_return_if_fail (people != NULL);
- new_entry = g_slice_new (CreditSection);
+ new_entry = g_new (CreditSection, 1);
new_entry->heading = g_strdup ((char *)section_name);
new_entry->people = g_strdupv ((char **)people);
if (action == NULL)
{
- action = g_slice_new (Action);
+ action = g_new (Action, 1);
action->muxer = muxer;
action->fullname = g_strdup (name);
action->watchers = NULL;
g_object_unref (group->group);
g_free (group->prefix);
- g_slice_free (Group, group);
+ g_free (group);
}
static void
g_slist_free (action->watchers);
g_free (action->fullname);
- g_slice_free (Action, action);
+ g_free (action);
}
static void
if (!muxer->groups)
muxer->groups = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, gtk_action_muxer_free_group);
- group = g_slice_new0 (Group);
+ group = g_new0 (Group, 1);
group->muxer = muxer;
group->group = g_object_ref (action_group);
group->prefix = g_strdup (prefix);
{
g_free (inhibitor->reason);
g_clear_object (&inhibitor->window);
- g_slice_free (GtkApplicationQuartzInhibitor, inhibitor);
+ g_free (inhibitor);
}
typedef GtkApplicationImplClass GtkApplicationImplQuartzClass;
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) impl;
GtkApplicationQuartzInhibitor *inhibitor;
- inhibitor = g_slice_new (GtkApplicationQuartzInhibitor);
+ inhibitor = g_new (GtkApplicationQuartzInhibitor, 1);
inhibitor->cookie = ++quartz->next_cookie;
inhibitor->flags = flags;
inhibitor->reason = g_strdup (reason);
static void
gtk_application_wayland_inhibitor_free (GtkApplicationWaylandInhibitor *inhibitor)
{
- g_slice_free (GtkApplicationWaylandInhibitor, inhibitor);
+ g_free (inhibitor);
}
typedef struct
if (!flags)
return 0;
- inhibitor = g_slice_new0 (GtkApplicationWaylandInhibitor);
+ inhibitor = g_new0 (GtkApplicationWaylandInhibitor, 1);
inhibitor->cookie = ++wayland->next_cookie;
inhibitor->flags = flags;
wayland->inhibitors = g_slist_prepend (wayland->inhibitors, inhibitor);
return;
ra_clear (&self->roaring.high_low_container);
- g_slice_free (GtkBitset, self);
+ g_free (self);
}
/**
{
GtkBitset *self;
- self = g_slice_new0 (GtkBitset);
+ self = g_new0 (GtkBitset, 1);
self->ref_count = 1;
g_object_unref (bookmark->file);
g_free (bookmark->label);
- g_slice_free (GtkBookmark, bookmark);
+ g_free (bookmark);
}
static void
if (!g_utf8_validate (lines[i], -1, NULL))
continue;
- bookmark = g_slice_new0 (GtkBookmark);
+ bookmark = g_new0 (GtkBookmark, 1);
if ((space = strchr (lines[i], ' ')) != NULL)
{
return FALSE;
}
- bookmark = g_slice_new0 (GtkBookmark);
+ bookmark = g_new0 (GtkBookmark, 1);
bookmark->file = g_object_ref (file);
manager->bookmarks = g_slist_insert (manager->bookmarks, bookmark, position);
GtkBorder *
gtk_border_new (void)
{
- return g_slice_new0 (GtkBorder);
+ return g_new0 (GtkBorder, 1);
}
/**
GtkBorder *
gtk_border_copy (const GtkBorder *border_)
{
+ GtkBorder *copy;
+
g_return_val_if_fail (border_ != NULL, NULL);
- return g_slice_dup (GtkBorder, border_);
+ copy = g_new0 (GtkBorder, 1);
+ memcpy (copy, border_, sizeof (GtkBorder));
+ return copy;
}
/**
void
gtk_border_free (GtkBorder *border_)
{
- g_slice_free (GtkBorder, border_);
+ g_free (border_);
}
G_DEFINE_BOXED_TYPE (GtkBorder, gtk_border,
{
struct frame *new;
- new = g_slice_new (struct frame);
+ new = g_new (struct frame, 1);
*new = state->frame;
state->frame.menu = menu;
state->frame = *prev;
- g_slice_free (struct frame, prev);
+ g_free (prev);
}
static void
state->frame = *prev;
- g_slice_free (struct frame, prev);
+ g_free (prev);
}
if (state->string)
g_free (state->attribute);
g_free (state->context);
- g_slice_free (GtkBuilderMenuState, state);
+ g_free (state);
}
static GtkBuildableParser gtk_builder_menu_subparser =
GtkBuilderMenuState *state;
char *id;
- state = g_slice_new0 (GtkBuilderMenuState);
+ state = g_new0 (GtkBuilderMenuState, 1);
state->parser_data = parser_data;
gtk_buildable_parse_context_push (&parser_data->ctx, >k_builder_menu_subparser, state);
g_assert (state->frame.prev == NULL);
g_assert (state->frame.item == NULL);
g_assert (state->frame.menu == NULL);
- g_slice_free (GtkBuilderMenuState, state);
+ g_free (state);
}
prop->applied = TRUE;
- property = g_slice_new (DelayedProperty);
+ property = g_new (DelayedProperty, 1);
property->pspec = prop->pspec;
property->object = g_strdup (object_name);
property->value = g_strdup (prop->text->str);
g_free (property->value);
g_free (property->object);
- g_slice_free (DelayedProperty, property);
+ g_free (property);
}
g_slist_free (props);
version_minor = g_ascii_strtoll (split[1], NULL, 10);
g_strfreev (split);
- req_info = g_slice_new0 (RequiresInfo);
+ req_info = g_new0 (RequiresInfo, 1);
req_info->library = g_strdup (library);
req_info->major = version_major;
req_info->minor = version_minor;
}
}
- object_info = g_slice_new0 (ObjectInfo);
+ object_info = g_new0 (ObjectInfo, 1);
object_info->tag_type = TAG_OBJECT;
object_info->type = object_type;
object_info->oclass = g_type_class_ref (object_type);
++data->cur_object_level;
- object_info = g_slice_new0 (ObjectInfo);
+ object_info = g_new0 (ObjectInfo, 1);
object_info->tag_type = TAG_TEMPLATE;
object_info->type = parsed_type;
object_info->oclass = g_type_class_ref (parsed_type);
g_ptr_array_free (info->properties, TRUE);
g_free (info->constructor);
g_free (info->id);
- g_slice_free (ObjectInfo, info);
+ g_free (info);
}
static void
return;
}
- child_info = g_slice_new0 (ChildInfo);
+ child_info = g_new0 (ChildInfo, 1);
child_info->tag_type = TAG_CHILD;
child_info->type = g_strdup (type);
child_info->internal_child = g_strdup (internal_child);
{
g_free (info->type);
g_free (info->internal_child);
- g_slice_free (ChildInfo, info);
+ g_free (info);
}
static void
{
BindingInfo *binfo;
- binfo = g_slice_new0 (BindingInfo);
+ binfo = g_new0 (BindingInfo, 1);
binfo->tag_type = TAG_BINDING;
binfo->target = NULL;
binfo->target_pspec = pspec;
return;
}
- info = g_slice_new0 (PropertyInfo);
+ info = g_new0 (PropertyInfo, 1);
info->tag_type = TAG_PROPERTY;
info->pspec = pspec;
info->text = g_string_new ("");
}
- info = g_slice_new0 (BindingExpressionInfo);
+ info = g_new0 (BindingExpressionInfo, 1);
info->tag_type = TAG_BINDING_EXPRESSION;
info->target = NULL;
info->target_pspec = pspec;
}
g_string_free (info->text, TRUE);
g_free (info->context);
- g_slice_free (PropertyInfo, info);
+ g_free (info);
}
static void
g_assert_not_reached ();
break;
}
- g_slice_free (ExpressionInfo, info);
+ g_free (info);
}
static gboolean
}
}
- info = g_slice_new0 (ExpressionInfo);
+ info = g_new0 (ExpressionInfo, 1);
info->tag_type = TAG_EXPRESSION;
info->expression_type = EXPRESSION_CONSTANT;
info->constant.type = type;
swapped = FALSE;
}
- info = g_slice_new0 (ExpressionInfo);
+ info = g_new0 (ExpressionInfo, 1);
info->tag_type = TAG_EXPRESSION;
info->expression_type = EXPRESSION_CLOSURE;
info->closure.type = type;
}
}
- info = g_slice_new0 (ExpressionInfo);
+ info = g_new0 (ExpressionInfo, 1);
info->tag_type = TAG_EXPRESSION;
info->expression_type = EXPRESSION_PROPERTY;
info->property.this_type = type;
swapped = FALSE;
}
- info = g_slice_new0 (SignalInfo);
+ info = g_new0 (SignalInfo, 1);
info->id = id;
info->detail = detail;
info->handler = g_strdup (handler);
g_free (info->handler);
g_free (info->connect_object_name);
g_free (info->object_name);
- g_slice_free (SignalInfo, info);
+ g_free (info);
}
void
{
g_free (info->source);
g_free (info->source_property);
- g_slice_free (BindingInfo, info);
+ g_free (info);
}
void
if (info->expr)
free_expression_info (info->expr);
g_free (info->object_name);
- g_slice_free (BindingExpressionInfo, info);
+ g_free (info);
}
static void
gpointer user_data)
{
g_free (info->library);
- g_slice_free (RequiresInfo, info);
+ g_free (info);
}
static void
{
SubParser *subparser;
- subparser = g_slice_new0 (SubParser);
+ subparser = g_new0 (SubParser, 1);
subparser->object = object;
subparser->child = child;
subparser->tagname = g_strdup (element_name);
free_subparser (SubParser *subparser)
{
g_free (subparser->tagname);
- g_slice_free (SubParser, subparser);
+ g_free (subparser);
}
static gboolean
text_len--;
if (expr_info->property.expression == NULL && text_len > 0)
{
- ExpressionInfo *constant = g_slice_new0 (ExpressionInfo);
+ ExpressionInfo *constant = g_new0 (ExpressionInfo, 1);
constant->tag_type = TAG_EXPRESSION;
constant->expression_type = EXPRESSION_CONSTANT;
constant->constant.type = G_TYPE_INVALID;
/* All strings are owned by the string chunk */
typedef struct {
- /* Must be first for g_slice_free_chain() */
GList link;
const char *string;
RecordDataType type,
gsize size)
{
- RecordDataNode *node = g_slice_alloc0 (size);
+ RecordDataNode *node = g_malloc0 (size);
node->type = type;
node->link.data = node;
l = next;
}
- g_slice_free1 (sizeof (RecordDataElement) +
- sizeof (RecordDataString) * element->n_attributes, element);
+ g_free (element);
break;
case RECORD_TYPE_TEXT:
text = (RecordDataText *)node;
- g_slice_free (RecordDataText, text);
+ g_free (text);
break;
case RECORD_TYPE_END_ELEMENT:
default:
return s;
}
- s = g_slice_new (RecordDataString);
+ s = g_new (RecordDataString, 1);
/* The string is zero terminated */
s->string = g_string_chunk_insert_len (data->chunks, str, len);
s->len = len;
GList *l;
GString *marshaled;
int offset;
+ RecordDataString *node;
data.strings = g_hash_table_new (record_data_string_hash, record_data_string_equal);
data.chunks = g_string_chunk_new (512);
marshal_root (marshaled, &data.root->base);
- g_slice_free_chain (RecordDataString,
- (RecordDataString *)data.string_list.head,
- link.next);
+ node = (RecordDataString *) data.string_list.head;
+ while (node)
+ {
+ RecordDataString *next = (RecordDataString *) node->link.next;
+ g_free (node);
+ node = next;
+ }
+
record_data_node_free (&data.root->base);
g_string_chunk_free (data.chunks);
g_hash_table_destroy (data.strings);
view->prev_view = NULL;
view->next_view = NULL;
- g_slice_free (VflView, view);
+ g_free (view);
}
static void
{
if (parser->views == NULL && parser->leading_super == NULL)
{
- parser->leading_super = g_slice_new0 (VflView);
+ parser->leading_super = g_new0 (VflView, 1);
parser->leading_super->name = g_strdup ("super");
parser->leading_super->orientation = parser->orientation;
}
else if (parser->trailing_super == NULL)
{
- parser->trailing_super = g_slice_new0 (VflView);
+ parser->trailing_super = g_new0 (VflView, 1);
parser->trailing_super->name = g_strdup ("super");
parser->trailing_super->orientation = parser->orientation;
if (*cur == '[')
{
- VflView *view = g_slice_new0 (VflView);
+ VflView *view = g_new0 (VflView, 1);
char *tmp;
view->orientation = parser->orientation;
_gtk_css_keyframes_unref (self->keyframes);
_gtk_css_value_unref (self->ease);
- g_slice_free (GtkCssAnimation, self);
+ g_free (self);
}
static const GtkStyleAnimationClass GTK_CSS_ANIMATION_CLASS = {
g_return_val_if_fail (ease != NULL, NULL);
g_return_val_if_fail (iteration_count >= 0, NULL);
- animation = g_slice_alloc (sizeof (GtkCssAnimation));
+ animation = g_new (GtkCssAnimation, 1);
animation->parent.class = >K_CSS_ANIMATION_CLASS;
animation->parent.ref_count = 1;
gint64 timestamp,
GtkCssPlayState play_state)
{
- GtkCssAnimation *animation = g_slice_alloc (sizeof (GtkCssAnimation));
+ GtkCssAnimation *animation = g_new (GtkCssAnimation, 1);
animation->parent.class = >K_CSS_ANIMATION_CLASS;
animation->parent.ref_count = 1;
guint i;
for (i = 0; i < value->n_values; i++)
- {
- _gtk_css_value_unref (value->values[i]);
- }
+ _gtk_css_value_unref (value->values[i]);
- g_slice_free1 (sizeof (GtkCssValue) + sizeof (GtkCssValue *) * (value->n_values - 1), value);
+ g_free (value);
}
static GtkCssValue *
if (value->y)
_gtk_css_value_unref (value->y);
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
_gtk_css_value_unref (value->values[i]);
}
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
break;
}
- g_slice_free (GtkCssValue, color);
+ g_free (color);
}
static GtkCssValue *
_gtk_css_value_unref (value->x);
_gtk_css_value_unref (value->y);
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
static void
gtk_css_dynamic_free (GtkStyleAnimation *animation)
{
- g_slice_free (GtkCssDynamic, (GtkCssDynamic *)animation);
+ g_free (animation);
}
static const GtkStyleAnimationClass GTK_CSS_DYNAMIC_CLASS = {
GtkStyleAnimation *
gtk_css_dynamic_new (gint64 timestamp)
{
- GtkCssDynamic *dynamic = g_slice_alloc (sizeof (GtkCssDynamic));
+ GtkCssDynamic *dynamic = g_new (GtkCssDynamic, 1);
dynamic->parent.class = >K_CSS_DYNAMIC_CLASS;
dynamic->parent.ref_count = 1;
static void
gtk_css_value_ease_free (GtkCssValue *value)
{
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
static void
gtk_css_value_enum_free (GtkCssValue *value)
{
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
guint i;
for (i = 0; i < value->n_filters; i++)
- {
- gtk_css_filter_clear (&value->filters[i]);
- }
+ gtk_css_filter_clear (&value->filters[i]);
- g_slice_free1 (sizeof (GtkCssValue) + sizeof (GtkCssFilter) * (value->n_filters - 1), value);
+ g_free (value);
}
/* returns TRUE if dest == src */
{
g_hash_table_unref (value->features);
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
{
g_hash_table_unref (value->axes);
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
gtk_css_value_image_free (GtkCssValue *value)
{
g_object_unref (value->image);
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
}
g_free (keyframes->values);
- g_slice_free (GtkCssKeyframes, keyframes);
+ g_free (keyframes);
}
static guint
{
GtkCssKeyframes *keyframes;
- keyframes = g_slice_new0 (GtkCssKeyframes);
+ keyframes = g_new0 (GtkCssKeyframes, 1);
keyframes->ref_count = 1;
return keyframes;
gtk_css_value_line_height_free (GtkCssValue *value)
{
_gtk_css_value_unref (value->height);
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
{
GtkCssNodeStyleCache *result;
- result = g_slice_new0 (GtkCssNodeStyleCache);
+ result = g_new0 (GtkCssNodeStyleCache, 1);
result->ref_count = 1;
result->style = g_object_ref (style);
if (cache->children)
g_hash_table_unref (cache->children);
- g_slice_free (GtkCssNodeStyleCache, cache);
+ g_free (cache);
}
GtkCssStyle *
for (guint i = 0; i < n_terms; i++)
_gtk_css_value_unref (number->calc.terms[i]);
-
- g_slice_free1 (gtk_css_value_calc_get_size (n_terms), number);
- }
- else
- {
- g_slice_free (GtkCssValue, number);
}
+
+ g_free (number);
}
static double
g_free (value->color_names);
g_free (value->color_values);
-
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
{
_gtk_css_value_unref (value->x);
_gtk_css_value_unref (value->y);
-
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
g_object_unref (scanner->provider);
gtk_css_parser_unref (scanner->parser);
- g_slice_free (GtkCssScanner, scanner);
+ g_free (scanner);
}
static void
{
GtkCssScanner *scanner;
- scanner = g_slice_new0 (GtkCssScanner);
+ scanner = g_new0 (GtkCssScanner, 1);
g_object_ref (provider);
scanner->provider = provider;
static void
gtk_css_value_repeat_free (GtkCssValue *value)
{
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
shadow_value_unref (shadow);
}
- g_slice_free1 (sizeof (GtkCssValue) + sizeof (ShadowValue) * (value->n_shadows - 1), value);
+ g_free (value);
}
static GtkCssValue *
gtk_css_value_string_free (GtkCssValue *value)
{
g_free (value->string);
- g_slice_free (GtkCssValue, value);
+ g_free (value);
}
static GtkCssValue *
guint i;
for (i = 0; i < value->n_transforms; i++)
- {
- gtk_css_transform_clear (&value->transforms[i]);
- }
+ gtk_css_transform_clear (&value->transforms[i]);
- g_slice_free1 (sizeof (GtkCssValue) + sizeof (GtkCssTransform) * (value->n_transforms - 1), value);
+ g_free (value);
}
/* returns TRUE if dest == src */
gtk_css_value_unref (self->start);
gtk_css_value_unref (self->ease);
-
- g_slice_free (GtkCssTransition, self);
+ g_free (self);
}
static const GtkStyleAnimationClass GTK_CSS_TRANSITION_CLASS = {
GtkCssTransition *source = (GtkCssTransition *)style_animation;
GtkCssTransition *transition;
- transition = g_slice_alloc (sizeof (GtkCssTransition));
+ transition = g_new (GtkCssTransition, 1);
transition->parent.class = >K_CSS_TRANSITION_CLASS;
transition->parent.ref_count = 1;
g_return_val_if_fail (start != NULL, NULL);
g_return_val_if_fail (ease != NULL, NULL);
- transition = g_slice_alloc (sizeof (GtkCssTransition));
+ transition = g_new (GtkCssTransition, 1);
transition->parent.class = >K_CSS_TRANSITION_CLASS;
transition->parent.ref_count = 1;
{
GtkCssValue *value;
- value = g_slice_alloc0 (size);
+ value = g_malloc0 (size);
value->class = klass;
value->ref_count = 1;
{
GtkDrop *self = data;
- g_slice_free (GtkDrop, self);
+ g_free (self);
}
static GtkDrop *
result = g_object_get_qdata (G_OBJECT (drop), drop_quark);
if (result == NULL)
{
- result = g_slice_new0 (GtkDrop);
+ result = g_new0 (GtkDrop, 1);
g_object_set_qdata_full (G_OBJECT (drop), drop_quark, result, gtk_drop_free);
}
{
GtkPangoAttributeParserData *parser_data;
- parser_data = g_slice_new0 (GtkPangoAttributeParserData);
+ parser_data = g_new0 (GtkPangoAttributeParserData, 1);
parser_data->builder = g_object_ref (builder);
parser_data->object = (GObject *) g_object_ref (buildable);
*parser = pango_parser;
g_object_unref (data->object);
g_object_unref (data->builder);
- g_slice_free (GtkPangoAttributeParserData, data);
+ g_free (data);
}
}
gtk_widget_unparent (icon_info->widget);
- g_slice_free (EntryIconInfo, icon_info);
+ g_free (icon_info);
}
g_clear_pointer (&priv->progress_widget, gtk_widget_unparent);
g_return_val_if_fail (priv->icons[icon_pos] == NULL, NULL);
- icon_info = g_slice_new0 (EntryIconInfo);
+ icon_info = g_new0 (EntryIconInfo, 1);
priv->icons[icon_pos] = icon_info;
icon_info->widget = gtk_image_new ();
g_assert (bind->target == NULL);
if (bind->watch)
gtk_expression_watch_unwatch (bind->watch);
- g_slice_free (GtkExpressionBind, bind);
+ g_free (bind);
}
g_slist_free (data);
}
else
g_object_weak_unref (bind->target, invalidate_binds, NULL);
- g_slice_free (GtkExpressionBind, bind);
+ g_free (bind);
}
else
{
return NULL;
}
- bind = g_slice_new0 (GtkExpressionBind);
+ bind = g_new0 (GtkExpressionBind, 1);
binds = g_object_steal_data (target, "gtk-expression-binds");
if (binds == NULL)
g_object_weak_ref (target, invalidate_binds, NULL);
default:
break;
}
- g_slice_free (FilterRule, rule);
+ g_free (rule);
}
static void
if (strcmp (tagname, "mime-types") == 0)
{
- data = g_slice_new0 (SubParserData);
+ data = g_new0 (SubParserData, 1);
data->string = g_string_new ("");
data->type = PARSE_MIME_TYPES;
data->filter = GTK_FILE_FILTER (buildable);
}
else if (strcmp (tagname, "patterns") == 0)
{
- data = g_slice_new0 (SubParserData);
+ data = g_new0 (SubParserData, 1);
data->string = g_string_new ("");
data->type = PARSE_PATTERNS;
data->filter = GTK_FILE_FILTER (buildable);
}
else if (strcmp (tagname, "suffixes") == 0)
{
- data = g_slice_new0 (SubParserData);
+ data = g_new0 (SubParserData, 1);
data->string = g_string_new ("");
data->type = PARSE_SUFFIXES;
data->filter = GTK_FILE_FILTER (buildable);
SubParserData *data = (SubParserData*)user_data;
g_string_free (data->string, TRUE);
- g_slice_free (SubParserData, data);
+ g_free (data);
}
}
g_return_if_fail (GTK_IS_FILE_FILTER (filter));
g_return_if_fail (mime_type != NULL);
- rule = g_slice_new (FilterRule);
+ rule = g_new (FilterRule, 1);
rule->type = FILTER_RULE_MIME_TYPE;
rule->u.content_types = g_new0 (char *, 2);
rule->u.content_types[0] = g_content_type_from_mime_type (mime_type);
g_return_if_fail (GTK_IS_FILE_FILTER (filter));
g_return_if_fail (pattern != NULL);
- rule = g_slice_new (FilterRule);
+ rule = g_new (FilterRule, 1);
rule->type = FILTER_RULE_PATTERN;
rule->u.pattern = g_strdup (pattern);
g_return_if_fail (GTK_IS_FILE_FILTER (filter));
g_return_if_fail (suffix != NULL);
- rule = g_slice_new (FilterRule);
+ rule = g_new (FilterRule, 1);
rule->type = FILTER_RULE_SUFFIX;
rule->u.pattern = g_strconcat ("*.", suffix, NULL);
g_return_if_fail (GTK_IS_FILE_FILTER (filter));
- rule = g_slice_new (FilterRule);
+ rule = g_new (FilterRule, 1);
rule->type = FILTER_RULE_PIXBUF_FORMATS;
array = g_ptr_array_new ();
g_return_if_fail (G_IS_FILE (file));
g_return_if_fail (G_IS_FILE_INFO (info));
- node = g_slice_alloc0 (sizeof (FileModelNode));
+ node = g_new0 (FileModelNode, 1);
node->file = g_object_ref (file);
if (info)
{
node->frozen_add = model->frozen ? TRUE : FALSE;
g_array_append_vals (model->files, node, 1);
- g_slice_free1 (sizeof (FileModelNode), node);
+ g_free (node);
position = model->files->len - 1;
{
g_free (unthemed_icon->svg_filename);
g_free (unthemed_icon->no_svg_filename);
- g_slice_free (UnthemedIcon, unthemed_icon);
+ g_free (unthemed_icon);
}
static inline void
}
else
{
- unthemed_icon = g_slice_new0 (UnthemedIcon);
+ unthemed_icon = g_new0 (UnthemedIcon, 1);
unthemed_icon->is_resource = is_resource;
{
GtkKineticScrolling *data;
- data = g_slice_new0 (GtkKineticScrolling);
+ data = g_new0 (GtkKineticScrolling, 1);
data->lower = lower;
data->upper = upper;
data->decel_friction = decel_friction;
void
gtk_kinetic_scrolling_free (GtkKineticScrolling *kinetic)
{
- g_slice_free (GtkKineticScrolling, kinetic);
+ g_free (kinetic);
}
static void
{
GtkPangoAttributeParserData *parser_data;
- parser_data = g_slice_new0 (GtkPangoAttributeParserData);
+ parser_data = g_new0 (GtkPangoAttributeParserData, 1);
parser_data->builder = g_object_ref (builder);
parser_data->object = (GObject *) g_object_ref (buildable);
*parser = pango_parser;
g_object_unref (data->object);
g_object_unref (data->builder);
- g_slice_free (GtkPangoAttributeParserData, data);
+ g_free (data);
}
}
gtk_level_bar_offset_new (const char *name,
double value)
{
- GtkLevelBarOffset *offset = g_slice_new0 (GtkLevelBarOffset);
+ GtkLevelBarOffset *offset = g_new0 (GtkLevelBarOffset, 1);
offset->name = g_strdup (name);
offset->value = value;
gtk_level_bar_offset_free (GtkLevelBarOffset *offset)
{
g_free (offset->name);
- g_slice_free (GtkLevelBarOffset, offset);
+ g_free (offset);
}
static int
if (strcmp (tagname, "offsets") != 0)
return FALSE;
- data = g_slice_new0 (OffsetsParserData);
+ data = g_new0 (OffsetsParserData, 1);
data->self = GTK_LEVEL_BAR (buildable);
data->builder = builder;
data->offsets = NULL;
}
g_list_free_full (data->offsets, (GDestroyNotify) gtk_level_bar_offset_free);
- g_slice_free (OffsetsParserData, data);
+ g_free (data);
}
static void
g_return_val_if_fail (GTK_IS_LIST_ITEM_MANAGER (self), NULL);
- tracker = g_slice_new0 (GtkListItemTracker);
+ tracker = g_new0 (GtkListItemTracker, 1);
tracker->position = GTK_INVALID_LIST_POSITION;
self->trackers = g_slist_remove (self->trackers, tracker);
- g_slice_free (GtkListItemTracker, tracker);
+ g_free (tracker);
gtk_list_item_manager_ensure_items (self, NULL, G_MAXUINT);
{
GtkMenuTrackerSection *fake_section;
- fake_section = g_slice_new0 (GtkMenuTrackerSection);
+ fake_section = g_new0 (GtkMenuTrackerSection, 1);
fake_section->is_fake = TRUE;
fake_section->model = g_object_ref (item);
fake_section->handler = g_signal_connect (item, "notify::is-visible",
g_slist_free_full (section->items, (GDestroyNotify) gtk_menu_tracker_section_free);
g_free (section->action_namespace);
g_object_unref (section->model);
- g_slice_free (GtkMenuTrackerSection, section);
+ g_free (section);
}
static GtkMenuTrackerSection *
{
GtkMenuTrackerSection *section;
- section = g_slice_new0 (GtkMenuTrackerSection);
+ section = g_new0 (GtkMenuTrackerSection, 1);
section->model = g_object_ref (model);
section->with_separators = with_separators;
section->action_namespace = g_strdup (action_namespace);
{
GtkMenuTracker *tracker;
- tracker = g_slice_new (GtkMenuTracker);
+ tracker = g_new (GtkMenuTracker, 1);
tracker->merge_sections = merge_sections;
tracker->mac_os_mode = mac_os_mode;
tracker->observable = g_object_ref (observable);
{
gtk_menu_tracker_section_free (tracker->toplevel);
g_object_unref (tracker->observable);
- g_slice_free (GtkMenuTracker, tracker);
+ g_free (tracker);
}
for (i = 0; i < self->n_keys; i++)
gtk_sort_keys_unref (self->keys[i].keys);
- g_slice_free1 (sizeof (GtkMultiSortKeys) + self->n_keys * sizeof (GtkMultiSortKey), self);
+ g_free (self);
}
static int
GtkNumericSortKeys *self = (GtkNumericSortKeys *) keys;
gtk_expression_unref (self->expression);
- g_slice_free (GtkNumericSortKeys, self);
+ g_free (self);
}
#define COMPARE_FUNC(type, name, _a, _b) \
{
GtkPaperSize *size;
- size = g_slice_new0 (GtkPaperSize);
+ size = g_new0 (GtkPaperSize, 1);
size->info = info;
size->width = info->width;
size->height = info->height;
}
else
{
- size = g_slice_new0 (GtkPaperSize);
+ size = g_new0 (GtkPaperSize, 1);
size->width = width;
size->height = height;
else
{
g_warning ("Unknown paper size %s", name);
- size = g_slice_new0 (GtkPaperSize);
+ size = g_new0 (GtkPaperSize, 1);
size->name = g_strdup (name);
size->display_name = g_strdup (name);
/* Default to A4 size */
g_return_val_if_fail (name != NULL, NULL);
g_return_val_if_fail (unit != GTK_UNIT_NONE, NULL);
- size = g_slice_new0 (GtkPaperSize);
+ size = g_new0 (GtkPaperSize, 1);
size->name = g_strdup (name);
size->display_name = g_strdup (display_name);
{
GtkPaperSize *size;
- size = g_slice_new0 (GtkPaperSize);
+ size = g_new0 (GtkPaperSize, 1);
size->info = other->info;
if (other->name)
g_free (size->name);
g_free (size->display_name);
g_free (size->ppd_name);
-
- g_slice_free (GtkPaperSize, size);
+ g_free (size);
}
/**
out:
g_clear_object (&info);
g_clear_error (&error);
- g_slice_free (BookmarkQueryClosure, clos);
+ g_free (clos);
}
static gboolean
if (_gtk_bookmarks_manager_get_is_builtin (sidebar->bookmarks_manager, root))
continue;
- clos = g_slice_new (BookmarkQueryClosure);
+ clos = g_new (BookmarkQueryClosure, 1);
clos->sidebar = sidebar;
clos->index = index;
clos->is_native = is_native;
{
GtkRbNode *result;
- result = g_slice_alloc0 (gtk_rb_node_get_size (tree));
+ result = g_malloc0 (gtk_rb_node_get_size (tree));
result->red = TRUE;
result->dirty = TRUE;
if (tree->clear_augment_func)
tree->clear_augment_func (NODE_TO_AUG_POINTER (tree, node));
- g_slice_free1 (gtk_rb_node_get_size (tree), node);
+ g_free (node);
}
static void
{
GtkRbTree *tree;
- tree = g_slice_new0 (GtkRbTree);
+ tree = g_new0 (GtkRbTree, 1);
tree->ref_count = 1;
tree->element_size = element_size;
if (tree->root)
gtk_rb_node_free_deep (tree, tree->root);
-
- g_slice_free (GtkRbTree, tree);
+
+ g_free (tree);
}
gpointer
{
g_string_free (data->markup, TRUE);
g_free (data->context);
- g_slice_free (MarkData, data);
+ g_free (data);
}
static void
position = g_value_get_enum (&gvalue);
}
- mark = g_slice_new (MarkData);
+ mark = g_new (MarkData, 1);
mark->value = value;
if (position == GTK_POS_LEFT || position == GTK_POS_TOP)
mark->position = GTK_POS_TOP;
if (strcmp (tagname, "marks") == 0)
{
- data = g_slice_new0 (MarksSubparserData);
+ data = g_new0 (MarksSubparserData, 1);
data->scale = GTK_SCALE (buildable);
data->builder = builder;
data->marks = NULL;
}
g_slist_free (marks_data->marks);
- g_slice_free (MarksSubparserData, marks_data);
+ g_free (marks_data);
}
else
{
parent_buildable_iface->custom_finished (buildable, builder, child,
- tagname, user_data);
+ tagname, user_data);
}
}
g_clear_object (&hit->file);
g_clear_object (&hit->info);
- g_slice_free (GtkSearchHit, hit);
+ g_free (hit);
}
static GFileInfo *
break;
url = tracker_sparql_cursor_get_string (cursor, 0, NULL);
- hit = g_slice_new0 (GtkSearchHit);
+ hit = g_new0 (GtkSearchHit, 1);
hit->file = g_file_new_for_uri (url);
hit->info = create_file_info (hit->file, cursor);
hits = g_list_prepend (hits, hit);
g_value_unset (&qvalue->value);
g_free (qvalue->origin);
- g_slice_free (GtkSettingsValue, qvalue);
+ g_free (qvalue);
}
static void
qvalue = g_datalist_id_dup_data (&settings->queued_settings, name_quark, NULL, NULL);
if (!qvalue)
{
- qvalue = g_slice_new0 (GtkSettingsValue);
+ qvalue = g_new0 (GtkSettingsValue, 1);
g_datalist_id_set_data_full (&settings->queued_settings, name_quark, qvalue, free_value);
}
else
if (strcmp (tagname, "widgets") == 0)
{
- data = g_slice_new0 (GSListSubParserData);
+ data = g_new0 (GSListSubParserData, 1);
data->items = NULL;
data->object = G_OBJECT (buildable);
data->builder = builder;
gtk_size_group_add_widget (GTK_SIZE_GROUP (data->object), GTK_WIDGET (object));
}
g_slist_free_full (data->items, item_data_free);
- g_slice_free (GSListSubParserData, data);
+ g_free (data);
}
int i;
for (i = 0; i < GTK_SIZE_REQUEST_CACHED_SIZES && sizes[i] != NULL; i++)
- g_slice_free (SizeRequestX, sizes[i]);
+ g_free (sizes[i]);
- g_slice_free1 (sizeof (SizeRequestY *) * GTK_SIZE_REQUEST_CACHED_SIZES, sizes);
+ g_free (sizes);
}
static void
int i;
for (i = 0; i < GTK_SIZE_REQUEST_CACHED_SIZES && sizes[i] != NULL; i++)
- g_slice_free (SizeRequestY, sizes[i]);
+ g_free (sizes[i]);
- g_slice_free1 (sizeof (SizeRequestY *) * GTK_SIZE_REQUEST_CACHED_SIZES, sizes);
+ g_free (sizes);
}
void
}
if (cache->requests_x == NULL)
- cache->requests_x = g_slice_alloc0 (sizeof (SizeRequestX *) * GTK_SIZE_REQUEST_CACHED_SIZES);
+ cache->requests_x = g_new0 (SizeRequestX *, GTK_SIZE_REQUEST_CACHED_SIZES);
if (cache->requests_x[cache->flags[orientation].last_cached_request] == NULL)
- cache->requests_x[cache->flags[orientation].last_cached_request] = g_slice_new (SizeRequestX);
+ cache->requests_x[cache->flags[orientation].last_cached_request] = g_new (SizeRequestX, 1);
cached_size = cache->requests_x[cache->flags[orientation].last_cached_request];
cached_size->lower_for_size = for_size;
}
if (cache->requests_y == NULL)
- cache->requests_y = g_slice_alloc0 (sizeof (SizeRequestY *) * GTK_SIZE_REQUEST_CACHED_SIZES);
+ cache->requests_y = g_new0 (SizeRequestY *, GTK_SIZE_REQUEST_CACHED_SIZES);
if (cache->requests_y[cache->flags[orientation].last_cached_request] == NULL)
- cache->requests_y[cache->flags[orientation].last_cached_request] = g_slice_new (SizeRequestY);
+ cache->requests_y[cache->flags[orientation].last_cached_request] = g_new (SizeRequestY, 1);
cached_size = cache->requests_y[cache->flags[orientation].last_cached_request];
cached_size->lower_for_size = for_size;
g_object_unref (self->sorter);
- g_slice_free (GtkDefaultSortKeys, self);
+ g_free (self);
}
static gboolean
g_return_val_if_fail (key_align > 0, NULL);
- self = g_slice_alloc0 (size);
+ self = g_malloc0 (size);
self->klass = klass;
self->ref_count = 1;
static void
gtk_equal_sort_keys_free (GtkSortKeys *keys)
{
- g_slice_free (GtkSortKeys, keys);
+ g_free (keys);
}
static int
{
ItemParserData *data;
- data = g_slice_new0 (ItemParserData);
+ data = g_new0 (ItemParserData, 1);
data->builder = g_object_ref (builder);
data->list = g_object_ref (GTK_STRING_LIST (buildable));
data->domain = gtk_builder_get_translation_domain (builder);
g_object_unref (data->list);
g_object_unref (data->builder);
g_string_free (data->string, TRUE);
- g_slice_free (ItemParserData, data);
+ g_free (data);
}
}
GtkStringSortKeys *self = (GtkStringSortKeys *) keys;
gtk_expression_unref (self->expression);
- g_slice_free (GtkStringSortKeys, self);
+ g_free (self);
}
static int
if (password_hint->source_id)
g_source_remove (password_hint->source_id);
- g_slice_free (GtkTextPasswordHint, password_hint);
+ g_free (password_hint);
}
quark_password_hint);
if (!password_hint)
{
- password_hint = g_slice_new0 (GtkTextPasswordHint);
+ password_hint = g_new0 (GtkTextPasswordHint, 1);
g_object_set_qdata_full (G_OBJECT (self), quark_password_hint, password_hint,
(GDestroyNotify)gtk_text_password_hint_free);
}
{
GtkTextAttributes *values;
- values = g_slice_new0 (GtkTextAttributes);
+ values = g_new0 (GtkTextAttributes, 1);
/* 0 is a valid value for most of the struct */
values->refcount = 1;
if (values->font_features)
g_free (values->font_features);
- g_slice_free (GtkTextAttributes, values);
+ g_free (values);
}
}
/* Create the tree itself */
- tree = g_slice_new0 (GtkTextBTree);
+ tree = g_new0 (GtkTextBTree, 1);
tree->root_node = root_node;
tree->table = table;
tree->views = NULL;
g_object_unref (tree->selection_bound_mark);
tree->selection_bound_mark = NULL;
- g_slice_free (GtkTextBTree, tree);
+ g_free (tree);
}
}
g_return_if_fail (tree != NULL);
- view = g_slice_new (BTreeView);
+ view = g_new (BTreeView, 1);
view->view_id = layout;
view->layout = layout;
*/
last_line = get_last_line (tree);
- line_data = g_slice_new (GtkTextLineData);
+ line_data = g_new (GtkTextLineData, 1);
line_data->view_id = layout;
line_data->next = NULL;
line_data->width = 0;
*/
last_line = get_last_line (tree);
line_data = _gtk_text_line_remove_data (last_line, view_id);
- g_slice_free (GtkTextLineData, line_data);
+ g_free (line_data);
gtk_text_btree_node_remove_view (view, tree->root_node, view_id);
view->layout = (gpointer) 0xdeadbeef;
view->view_id = (gpointer) 0xdeadbeef;
- g_slice_free (BTreeView, view);
+ g_free (view);
}
void
iter_stack_new (void)
{
IterStack *stack;
- stack = g_slice_new (IterStack);
+ stack = g_new (IterStack, 1);
stack->iters = NULL;
stack->count = 0;
stack->allocated = 0;
iter_stack_free (IterStack *stack)
{
g_free (stack->iters);
- g_slice_free (IterStack, stack);
+ g_free (stack);
}
static void
{
GtkTextLineData *line_data;
- line_data = g_slice_new (GtkTextLineData);
+ line_data = g_new (GtkTextLineData, 1);
line_data->view_id = layout;
line_data->next = NULL;
static void
summary_list_destroy (Summary *summary)
{
- g_slice_free_chain (Summary, summary, next);
+ while (summary)
+ {
+ Summary *next = summary->next;
+ g_free (summary);
+ summary = next;
+ }
}
static GtkTextLine*
{
GtkTextLine *line;
- line = g_slice_new0 (GtkTextLine);
+ line = g_new0 (GtkTextLine, 1);
line->dir_strong = PANGO_DIRECTION_NEUTRAL;
line->dir_propagated_forward = PANGO_DIRECTION_NEUTRAL;
line->dir_propagated_back = PANGO_DIRECTION_NEUTRAL;
ld = next;
}
- g_slice_free (GtkTextLine, line);
+ g_free (line);
}
static void
{
NodeData *nd;
- nd = g_slice_new (NodeData);
+ nd = g_new (NodeData, 1);
nd->view_id = view_id;
nd->next = next;
static inline void
node_data_destroy (NodeData *nd)
{
- g_slice_free (NodeData, nd);
+ g_free (nd);
}
static inline void
node_data_list_destroy (NodeData *nd)
{
- g_slice_free_chain (NodeData, nd, next);
+ while (nd)
+ {
+ NodeData *next = nd->next;
+ g_free (nd);
+ nd = next;
+ }
}
static inline NodeData*
summary->info = (void*)0x1;
summary->toggle_count = 567;
summary->next = (void*)0x1;
- g_slice_free (Summary, summary);
+ g_free (summary);
}
static GtkTextBTreeNode*
{
GtkTextBTreeNode *node;
- node = g_slice_new (GtkTextBTreeNode);
+ node = g_new (GtkTextBTreeNode, 1);
node->node_data = NULL;
{
/* didn't find a summary for our tag. */
g_return_if_fail (adjust > 0);
- summary = g_slice_new (Summary);
+ summary = g_new (Summary, 1);
summary->info = info;
summary->toggle_count = adjust;
summary->next = node->summary;
summary_list_destroy (node->summary);
node_data_list_destroy (node->node_data);
- g_slice_free (GtkTextBTreeNode, node);
+ g_free (node);
}
static NodeData*
{
/* didn't find it, create. */
- info = g_slice_new (GtkTextTagInfo);
+ info = g_new (GtkTextTagInfo, 1);
info->tag = tag;
g_object_ref (tag);
g_object_unref (info->tag);
- g_slice_free (GtkTextTagInfo, info);
+ g_free (info);
return;
}
*/
GtkTextBTreeNode *rootnode = info->tag_root;
- summary = g_slice_new (Summary);
+ summary = g_new (Summary, 1);
summary->info = info;
summary->toggle_count = info->toggle_count - delta;
summary->next = rootnode->summary;
rootLevel = rootnode->level;
info->tag_root = rootnode;
}
- summary = g_slice_new (Summary);
+ summary = g_new (Summary, 1);
summary->info = info;
summary->toggle_count = delta;
summary->next = node->summary;
{
Range *r;
- r = g_slice_new (Range);
+ r = g_new (Range, 1);
r->buffer = gtk_text_iter_get_buffer (range_start);
g_object_ref (r->buffer);
*r->range_end = *r->whole_end;
g_object_unref (r->buffer);
- g_slice_free (Range, r);
+ g_free (r);
}
static void
free_clipboard_request (ClipboardRequest *request_data)
{
g_object_unref (request_data->buffer);
- g_slice_free (ClipboardRequest, request_data);
+ g_free (request_data);
}
#if 0
}
else
{
- selection_clipboard = g_slice_new (SelectionClipboard);
+ selection_clipboard = g_new (SelectionClipboard, 1);
selection_clipboard->clipboard = clipboard;
selection_clipboard->ref_count = 1;
buffer->priv->selection_clipboards = g_slist_remove (buffer->priv->selection_clipboards,
selection_clipboard);
- g_slice_free (SelectionClipboard, selection_clipboard);
+ g_free (selection_clipboard);
}
}
for (l = priv->selection_clipboards; l != NULL; l = l->next)
{
SelectionClipboard *selection_clipboard = l->data;
- g_slice_free (SelectionClipboard, selection_clipboard);
+ g_free (selection_clipboard);
}
g_slist_free (priv->selection_clipboards);
GtkTextIter *override_location,
gboolean default_editable)
{
- ClipboardRequest *data = g_slice_new (ClipboardRequest);
+ ClipboardRequest *data = g_new (ClipboardRequest, 1);
GtkTextIter paste_point;
GtkTextIter start, end;
for (i = 0; i < ATTR_CACHE_SIZE; i++)
g_free (cache->entries[i].attrs);
- g_slice_free (GtkTextLogAttrCache, cache);
+ g_free (cache);
}
static void
if (priv->log_attr_cache == NULL)
{
- priv->log_attr_cache = g_slice_new0 (GtkTextLogAttrCache);
+ priv->log_attr_cache = g_new0 (GtkTextLogAttrCache, 1);
priv->log_attr_cache->chars_changed_stamp =
_gtk_text_btree_get_chars_changed_stamp (get_btree (buffer));
}
g_object_unref (paintable);
}
- g_slice_free1 (PAINTABLE_SEG_SIZE, seg);
+ g_free (seg);
return 0;
}
GtkTextLineSegment *seg;
guint flags;
- seg = g_slice_alloc (PAINTABLE_SEG_SIZE);
+ seg = g_malloc (PAINTABLE_SEG_SIZE);
seg->type = >k_text_paintable_type;
GtkTextLineSegment *seg;
GtkTextChildAnchorPrivate *priv = gtk_text_child_anchor_get_instance_private (anchor);
- seg = g_slice_alloc (WIDGET_SEG_SIZE);
+ seg = g_malloc (WIDGET_SEG_SIZE);
seg->type = >k_text_child_type;
g_slist_free_full (seg->body.child.widgets, g_object_unref);
- g_slice_free1 (WIDGET_SEG_SIZE, seg);
+ g_free (seg);
}
g_free (priv->replacement);
{
Action *action;
- action = g_slice_new0 (Action);
+ action = g_new0 (Action, 1);
action->kind = kind;
action->link.data = action;
else if (action->kind == ACTION_KIND_GROUP)
clear_action_queue (&action->u.group.actions);
- g_slice_free (Action, action);
+ g_free (action);
}
static gboolean
g_return_val_if_fail (iter != NULL, NULL);
- new_iter = g_slice_new (GtkTextIter);
+ new_iter = g_new (GtkTextIter, 1);
*new_iter = *iter;
{
g_return_if_fail (iter != NULL);
- g_slice_free (GtkTextIter, iter);
+ g_free (iter);
}
/**
{
gtk_text_layout_invalidate_cache (layout, line, FALSE);
- g_slice_free (GtkTextLineData, line_data);
+ g_free (line_data);
}
/**
if (appearance_attr->appearance.strikethrough_rgba)
gdk_rgba_free (appearance_attr->appearance.strikethrough_rgba);
- g_slice_free (GtkTextAttrAppearance, appearance_attr);
+ g_free (appearance_attr);
}
static gboolean
klass.type = gtk_text_attr_appearance_type =
pango_attr_type_register (I_("GtkTextAttrAppearance"));
- result = g_slice_new (GtkTextAttrAppearance);
+ result = g_new (GtkTextAttrAppearance, 1);
result->attr.klass = &klass;
result->appearance = *appearance;
{
GtkTextLineDisplayCache *ret;
- ret = g_slice_new0 (GtkTextLineDisplayCache);
+ ret = g_new0 (GtkTextLineDisplayCache, 1);
ret->sorted_by_line = g_sequence_new ((GDestroyNotify)gtk_text_line_display_unref);
ret->line_to_display = g_hash_table_new (NULL, NULL);
ret->mru_size = DEFAULT_MRU_SIZE;
g_clear_pointer (&cache->evict_source, g_source_destroy);
g_clear_pointer (&cache->sorted_by_line, g_sequence_free);
g_clear_pointer (&cache->line_to_display, g_hash_table_unref);
- g_slice_free (GtkTextLineDisplayCache, cache);
+ g_free (cache);
}
static gboolean
"impending");
g_free (seg->body.mark.name);
- g_slice_free1 (MSEG_SIZE, seg);
+ g_free (seg);
mark->segment = NULL;
}
{
GtkTextLineSegment *mark;
- mark = g_slice_alloc0 (MSEG_SIZE);
+ mark = g_malloc0 (MSEG_SIZE);
mark->body.mark.name = NULL;
mark->type = >k_text_right_mark_type;
g_assert (gtk_text_byte_begins_utf8_char (text));
- seg = g_slice_alloc (CSEG_SIZE (len));
+ seg = g_malloc (CSEG_SIZE (len));
seg->type = (GtkTextLineSegmentClass *)>k_text_char_type;
seg->next = NULL;
seg->byte_count = len;
g_assert (gtk_text_byte_begins_utf8_char (text1));
g_assert (gtk_text_byte_begins_utf8_char (text2));
- seg = g_slice_alloc (CSEG_SIZE (len1+len2));
+ seg = g_malloc (CSEG_SIZE (len1+len2));
seg->type = >k_text_char_type;
seg->next = NULL;
seg->byte_count = len1 + len2;
g_assert (seg->type == >k_text_char_type);
- g_slice_free1 (CSEG_SIZE (seg->byte_count), seg);
+ g_free (seg);
}
/*
#pragma GCC diagnostic ignored "-Warray-bounds"
GtkTextLineSegment *seg;
- seg = g_slice_alloc (TSEG_SIZE);
+ seg = g_malloc (TSEG_SIZE);
seg->type = on ? >k_text_toggle_on_type : >k_text_toggle_off_type;
g_assert (seg->type == >k_text_toggle_on_type ||
seg->type == >k_text_toggle_off_type);
- g_slice_free1 (TSEG_SIZE, seg);
+ g_free (seg);
}
/*
gtk_text_buffer_delete_mark (gtk_text_mark_get_buffer (scroll->mark),
scroll->mark);
g_object_unref (scroll->mark);
- g_slice_free (GtkTextPendingScroll, scroll);
+ g_free (scroll);
}
static void
DV(g_print(G_STRLOC"\n"));
- scroll = g_slice_new (GtkTextPendingScroll);
+ scroll = g_new (GtkTextPendingScroll, 1);
scroll->within_margin = within_margin;
scroll->use_align = use_align;
g_object_unref (data->buffer);
- g_slice_free (SelectionData, data);
+ g_free (data);
}
static gboolean
SelectionData *data;
priv = text_view->priv;
- data = g_slice_new0 (SelectionData);
+ data = g_new0 (SelectionData, 1);
data->granularity = granularity;
buffer = get_buffer (text_view);
GtkTextWindow *win;
GtkCssNode *widget_node;
- win = g_slice_new (GtkTextWindow);
+ win = g_new (GtkTextWindow, 1);
win->type = GTK_TEXT_WINDOW_TEXT;
win->widget = widget;
{
gtk_css_node_set_parent (win->css_node, NULL);
- g_slice_free (GtkTextWindow, win);
+ g_free (win);
}
static void
{
AnchoredChild *vc;
- vc = g_slice_new0 (AnchoredChild);
+ vc = g_new0 (AnchoredChild, 1);
vc->link.data = vc;
vc->widget = g_object_ref (child);
vc->anchor = g_object_ref (anchor);
g_object_unref (child->anchor);
g_object_unref (child->widget);
- g_slice_free (AnchoredChild, child);
+ g_free (child);
}
static void
{
Overlay *overlay;
- overlay = g_slice_new0 (Overlay);
+ overlay = g_new0 (Overlay, 1);
overlay->link.data = overlay;
overlay->widget = g_object_ref (widget);
overlay->x = x;
g_assert (overlay->link.next == NULL);
g_object_unref (overlay->widget);
- g_slice_free (Overlay, overlay);
+ g_free (overlay);
}
static void
g_hash_table_unref (self->cached_keys);
if (self->sort_keys)
gtk_sort_keys_unref (self->sort_keys);
- g_slice_free (GtkTreeListRowSortKeys, self);
+ g_free (self);
}
static inline gboolean
if (child_class)
{
g_free (child_class->name);
- g_slice_free (AutomaticChildClass, child_class);
+ g_free (child_class);
}
}
g_object_unref (template_data->scope);
- g_slice_free (GtkWidgetTemplate, template_data);
+ g_free (template_data);
}
g_object_unref (klass->priv->shortcuts);
priv->tick_callbacks = g_list_delete_link (priv->tick_callbacks, link);
if (info->notify)
info->notify (info->user_data);
- g_slice_free (GtkTickCallbackInfo, info);
+ g_free (info);
}
if (priv->tick_callbacks == NULL && priv->clock_tick_id)
}
}
- info = g_slice_new0 (GtkTickCallbackInfo);
+ info = g_new0 (GtkTickCallbackInfo, 1);
info->refcount = 1;
info->id = ++tick_callback_id;
if (info->notify)
info->notify (info->user_data);
- g_slice_free (GtkSurfaceTransformChangedCallbackInfo, info);
+ g_free (info);
}
static void
g_list_free_full (surface_transform_data->callbacks,
(GDestroyNotify) surface_transform_changed_callback_info_destroy);
- g_slice_free (GtkWidgetSurfaceTransformData, surface_transform_data);
+ g_free (surface_transform_data);
priv->surface_transform_data = NULL;
}
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (!priv->surface_transform_data)
- priv->surface_transform_data = g_slice_new0 (GtkWidgetSurfaceTransformData);
+ priv->surface_transform_data = g_new0 (GtkWidgetSurfaceTransformData, 1);
return priv->surface_transform_data;
}
if (!surface_transform_data->callbacks)
sync_widget_surface_transform (widget);
- info = g_slice_new0 (GtkSurfaceTransformChangedCallbackInfo);
+ info = g_new0 (GtkSurfaceTransformChangedCallbackInfo, 1);
info->id = ++surface_transform_changed_callback_id;
info->callback = callback;
{
if (surface_transform_data->tracked_parent)
remove_parent_surface_transform_changed_listener (widget);
- g_slice_free (GtkWidgetSurfaceTransformData, surface_transform_data);
+ g_free (surface_transform_data);
priv->surface_transform_data = NULL;
}
}
child_class->name);
if (G_IS_OBJECT (child_object))
{
- FinalizeAssertion *assertion = g_slice_new0 (FinalizeAssertion);
+ FinalizeAssertion *assertion = g_new0 (FinalizeAssertion, 1);
assertion->child_class = child_class;
assertion->widget_type = class_type;
assertion->object = child_object;
g_type_name (assertion->widget_type),
assertion->object->ref_count);
- g_slice_free (FinalizeAssertion, assertion);
+ g_free (assertion);
}
g_slist_free (assertions);
#endif /* G_ENABLE_CONSISTENCY_CHECKS */
GtkRequisition *
gtk_requisition_new (void)
{
- return g_slice_new0 (GtkRequisition);
+ return g_new0 (GtkRequisition, 1);
}
/**
GtkRequisition *
gtk_requisition_copy (const GtkRequisition *requisition)
{
- return g_slice_dup (GtkRequisition, requisition);
+ GtkRequisition *copy = g_new (GtkRequisition, 1);
+ memcpy (copy, requisition, sizeof (GtkRequisition));
+ return copy;
}
/**
void
gtk_requisition_free (GtkRequisition *requisition)
{
- g_slice_free (GtkRequisition, requisition);
+ g_free (requisition);
}
G_DEFINE_BOXED_TYPE (GtkRequisition, gtk_requisition,
{
StyleParserData *data;
- data = g_slice_new0 (StyleParserData);
+ data = g_new0 (StyleParserData, 1);
data->builder = builder;
*parser = style_parser;
{
LayoutParserData *data;
- data = g_slice_new0 (LayoutParserData);
+ data = g_new0 (LayoutParserData, 1);
data->builder = builder;
data->object = (GObject *) g_object_ref (buildable);
{
AccessibilityParserData *data;
- data = g_slice_new0 (AccessibilityParserData);
+ data = g_new0 (AccessibilityParserData, 1);
data->builder = builder;
data->object = (GObject *) g_object_ref (buildable);
gtk_widget_add_css_class (GTK_WIDGET (buildable), (const char *)l->data);
g_slist_free_full (style_data->classes, g_free);
- g_slice_free (StyleParserData, style_data);
+ g_free (style_data);
}
else if (strcmp (tagname, "layout") == 0)
{
/* Free the unapplied properties, if any */
g_slist_free_full (layout_data->properties, layout_property_info_free);
g_object_unref (layout_data->object);
- g_slice_free (LayoutParserData, layout_data);
+ g_free (layout_data);
}
else if (strcmp (tagname, "accessibility") == 0)
{
g_slist_free_full (accessibility_data->states,
accessibility_attribute_info_free);
g_object_unref (accessibility_data->object);
- g_slice_free (AccessibilityParserData, accessibility_data);
+ g_free (accessibility_data);
}
}
gboolean internal_child,
gssize offset)
{
- AutomaticChildClass *child_class = g_slice_new0 (AutomaticChildClass);
+ AutomaticChildClass *child_class = g_new0 (AutomaticChildClass, 1);
child_class->name = g_strdup (name);
child_class->internal_child = internal_child;
g_return_if_fail (widget_class->priv->template == NULL);
g_return_if_fail (template_bytes != NULL);
- widget_class->priv->template = g_slice_new0 (GtkWidgetTemplate);
+ widget_class->priv->template = g_new0 (GtkWidgetTemplate, 1);
bytes_data = g_bytes_get_data (template_bytes, &bytes_size);
if (_gtk_buildable_parser_is_precompiled (bytes_data, bytes_size))
free_icon_info (GtkWindowIconInfo *info)
{
g_free (info->icon_name);
- g_slice_free (GtkWindowIconInfo, info);
+ g_free (info);
}
if (info == NULL)
{
- info = g_slice_new0 (GtkWindowIconInfo);
+ info = g_new0 (GtkWindowIconInfo, 1);
g_object_set_qdata_full (G_OBJECT (window),
quark_gtk_window_icon_info,
info,
projects / gtk4.git / commitdiff