[gimp] app: remove const qualifiers from all object parameters
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] app: remove const qualifiers from all object parameters
- Date: Thu, 19 May 2016 21:54:30 +0000 (UTC)
commit 28e1a379e6766b778f1854fea8bf1029e6d70a73
Author: Michael Natterer <mitch gimp org>
Date: Thu May 19 23:51:44 2016 +0200
app: remove const qualifiers from all object parameters
They are unreliable because every type checking cast discards them,
they are useless anyway, visual clutter, added inconsistently, and
generally suck. Wanted to do this a long time ago, it was a bad idea
in the first place.
app/core/core-types.h | 14 +-
app/core/gimp-edit.c | 6 +-
app/core/gimp-edit.h | 84 +++++-----
app/core/gimp-templates.c | 4 +-
app/core/gimpbrush.c | 14 +-
app/core/gimpbrush.h | 14 +-
app/core/gimpbrushgenerated.c | 12 +-
app/core/gimpbrushgenerated.h | 12 +-
app/core/gimpbuffer.c | 10 +-
app/core/gimpbuffer.h | 10 +-
app/core/gimpchannel.c | 20 +-
app/core/gimpchannel.h | 4 +-
app/core/gimpcontainer-filter.c | 18 +-
app/core/gimpcontainer-filter.h | 6 +-
app/core/gimpcontainer.c | 42 +++---
app/core/gimpcontainer.h | 138 ++++++++--------
app/core/gimpcontext.c | 2 +-
app/core/gimpcontext.h | 2 +-
app/core/gimpdrawable.c | 56 +++---
app/core/gimpdrawable.h | 51 +++---
app/core/gimpgrid.c | 2 +-
app/core/gimpgrid.h | 2 +-
app/core/gimpgrouplayer.c | 14 +-
app/core/gimpimage-colormap.c | 8 +-
app/core/gimpimage-colormap.h | 56 +++---
app/core/gimpimage-item-list.c | 2 +-
app/core/gimpimage-item-list.h | 2 +-
app/core/gimpimage-pick-layer.c | 18 +-
app/core/gimpimage-pick-layer.h | 18 +-
app/core/gimpimage-quick-mask.c | 10 +-
app/core/gimpimage-quick-mask.h | 20 +-
app/core/gimpimage-scale.c | 10 +-
app/core/gimpimage-scale.h | 2 +-
app/core/gimpimage-undo.c | 8 +-
app/core/gimpimage-undo.h | 64 ++++----
app/core/gimpimage.c | 164 +++++++++---------
app/core/gimpimage.h | 144 ++++++++--------
app/core/gimpitem-linked.c | 2 +-
app/core/gimpitem-linked.h | 2 +-
app/core/gimpitem.c | 62 ++++----
app/core/gimpitem.h | 48 +++---
app/core/gimplayer.c | 46 +++---
app/core/gimplayer.h | 22 ++--
app/core/gimplayermask.c | 14 +-
app/core/gimplayermask.h | 26 ++--
app/core/gimplist.c | 96 +++++-----
app/core/gimpparasitelist.c | 2 +-
app/core/gimpparasitelist.h | 2 +-
app/core/gimppattern.c | 4 +-
app/core/gimppattern.h | 10 +-
app/core/gimpselection.c | 4 +-
app/core/gimptag.c | 4 +-
app/core/gimptag.h | 46 +++---
app/core/gimptoolinfo.c | 4 +-
app/dialogs/convert-indexed-dialog.c | 24 ++--
app/display/gimpdisplayshell-transform.c | 218 ++++++++++++------------
app/display/gimpdisplayshell-transform.h | 274 +++++++++++++++---------------
app/file/file-open.c | 8 +-
app/plug-in/gimppluginprocedure.c | 10 +-
app/plug-in/gimppluginprocedure.h | 82 +++++-----
app/plug-in/gimptemporaryprocedure.c | 4 +-
app/vectors/gimpbezierstroke.c | 58 +++---
app/vectors/gimpstroke.c | 228 +++++++++++++-------------
app/vectors/gimpstroke.h | 88 +++++-----
app/vectors/gimpvectors-export.c | 40 +++---
app/vectors/gimpvectors-export.h | 12 +-
app/vectors/gimpvectors-warp.c | 46 +++---
app/vectors/gimpvectors-warp.h | 15 +-
app/vectors/gimpvectors.c | 110 ++++++------
app/vectors/gimpvectors.h | 52 +++---
app/widgets/gimpitemtreeview.h | 28 ++--
71 files changed, 1377 insertions(+), 1377 deletions(-)
---
diff --git a/app/core/core-types.h b/app/core/core-types.h
index 1ae6213..4249dcc 100644
--- a/app/core/core-types.h
+++ b/app/core/core-types.h
@@ -241,15 +241,15 @@ typedef void * GimpBezierDesc;
/* functions */
-typedef void (* GimpInitStatusFunc) (const gchar *text1,
- const gchar *text2,
- gdouble percentage);
+typedef void (* GimpInitStatusFunc) (const gchar *text1,
+ const gchar *text2,
+ gdouble percentage);
-typedef gboolean (* GimpObjectFilterFunc) (const GimpObject *object,
- gpointer user_data);
+typedef gboolean (* GimpObjectFilterFunc) (GimpObject *object,
+ gpointer user_data);
-typedef gint64 (* GimpMemsizeFunc) (gpointer instance,
- gint64 *gui_size);
+typedef gint64 (* GimpMemsizeFunc) (gpointer instance,
+ gint64 *gui_size);
/* structs */
diff --git a/app/core/gimp-edit.c b/app/core/gimp-edit.c
index 652a145..57fb54a 100644
--- a/app/core/gimp-edit.c
+++ b/app/core/gimp-edit.c
@@ -63,7 +63,7 @@ static GimpBuffer * gimp_edit_extract (GimpImage *image,
/* public functions */
-const GimpBuffer *
+GimpBuffer *
gimp_edit_cut (GimpImage *image,
GimpDrawable *drawable,
GimpContext *context,
@@ -91,7 +91,7 @@ gimp_edit_cut (GimpImage *image,
return NULL;
}
-const GimpBuffer *
+GimpBuffer *
gimp_edit_copy (GimpImage *image,
GimpDrawable *drawable,
GimpContext *context,
@@ -119,7 +119,7 @@ gimp_edit_copy (GimpImage *image,
return NULL;
}
-const GimpBuffer *
+GimpBuffer *
gimp_edit_copy_visible (GimpImage *image,
GimpContext *context,
GError **error)
diff --git a/app/core/gimp-edit.h b/app/core/gimp-edit.h
index 7c0fda5..06997ff 100644
--- a/app/core/gimp-edit.h
+++ b/app/core/gimp-edit.h
@@ -19,51 +19,51 @@
#define __GIMP_EDIT_H__
-const GimpBuffer * gimp_edit_cut (GimpImage *image,
- GimpDrawable *drawable,
- GimpContext *context,
- GError **error);
-const GimpBuffer * gimp_edit_copy (GimpImage *image,
- GimpDrawable *drawable,
- GimpContext *context,
- GError **error);
-const GimpBuffer * gimp_edit_copy_visible (GimpImage *image,
- GimpContext *context,
- GError **error);
-GimpLayer * gimp_edit_paste (GimpImage *image,
- GimpDrawable *drawable,
- GimpBuffer *paste,
- gboolean paste_into,
- gint viewport_x,
- gint viewport_y,
- gint viewport_width,
- gint viewport_height);
+GimpBuffer * gimp_edit_cut (GimpImage *image,
+ GimpDrawable *drawable,
+ GimpContext *context,
+ GError **error);
+GimpBuffer * gimp_edit_copy (GimpImage *image,
+ GimpDrawable *drawable,
+ GimpContext *context,
+ GError **error);
+GimpBuffer * gimp_edit_copy_visible (GimpImage *image,
+ GimpContext *context,
+ GError **error);
+GimpLayer * gimp_edit_paste (GimpImage *image,
+ GimpDrawable *drawable,
+ GimpBuffer *paste,
+ gboolean paste_into,
+ gint viewport_x,
+ gint viewport_y,
+ gint viewport_width,
+ gint viewport_height);
-const gchar * gimp_edit_named_cut (GimpImage *image,
- const gchar *name,
- GimpDrawable *drawable,
- GimpContext *context,
- GError **error);
-const gchar * gimp_edit_named_copy (GimpImage *image,
- const gchar *name,
- GimpDrawable *drawable,
- GimpContext *context,
- GError **error);
-const gchar * gimp_edit_named_copy_visible (GimpImage *image,
- const gchar *name,
- GimpContext *context,
- GError **error);
+const gchar * gimp_edit_named_cut (GimpImage *image,
+ const gchar *name,
+ GimpDrawable *drawable,
+ GimpContext *context,
+ GError **error);
+const gchar * gimp_edit_named_copy (GimpImage *image,
+ const gchar *name,
+ GimpDrawable *drawable,
+ GimpContext *context,
+ GError **error);
+const gchar * gimp_edit_named_copy_visible (GimpImage *image,
+ const gchar *name,
+ GimpContext *context,
+ GError **error);
-void gimp_edit_clear (GimpImage *image,
- GimpDrawable *drawable,
- GimpContext *context);
-void gimp_edit_fill (GimpImage *image,
- GimpDrawable *drawable,
- GimpFillOptions *options,
- const gchar *undo_desc);
+void gimp_edit_clear (GimpImage *image,
+ GimpDrawable *drawable,
+ GimpContext *context);
+void gimp_edit_fill (GimpImage *image,
+ GimpDrawable *drawable,
+ GimpFillOptions *options,
+ const gchar *undo_desc);
-gboolean gimp_edit_fade (GimpImage *image,
- GimpContext *context);
+gboolean gimp_edit_fade (GimpImage *image,
+ GimpContext *context);
#endif /* __GIMP_EDIT_H__ */
diff --git a/app/core/gimp-templates.c b/app/core/gimp-templates.c
index 8d7047f..a3c9393 100644
--- a/app/core/gimp-templates.c
+++ b/app/core/gimp-templates.c
@@ -117,8 +117,8 @@ gimp_templates_save (Gimp *gimp)
* and dpi/ppi-insensitive
*/
static GimpObject *
-gimp_templates_migrate_get_child_by_name (const GimpContainer *container,
- const gchar *name)
+gimp_templates_migrate_get_child_by_name (GimpContainer *container,
+ const gchar *name)
{
GimpList *list = GIMP_LIST (container);
GimpObject *retval = NULL;
diff --git a/app/core/gimpbrush.c b/app/core/gimpbrush.c
index eaa47ed..37dbe05 100644
--- a/app/core/gimpbrush.c
+++ b/app/core/gimpbrush.c
@@ -818,7 +818,7 @@ gimp_brush_transform_boundary (GimpBrush *brush,
}
GimpTempBuf *
-gimp_brush_get_mask (const GimpBrush *brush)
+gimp_brush_get_mask (GimpBrush *brush)
{
g_return_val_if_fail (brush != NULL, NULL);
g_return_val_if_fail (GIMP_IS_BRUSH (brush), NULL);
@@ -827,7 +827,7 @@ gimp_brush_get_mask (const GimpBrush *brush)
}
GimpTempBuf *
-gimp_brush_get_pixmap (const GimpBrush *brush)
+gimp_brush_get_pixmap (GimpBrush *brush)
{
g_return_val_if_fail (brush != NULL, NULL);
g_return_val_if_fail (GIMP_IS_BRUSH (brush), NULL);
@@ -836,7 +836,7 @@ gimp_brush_get_pixmap (const GimpBrush *brush)
}
gint
-gimp_brush_get_width (const GimpBrush *brush)
+gimp_brush_get_width (GimpBrush *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH (brush), 0);
@@ -844,7 +844,7 @@ gimp_brush_get_width (const GimpBrush *brush)
}
gint
-gimp_brush_get_height (const GimpBrush *brush)
+gimp_brush_get_height (GimpBrush *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH (brush), 0);
@@ -852,7 +852,7 @@ gimp_brush_get_height (const GimpBrush *brush)
}
gint
-gimp_brush_get_spacing (const GimpBrush *brush)
+gimp_brush_get_spacing (GimpBrush *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH (brush), 0);
@@ -877,7 +877,7 @@ gimp_brush_set_spacing (GimpBrush *brush,
static const GimpVector2 fail = { 0.0, 0.0 };
GimpVector2
-gimp_brush_get_x_axis (const GimpBrush *brush)
+gimp_brush_get_x_axis (GimpBrush *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH (brush), fail);
@@ -885,7 +885,7 @@ gimp_brush_get_x_axis (const GimpBrush *brush)
}
GimpVector2
-gimp_brush_get_y_axis (const GimpBrush *brush)
+gimp_brush_get_y_axis (GimpBrush *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH (brush), fail);
diff --git a/app/core/gimpbrush.h b/app/core/gimpbrush.h
index 42390d1..0bf353f 100644
--- a/app/core/gimpbrush.h
+++ b/app/core/gimpbrush.h
@@ -128,18 +128,18 @@ const GimpBezierDesc * gimp_brush_transform_boundary (GimpBrush *brush,
gint *width,
gint *height);
-GimpTempBuf * gimp_brush_get_mask (const GimpBrush *brush);
-GimpTempBuf * gimp_brush_get_pixmap (const GimpBrush *brush);
+GimpTempBuf * gimp_brush_get_mask (GimpBrush *brush);
+GimpTempBuf * gimp_brush_get_pixmap (GimpBrush *brush);
-gint gimp_brush_get_width (const GimpBrush *brush);
-gint gimp_brush_get_height (const GimpBrush *brush);
+gint gimp_brush_get_width (GimpBrush *brush);
+gint gimp_brush_get_height (GimpBrush *brush);
-gint gimp_brush_get_spacing (const GimpBrush *brush);
+gint gimp_brush_get_spacing (GimpBrush *brush);
void gimp_brush_set_spacing (GimpBrush *brush,
gint spacing);
-GimpVector2 gimp_brush_get_x_axis (const GimpBrush *brush);
-GimpVector2 gimp_brush_get_y_axis (const GimpBrush *brush);
+GimpVector2 gimp_brush_get_x_axis (GimpBrush *brush);
+GimpVector2 gimp_brush_get_y_axis (GimpBrush *brush);
#endif /* __GIMP_BRUSH_H__ */
diff --git a/app/core/gimpbrushgenerated.c b/app/core/gimpbrushgenerated.c
index 858bc0b..fdb1d11 100644
--- a/app/core/gimpbrushgenerated.c
+++ b/app/core/gimpbrushgenerated.c
@@ -803,7 +803,7 @@ gimp_brush_generated_set_angle (GimpBrushGenerated *brush,
}
GimpBrushGeneratedShape
-gimp_brush_generated_get_shape (const GimpBrushGenerated *brush)
+gimp_brush_generated_get_shape (GimpBrushGenerated *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush),
GIMP_BRUSH_GENERATED_CIRCLE);
@@ -812,7 +812,7 @@ gimp_brush_generated_get_shape (const GimpBrushGenerated *brush)
}
gfloat
-gimp_brush_generated_get_radius (const GimpBrushGenerated *brush)
+gimp_brush_generated_get_radius (GimpBrushGenerated *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
@@ -820,7 +820,7 @@ gimp_brush_generated_get_radius (const GimpBrushGenerated *brush)
}
gint
-gimp_brush_generated_get_spikes (const GimpBrushGenerated *brush)
+gimp_brush_generated_get_spikes (GimpBrushGenerated *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1);
@@ -828,7 +828,7 @@ gimp_brush_generated_get_spikes (const GimpBrushGenerated *brush)
}
gfloat
-gimp_brush_generated_get_hardness (const GimpBrushGenerated *brush)
+gimp_brush_generated_get_hardness (GimpBrushGenerated *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
@@ -836,7 +836,7 @@ gimp_brush_generated_get_hardness (const GimpBrushGenerated *brush)
}
gfloat
-gimp_brush_generated_get_aspect_ratio (const GimpBrushGenerated *brush)
+gimp_brush_generated_get_aspect_ratio (GimpBrushGenerated *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
@@ -844,7 +844,7 @@ gimp_brush_generated_get_aspect_ratio (const GimpBrushGenerated *brush)
}
gfloat
-gimp_brush_generated_get_angle (const GimpBrushGenerated *brush)
+gimp_brush_generated_get_angle (GimpBrushGenerated *brush)
{
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (brush), -1.0);
diff --git a/app/core/gimpbrushgenerated.h b/app/core/gimpbrushgenerated.h
index af7e4b1..d72f99d 100644
--- a/app/core/gimpbrushgenerated.h
+++ b/app/core/gimpbrushgenerated.h
@@ -77,12 +77,12 @@ gfloat gimp_brush_generated_set_angle (GimpBrushGenerated *brush,
gfloat angle);
GimpBrushGeneratedShape
- gimp_brush_generated_get_shape (const GimpBrushGenerated *brush);
-gfloat gimp_brush_generated_get_radius (const GimpBrushGenerated *brush);
-gint gimp_brush_generated_get_spikes (const GimpBrushGenerated *brush);
-gfloat gimp_brush_generated_get_hardness (const GimpBrushGenerated *brush);
-gfloat gimp_brush_generated_get_aspect_ratio (const GimpBrushGenerated *brush);
-gfloat gimp_brush_generated_get_angle (const GimpBrushGenerated *brush);
+ gimp_brush_generated_get_shape (GimpBrushGenerated *brush);
+gfloat gimp_brush_generated_get_radius (GimpBrushGenerated *brush);
+gint gimp_brush_generated_get_spikes (GimpBrushGenerated *brush);
+gfloat gimp_brush_generated_get_hardness (GimpBrushGenerated *brush);
+gfloat gimp_brush_generated_get_aspect_ratio (GimpBrushGenerated *brush);
+gfloat gimp_brush_generated_get_angle (GimpBrushGenerated *brush);
#endif /* __GIMP_BRUSH_GENERATED_H__ */
diff --git a/app/core/gimpbuffer.c b/app/core/gimpbuffer.c
index b3c9a2e..bd11fb6 100644
--- a/app/core/gimpbuffer.c
+++ b/app/core/gimpbuffer.c
@@ -436,7 +436,7 @@ gimp_buffer_new_from_pixbuf (GdkPixbuf *pixbuf,
}
gint
-gimp_buffer_get_width (const GimpBuffer *buffer)
+gimp_buffer_get_width (GimpBuffer *buffer)
{
g_return_val_if_fail (GIMP_IS_BUFFER (buffer), 0);
@@ -444,7 +444,7 @@ gimp_buffer_get_width (const GimpBuffer *buffer)
}
gint
-gimp_buffer_get_height (const GimpBuffer *buffer)
+gimp_buffer_get_height (GimpBuffer *buffer)
{
g_return_val_if_fail (GIMP_IS_BUFFER (buffer), 0);
@@ -452,7 +452,7 @@ gimp_buffer_get_height (const GimpBuffer *buffer)
}
const Babl *
-gimp_buffer_get_format (const GimpBuffer *buffer)
+gimp_buffer_get_format (GimpBuffer *buffer)
{
g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL);
@@ -460,7 +460,7 @@ gimp_buffer_get_format (const GimpBuffer *buffer)
}
GeglBuffer *
-gimp_buffer_get_buffer (const GimpBuffer *buffer)
+gimp_buffer_get_buffer (GimpBuffer *buffer)
{
g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL);
@@ -490,7 +490,7 @@ gimp_buffer_set_color_profile (GimpBuffer *buffer,
}
GimpColorProfile *
-gimp_buffer_get_color_profile (const GimpBuffer *buffer)
+gimp_buffer_get_color_profile (GimpBuffer *buffer)
{
g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL);
diff --git a/app/core/gimpbuffer.h b/app/core/gimpbuffer.h
index 6817ed6..5df440c 100644
--- a/app/core/gimpbuffer.h
+++ b/app/core/gimpbuffer.h
@@ -61,15 +61,15 @@ GimpBuffer * gimp_buffer_new_from_pixbuf (GdkPixbuf *pixbuf,
gint offset_x,
gint offset_y);
-gint gimp_buffer_get_width (const GimpBuffer *buffer);
-gint gimp_buffer_get_height (const GimpBuffer *buffer);
-const Babl * gimp_buffer_get_format (const GimpBuffer *buffer);
+gint gimp_buffer_get_width (GimpBuffer *buffer);
+gint gimp_buffer_get_height (GimpBuffer *buffer);
+const Babl * gimp_buffer_get_format (GimpBuffer *buffer);
-GeglBuffer * gimp_buffer_get_buffer (const GimpBuffer *buffer);
+GeglBuffer * gimp_buffer_get_buffer (GimpBuffer *buffer);
void gimp_buffer_set_color_profile (GimpBuffer *buffer,
GimpColorProfile *profile);
-GimpColorProfile * gimp_buffer_get_color_profile (const GimpBuffer *buffer);
+GimpColorProfile * gimp_buffer_get_color_profile (GimpBuffer *buffer);
#endif /* __GIMP_BUFFER_H__ */
diff --git a/app/core/gimpchannel.c b/app/core/gimpchannel.c
index 11bdd1c..92f589d 100644
--- a/app/core/gimpchannel.c
+++ b/app/core/gimpchannel.c
@@ -76,7 +76,7 @@ static gchar * gimp_channel_get_description (GimpViewable *viewable,
static GeglNode * gimp_channel_get_node (GimpFilter *filter);
-static gboolean gimp_channel_is_attached (const GimpItem *item);
+static gboolean gimp_channel_is_attached (GimpItem *item);
static GimpItemTree * gimp_channel_get_tree (GimpItem *item);
static gboolean gimp_channel_bounds (GimpItem *item,
gdouble *x,
@@ -153,10 +153,10 @@ static void gimp_channel_convert_type (GimpDrawable *drawable,
gboolean push_undo,
GimpProgress *progress);
static void gimp_channel_invalidate_boundary (GimpDrawable *drawable);
-static void gimp_channel_get_active_components (const GimpDrawable *drawable,
+static void gimp_channel_get_active_components (GimpDrawable *drawable,
gboolean *active);
static GimpComponentMask
- gimp_channel_get_active_mask (const GimpDrawable *drawable);
+ gimp_channel_get_active_mask (GimpDrawable *drawable);
static void gimp_channel_apply_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
@@ -475,7 +475,7 @@ gimp_channel_get_node (GimpFilter *filter)
}
static gboolean
-gimp_channel_is_attached (const GimpItem *item)
+gimp_channel_is_attached (GimpItem *item)
{
GimpImage *image = gimp_item_get_image (item);
@@ -988,8 +988,8 @@ gimp_channel_invalidate_boundary (GimpDrawable *drawable)
}
static void
-gimp_channel_get_active_components (const GimpDrawable *drawable,
- gboolean *active)
+gimp_channel_get_active_components (GimpDrawable *drawable,
+ gboolean *active)
{
/* Make sure that the alpha channel is not valid. */
active[GRAY] = TRUE;
@@ -997,7 +997,7 @@ gimp_channel_get_active_components (const GimpDrawable *drawable,
}
static GimpComponentMask
-gimp_channel_get_active_mask (const GimpDrawable *drawable)
+gimp_channel_get_active_mask (GimpDrawable *drawable)
{
/* Return all, because that skips the component mask op when painting */
return GIMP_COMPONENT_MASK_ALL;
@@ -1804,8 +1804,8 @@ gimp_channel_set_color (GimpChannel *channel,
}
void
-gimp_channel_get_color (const GimpChannel *channel,
- GimpRGB *color)
+gimp_channel_get_color (GimpChannel *channel,
+ GimpRGB *color)
{
g_return_if_fail (GIMP_IS_CHANNEL (channel));
g_return_if_fail (color != NULL);
@@ -1814,7 +1814,7 @@ gimp_channel_get_color (const GimpChannel *channel,
}
gdouble
-gimp_channel_get_opacity (const GimpChannel *channel)
+gimp_channel_get_opacity (GimpChannel *channel)
{
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), GIMP_OPACITY_TRANSPARENT);
diff --git a/app/core/gimpchannel.h b/app/core/gimpchannel.h
index 07931b6..ef8526f 100644
--- a/app/core/gimpchannel.h
+++ b/app/core/gimpchannel.h
@@ -141,12 +141,12 @@ GimpChannel * gimp_channel_new_from_component (GimpImage *image,
GimpChannel * gimp_channel_get_parent (GimpChannel *channel);
-gdouble gimp_channel_get_opacity (const GimpChannel *channel);
+gdouble gimp_channel_get_opacity (GimpChannel *channel);
void gimp_channel_set_opacity (GimpChannel *channel,
gdouble opacity,
gboolean push_undo);
-void gimp_channel_get_color (const GimpChannel *channel,
+void gimp_channel_get_color (GimpChannel *channel,
GimpRGB *color);
void gimp_channel_set_color (GimpChannel *channel,
const GimpRGB *color,
diff --git a/app/core/gimpcontainer-filter.c b/app/core/gimpcontainer-filter.c
index 774b402..45cb95b 100644
--- a/app/core/gimpcontainer-filter.c
+++ b/app/core/gimpcontainer-filter.c
@@ -59,7 +59,7 @@ gimp_container_filter_foreach_func (GimpObject *object,
* Returns: a weak #GimpContainer filled with matching objects.
**/
GimpContainer *
-gimp_container_filter (const GimpContainer *container,
+gimp_container_filter (GimpContainer *container,
GimpObjectFilterFunc filter,
gpointer user_data)
{
@@ -93,8 +93,8 @@ gimp_container_filter (const GimpContainer *container,
static gboolean
-gimp_object_filter_by_name (const GimpObject *object,
- const GRegex *regex)
+gimp_object_filter_by_name (GimpObject *object,
+ const GRegex *regex)
{
return g_regex_match (regex, gimp_object_get_name (object), 0, NULL);
}
@@ -111,9 +111,9 @@ gimp_object_filter_by_name (const GimpObject *object,
* Returns: a weak #GimpContainer filled with matching objects.
**/
GimpContainer *
-gimp_container_filter_by_name (const GimpContainer *container,
- const gchar *regexp,
- GError **error)
+gimp_container_filter_by_name (GimpContainer *container,
+ const gchar *regexp,
+ GError **error)
{
GimpContainer *result;
GRegex *regex;
@@ -140,9 +140,9 @@ gimp_container_filter_by_name (const GimpContainer *container,
gchar **
-gimp_container_get_filtered_name_array (const GimpContainer *container,
- const gchar *regexp,
- gint *length)
+gimp_container_get_filtered_name_array (GimpContainer *container,
+ const gchar *regexp,
+ gint *length)
{
GimpContainer *weak;
GError *error = NULL;
diff --git a/app/core/gimpcontainer-filter.h b/app/core/gimpcontainer-filter.h
index b83cc58..78aaefa 100644
--- a/app/core/gimpcontainer-filter.h
+++ b/app/core/gimpcontainer-filter.h
@@ -22,15 +22,15 @@
#define __GIMP_CONTAINER_FILTER_H__
-GimpContainer * gimp_container_filter (const GimpContainer *container,
+GimpContainer * gimp_container_filter (GimpContainer *container,
GimpObjectFilterFunc filter,
gpointer user_data);
-GimpContainer * gimp_container_filter_by_name (const GimpContainer *container,
+GimpContainer * gimp_container_filter_by_name (GimpContainer *container,
const gchar *regexp,
GError **error);
gchar ** gimp_container_get_filtered_name_array
- (const GimpContainer *container,
+ (GimpContainer *container,
const gchar *regexp,
gint *length);
diff --git a/app/core/gimpcontainer.c b/app/core/gimpcontainer.c
index 9b92040..9773a67 100644
--- a/app/core/gimpcontainer.c
+++ b/app/core/gimpcontainer.c
@@ -523,7 +523,7 @@ gimp_container_disconnect_callback (GimpObject *object,
}
GType
-gimp_container_get_children_type (const GimpContainer *container)
+gimp_container_get_children_type (GimpContainer *container)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), G_TYPE_NONE);
@@ -531,7 +531,7 @@ gimp_container_get_children_type (const GimpContainer *container)
}
GimpContainerPolicy
-gimp_container_get_policy (const GimpContainer *container)
+gimp_container_get_policy (GimpContainer *container)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), 0);
@@ -539,7 +539,7 @@ gimp_container_get_policy (const GimpContainer *container)
}
gint
-gimp_container_get_n_children (const GimpContainer *container)
+gimp_container_get_n_children (GimpContainer *container)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), 0);
@@ -783,7 +783,7 @@ gimp_container_clear (GimpContainer *container)
}
gboolean
-gimp_container_is_empty (const GimpContainer *container)
+gimp_container_is_empty (GimpContainer *container)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);
@@ -791,8 +791,8 @@ gimp_container_is_empty (const GimpContainer *container)
}
gboolean
-gimp_container_have (const GimpContainer *container,
- GimpObject *object)
+gimp_container_have (GimpContainer *container,
+ GimpObject *object)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), FALSE);
@@ -803,9 +803,9 @@ gimp_container_have (const GimpContainer *container,
}
void
-gimp_container_foreach (const GimpContainer *container,
- GFunc func,
- gpointer user_data)
+gimp_container_foreach (GimpContainer *container,
+ GFunc func,
+ gpointer user_data)
{
g_return_if_fail (GIMP_IS_CONTAINER (container));
g_return_if_fail (func != NULL);
@@ -815,8 +815,8 @@ gimp_container_foreach (const GimpContainer *container,
}
GimpObject *
-gimp_container_get_child_by_name (const GimpContainer *container,
- const gchar *name)
+gimp_container_get_child_by_name (GimpContainer *container,
+ const gchar *name)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL);
@@ -828,8 +828,8 @@ gimp_container_get_child_by_name (const GimpContainer *container,
}
GimpObject *
-gimp_container_get_child_by_index (const GimpContainer *container,
- gint index)
+gimp_container_get_child_by_index (GimpContainer *container,
+ gint index)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL);
@@ -848,7 +848,7 @@ gimp_container_get_child_by_index (const GimpContainer *container,
* container is empty
*/
GimpObject *
-gimp_container_get_first_child (const GimpContainer *container)
+gimp_container_get_first_child (GimpContainer *container)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL);
@@ -867,7 +867,7 @@ gimp_container_get_first_child (const GimpContainer *container)
* container is empty
*/
GimpObject *
-gimp_container_get_last_child (const GimpContainer *container)
+gimp_container_get_last_child (GimpContainer *container)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL);
@@ -879,8 +879,8 @@ gimp_container_get_last_child (const GimpContainer *container)
}
gint
-gimp_container_get_child_index (const GimpContainer *container,
- const GimpObject *object)
+gimp_container_get_child_index (GimpContainer *container,
+ GimpObject *object)
{
g_return_val_if_fail (GIMP_IS_CONTAINER (container), -1);
g_return_val_if_fail (object != NULL, -1);
@@ -893,8 +893,8 @@ gimp_container_get_child_index (const GimpContainer *container,
}
GimpObject *
-gimp_container_get_neighbor_of (const GimpContainer *container,
- const GimpObject *object)
+gimp_container_get_neighbor_of (GimpContainer *container,
+ GimpObject *object)
{
gint index;
@@ -929,8 +929,8 @@ gimp_container_get_name_array_foreach_func (GimpObject *object,
}
gchar **
-gimp_container_get_name_array (const GimpContainer *container,
- gint *length)
+gimp_container_get_name_array (GimpContainer *container,
+ gint *length)
{
gchar **names;
gchar **iter;
diff --git a/app/core/gimpcontainer.h b/app/core/gimpcontainer.h
index 99e86bf..5a2d218 100644
--- a/app/core/gimpcontainer.h
+++ b/app/core/gimpcontainer.h
@@ -48,82 +48,82 @@ struct _GimpContainerClass
GimpObjectClass parent_class;
/* signals */
- void (* add) (GimpContainer *container,
- GimpObject *object);
- void (* remove) (GimpContainer *container,
- GimpObject *object);
- void (* reorder) (GimpContainer *container,
- GimpObject *object,
- gint new_index);
- void (* freeze) (GimpContainer *container);
- void (* thaw) (GimpContainer *container);
+ void (* add) (GimpContainer *container,
+ GimpObject *object);
+ void (* remove) (GimpContainer *container,
+ GimpObject *object);
+ void (* reorder) (GimpContainer *container,
+ GimpObject *object,
+ gint new_index);
+ void (* freeze) (GimpContainer *container);
+ void (* thaw) (GimpContainer *container);
/* virtual functions */
- void (* clear) (GimpContainer *container);
- gboolean (* have) (const GimpContainer *container,
- const GimpObject *object);
- void (* foreach) (const GimpContainer *container,
- GFunc func,
- gpointer user_data);
- GimpObject * (* get_child_by_name) (const GimpContainer *container,
- const gchar *name);
- GimpObject * (* get_child_by_index) (const GimpContainer *container,
- gint index);
- gint (* get_child_index) (const GimpContainer *container,
- const GimpObject *object);
+ void (* clear) (GimpContainer *container);
+ gboolean (* have) (GimpContainer *container,
+ GimpObject *object);
+ void (* foreach) (GimpContainer *container,
+ GFunc func,
+ gpointer user_data);
+ GimpObject * (* get_child_by_name) (GimpContainer *container,
+ const gchar *name);
+ GimpObject * (* get_child_by_index) (GimpContainer *container,
+ gint index);
+ gint (* get_child_index) (GimpContainer *container,
+ GimpObject *object);
};
GType gimp_container_get_type (void) G_GNUC_CONST;
-GType gimp_container_get_children_type (const GimpContainer *container);
-GimpContainerPolicy gimp_container_get_policy (const GimpContainer *container);
-gint gimp_container_get_n_children (const GimpContainer *container);
-
-gboolean gimp_container_add (GimpContainer *container,
- GimpObject *object);
-gboolean gimp_container_remove (GimpContainer *container,
- GimpObject *object);
-gboolean gimp_container_insert (GimpContainer *container,
- GimpObject *object,
- gint new_index);
-gboolean gimp_container_reorder (GimpContainer *container,
- GimpObject *object,
- gint new_index);
-
-void gimp_container_freeze (GimpContainer *container);
-void gimp_container_thaw (GimpContainer *container);
-gboolean gimp_container_frozen (GimpContainer *container);
-
-void gimp_container_clear (GimpContainer *container);
-gboolean gimp_container_is_empty (const GimpContainer *container);
-gboolean gimp_container_have (const GimpContainer *container,
- GimpObject *object);
-void gimp_container_foreach (const GimpContainer *container,
- GFunc func,
- gpointer user_data);
-
-GimpObject * gimp_container_get_child_by_name (const GimpContainer *container,
- const gchar *name);
-GimpObject * gimp_container_get_child_by_index (const GimpContainer *container,
- gint index);
-GimpObject * gimp_container_get_first_child (const GimpContainer *container);
-GimpObject * gimp_container_get_last_child (const GimpContainer *container);
-gint gimp_container_get_child_index (const GimpContainer *container,
- const GimpObject *object);
-
-GimpObject * gimp_container_get_neighbor_of (const GimpContainer *container,
- const GimpObject *object);
-
-gchar ** gimp_container_get_name_array (const GimpContainer *container,
- gint *length);
-
-GQuark gimp_container_add_handler (GimpContainer *container,
- const gchar *signame,
- GCallback callback,
- gpointer callback_data);
-void gimp_container_remove_handler (GimpContainer *container,
- GQuark id);
+GType gimp_container_get_children_type (GimpContainer *container);
+GimpContainerPolicy gimp_container_get_policy (GimpContainer *container);
+gint gimp_container_get_n_children (GimpContainer *container);
+
+gboolean gimp_container_add (GimpContainer *container,
+ GimpObject *object);
+gboolean gimp_container_remove (GimpContainer *container,
+ GimpObject *object);
+gboolean gimp_container_insert (GimpContainer *container,
+ GimpObject *object,
+ gint new_index);
+gboolean gimp_container_reorder (GimpContainer *container,
+ GimpObject *object,
+ gint new_index);
+
+void gimp_container_freeze (GimpContainer *container);
+void gimp_container_thaw (GimpContainer *container);
+gboolean gimp_container_frozen (GimpContainer *container);
+
+void gimp_container_clear (GimpContainer *container);
+gboolean gimp_container_is_empty (GimpContainer *container);
+gboolean gimp_container_have (GimpContainer *container,
+ GimpObject *object);
+void gimp_container_foreach (GimpContainer *container,
+ GFunc func,
+ gpointer user_data);
+
+GimpObject * gimp_container_get_child_by_name (GimpContainer *container,
+ const gchar *name);
+GimpObject * gimp_container_get_child_by_index (GimpContainer *container,
+ gint index);
+GimpObject * gimp_container_get_first_child (GimpContainer *container);
+GimpObject * gimp_container_get_last_child (GimpContainer *container);
+gint gimp_container_get_child_index (GimpContainer *container,
+ GimpObject *object);
+
+GimpObject * gimp_container_get_neighbor_of (GimpContainer *container,
+ GimpObject *object);
+
+gchar ** gimp_container_get_name_array (GimpContainer *container,
+ gint *length);
+
+GQuark gimp_container_add_handler (GimpContainer *container,
+ const gchar *signame,
+ GCallback callback,
+ gpointer callback_data);
+void gimp_container_remove_handler (GimpContainer *container,
+ GQuark id);
#endif /* __GIMP_CONTAINER_H__ */
diff --git a/app/core/gimpcontext.c b/app/core/gimpcontext.c
index 9b0f3c8..53c4bd9 100644
--- a/app/core/gimpcontext.c
+++ b/app/core/gimpcontext.c
@@ -1556,7 +1556,7 @@ gimp_context_new (Gimp *gimp,
}
GimpContext *
-gimp_context_get_parent (const GimpContext *context)
+gimp_context_get_parent (GimpContext *context)
{
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
diff --git a/app/core/gimpcontext.h b/app/core/gimpcontext.h
index 43d08c1..14a1a22 100644
--- a/app/core/gimpcontext.h
+++ b/app/core/gimpcontext.h
@@ -160,7 +160,7 @@ GimpContext * gimp_context_new (Gimp *gimp,
const gchar *name,
GimpContext *template);
-GimpContext * gimp_context_get_parent (const GimpContext *context);
+GimpContext * gimp_context_get_parent (GimpContext *context);
void gimp_context_set_parent (GimpContext *context,
GimpContext *parent);
diff --git a/app/core/gimpdrawable.c b/app/core/gimpdrawable.c
index 4a65c7a..5f54d5b 100644
--- a/app/core/gimpdrawable.c
+++ b/app/core/gimpdrawable.c
@@ -146,7 +146,7 @@ static void gimp_drawable_real_update (GimpDrawable *drawable,
gint width,
gint height);
-static gint64 gimp_drawable_real_estimate_memsize (const GimpDrawable *drawable,
+static gint64 gimp_drawable_real_estimate_memsize (GimpDrawable *drawable,
GimpComponentType component_type,
gint width,
gint height);
@@ -768,10 +768,10 @@ gimp_drawable_real_update (GimpDrawable *drawable,
}
static gint64
-gimp_drawable_real_estimate_memsize (const GimpDrawable *drawable,
- GimpComponentType component_type,
- gint width,
- gint height)
+gimp_drawable_real_estimate_memsize (GimpDrawable *drawable,
+ GimpComponentType component_type,
+ gint width,
+ gint height)
{
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
gboolean linear = gimp_drawable_get_linear (drawable);
@@ -959,10 +959,10 @@ gimp_drawable_new (GType type,
}
gint64
-gimp_drawable_estimate_memsize (const GimpDrawable *drawable,
- GimpComponentType component_type,
- gint width,
- gint height)
+gimp_drawable_estimate_memsize (GimpDrawable *drawable,
+ GimpComponentType component_type,
+ gint width,
+ gint height)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), 0);
@@ -1006,8 +1006,8 @@ gimp_drawable_invalidate_boundary (GimpDrawable *drawable)
}
void
-gimp_drawable_get_active_components (const GimpDrawable *drawable,
- gboolean *active)
+gimp_drawable_get_active_components (GimpDrawable *drawable,
+ gboolean *active)
{
GimpDrawableClass *drawable_class;
@@ -1021,7 +1021,7 @@ gimp_drawable_get_active_components (const GimpDrawable *drawable,
}
GimpComponentMask
-gimp_drawable_get_active_mask (const GimpDrawable *drawable)
+gimp_drawable_get_active_mask (GimpDrawable *drawable)
{
GimpDrawableClass *drawable_class;
@@ -1297,7 +1297,7 @@ gimp_drawable_push_undo (GimpDrawable *drawable,
}
const Babl *
-gimp_drawable_get_format (const GimpDrawable *drawable)
+gimp_drawable_get_format (GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
@@ -1305,7 +1305,7 @@ gimp_drawable_get_format (const GimpDrawable *drawable)
}
const Babl *
-gimp_drawable_get_format_with_alpha (const GimpDrawable *drawable)
+gimp_drawable_get_format_with_alpha (GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
@@ -1316,7 +1316,7 @@ gimp_drawable_get_format_with_alpha (const GimpDrawable *drawable)
}
const Babl *
-gimp_drawable_get_format_without_alpha (const GimpDrawable *drawable)
+gimp_drawable_get_format_without_alpha (GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
@@ -1327,7 +1327,7 @@ gimp_drawable_get_format_without_alpha (const GimpDrawable *drawable)
}
gboolean
-gimp_drawable_get_linear (const GimpDrawable *drawable)
+gimp_drawable_get_linear (GimpDrawable *drawable)
{
const Babl *format;
@@ -1339,7 +1339,7 @@ gimp_drawable_get_linear (const GimpDrawable *drawable)
}
gboolean
-gimp_drawable_has_alpha (const GimpDrawable *drawable)
+gimp_drawable_has_alpha (GimpDrawable *drawable)
{
const Babl *format;
@@ -1351,7 +1351,7 @@ gimp_drawable_has_alpha (const GimpDrawable *drawable)
}
GimpImageBaseType
-gimp_drawable_get_base_type (const GimpDrawable *drawable)
+gimp_drawable_get_base_type (GimpDrawable *drawable)
{
const Babl *format;
@@ -1363,7 +1363,7 @@ gimp_drawable_get_base_type (const GimpDrawable *drawable)
}
GimpComponentType
-gimp_drawable_get_component_type (const GimpDrawable *drawable)
+gimp_drawable_get_component_type (GimpDrawable *drawable)
{
const Babl *format;
@@ -1375,7 +1375,7 @@ gimp_drawable_get_component_type (const GimpDrawable *drawable)
}
GimpPrecision
-gimp_drawable_get_precision (const GimpDrawable *drawable)
+gimp_drawable_get_precision (GimpDrawable *drawable)
{
const Babl *format;
@@ -1387,7 +1387,7 @@ gimp_drawable_get_precision (const GimpDrawable *drawable)
}
gboolean
-gimp_drawable_is_rgb (const GimpDrawable *drawable)
+gimp_drawable_is_rgb (GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
@@ -1395,7 +1395,7 @@ gimp_drawable_is_rgb (const GimpDrawable *drawable)
}
gboolean
-gimp_drawable_is_gray (const GimpDrawable *drawable)
+gimp_drawable_is_gray (GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
@@ -1403,7 +1403,7 @@ gimp_drawable_is_gray (const GimpDrawable *drawable)
}
gboolean
-gimp_drawable_is_indexed (const GimpDrawable *drawable)
+gimp_drawable_is_indexed (GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
@@ -1411,8 +1411,8 @@ gimp_drawable_is_indexed (const GimpDrawable *drawable)
}
const Babl *
-gimp_drawable_get_component_format (const GimpDrawable *drawable,
- GimpChannelType channel)
+gimp_drawable_get_component_format (GimpDrawable *drawable,
+ GimpChannelType channel)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
@@ -1452,8 +1452,8 @@ gimp_drawable_get_component_format (const GimpDrawable *drawable,
}
gint
-gimp_drawable_get_component_index (const GimpDrawable *drawable,
- GimpChannelType channel)
+gimp_drawable_get_component_index (GimpDrawable *drawable,
+ GimpChannelType channel)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), -1);
@@ -1477,7 +1477,7 @@ gimp_drawable_get_component_index (const GimpDrawable *drawable,
}
const guchar *
-gimp_drawable_get_colormap (const GimpDrawable *drawable)
+gimp_drawable_get_colormap (GimpDrawable *drawable)
{
GimpImage *image;
diff --git a/app/core/gimpdrawable.h b/app/core/gimpdrawable.h
index 52fc8c3..f457d22 100644
--- a/app/core/gimpdrawable.h
+++ b/app/core/gimpdrawable.h
@@ -53,14 +53,14 @@ struct _GimpDrawableClass
void (* alpha_changed) (GimpDrawable *drawable);
/* virtual functions */
- gint64 (* estimate_memsize) (const GimpDrawable *drawable,
+ gint64 (* estimate_memsize) (GimpDrawable *drawable,
GimpComponentType component_type,
gint width,
gint height);
void (* invalidate_boundary) (GimpDrawable *drawable);
- void (* get_active_components) (const GimpDrawable *drawable,
+ void (* get_active_components) (GimpDrawable *drawable,
gboolean *active);
- GimpComponentMask (* get_active_mask) (const GimpDrawable *drawable);
+ GimpComponentMask (* get_active_mask) (GimpDrawable *drawable);
void (* convert_type) (GimpDrawable *drawable,
GimpImage *dest_image,
const Babl *new_format,
@@ -123,7 +123,7 @@ GimpDrawable * gimp_drawable_new (GType type,
gint height,
const Babl *format);
-gint64 gimp_drawable_estimate_memsize (const GimpDrawable *drawable,
+gint64 gimp_drawable_estimate_memsize (GimpDrawable *drawable,
GimpComponentType component_type,
gint width,
gint height);
@@ -136,9 +136,9 @@ void gimp_drawable_update (GimpDrawable *drawable,
void gimp_drawable_alpha_changed (GimpDrawable *drawable);
void gimp_drawable_invalidate_boundary (GimpDrawable *drawable);
-void gimp_drawable_get_active_components (const GimpDrawable *drawable,
+void gimp_drawable_get_active_components (GimpDrawable *drawable,
gboolean *active);
-GimpComponentMask gimp_drawable_get_active_mask (const GimpDrawable *drawable);
+GimpComponentMask gimp_drawable_get_active_mask (GimpDrawable *drawable);
void gimp_drawable_convert_type (GimpDrawable *drawable,
GimpImage *dest_image,
@@ -199,26 +199,25 @@ void gimp_drawable_push_undo (GimpDrawable *drawable,
gint width,
gint height);
-const Babl * gimp_drawable_get_format (const GimpDrawable *drawable);
-const Babl * gimp_drawable_get_format_with_alpha
- (const GimpDrawable *drawable);
-const Babl * gimp_drawable_get_format_without_alpha
- (const GimpDrawable *drawable);
-gboolean gimp_drawable_get_linear (const GimpDrawable *drawable);
-gboolean gimp_drawable_has_alpha (const GimpDrawable *drawable);
-GimpImageBaseType gimp_drawable_get_base_type (const GimpDrawable *drawable);
-GimpComponentType gimp_drawable_get_component_type(const GimpDrawable *drawable);
-GimpPrecision gimp_drawable_get_precision (const GimpDrawable *drawable);
-gboolean gimp_drawable_is_rgb (const GimpDrawable *drawable);
-gboolean gimp_drawable_is_gray (const GimpDrawable *drawable);
-gboolean gimp_drawable_is_indexed (const GimpDrawable *drawable);
-
-const Babl * gimp_drawable_get_component_format (const GimpDrawable *drawable,
- GimpChannelType channel);
-gint gimp_drawable_get_component_index (const GimpDrawable *drawable,
- GimpChannelType channel);
-
-const guchar * gimp_drawable_get_colormap (const GimpDrawable *drawable);
+const Babl * gimp_drawable_get_format (GimpDrawable *drawable);
+const Babl * gimp_drawable_get_format_with_alpha(GimpDrawable *drawable);
+const Babl * gimp_drawable_get_format_without_alpha
+ (GimpDrawable *drawable);
+gboolean gimp_drawable_get_linear (GimpDrawable *drawable);
+gboolean gimp_drawable_has_alpha (GimpDrawable *drawable);
+GimpImageBaseType gimp_drawable_get_base_type (GimpDrawable *drawable);
+GimpComponentType gimp_drawable_get_component_type (GimpDrawable *drawable);
+GimpPrecision gimp_drawable_get_precision (GimpDrawable *drawable);
+gboolean gimp_drawable_is_rgb (GimpDrawable *drawable);
+gboolean gimp_drawable_is_gray (GimpDrawable *drawable);
+gboolean gimp_drawable_is_indexed (GimpDrawable *drawable);
+
+const Babl * gimp_drawable_get_component_format (GimpDrawable *drawable,
+ GimpChannelType channel);
+gint gimp_drawable_get_component_index (GimpDrawable *drawable,
+ GimpChannelType channel);
+
+const guchar * gimp_drawable_get_colormap (GimpDrawable *drawable);
#endif /* __GIMP_DRAWABLE_H__ */
diff --git a/app/core/gimpgrid.c b/app/core/gimpgrid.c
index 7f39064..3b8109a 100644
--- a/app/core/gimpgrid.c
+++ b/app/core/gimpgrid.c
@@ -307,7 +307,7 @@ gimp_grid_parasite_name (void)
}
GimpParasite *
-gimp_grid_to_parasite (const GimpGrid *grid)
+gimp_grid_to_parasite (GimpGrid *grid)
{
GimpParasite *parasite;
gchar *str;
diff --git a/app/core/gimpgrid.h b/app/core/gimpgrid.h
index 6a18278..f5d065b 100644
--- a/app/core/gimpgrid.h
+++ b/app/core/gimpgrid.h
@@ -74,7 +74,7 @@ void gimp_grid_get_offset (GimpGrid *grid,
gdouble *yoffset);
const gchar * gimp_grid_parasite_name (void) G_GNUC_CONST;
-GimpParasite * gimp_grid_to_parasite (const GimpGrid *grid);
+GimpParasite * gimp_grid_to_parasite (GimpGrid *grid);
GimpGrid * gimp_grid_from_parasite (const GimpParasite *parasite);
diff --git a/app/core/gimpgrouplayer.c b/app/core/gimpgrouplayer.c
index 122daad..a84ef64 100644
--- a/app/core/gimpgrouplayer.c
+++ b/app/core/gimpgrouplayer.c
@@ -90,7 +90,7 @@ static gboolean gimp_group_layer_get_expanded (GimpViewable *viewable)
static void gimp_group_layer_set_expanded (GimpViewable *viewable,
gboolean expanded);
-static gboolean gimp_group_layer_is_position_locked (const GimpItem *item);
+static gboolean gimp_group_layer_is_position_locked (GimpItem *item);
static GimpItem * gimp_group_layer_duplicate (GimpItem *item,
GType new_type);
static void gimp_group_layer_convert (GimpItem *item,
@@ -132,7 +132,7 @@ static void gimp_group_layer_transform (GimpItem *item,
GimpTransformResize clip_result,
GimpProgress *progress);
-static gint64 gimp_group_layer_estimate_memsize (const GimpDrawable *drawable,
+static gint64 gimp_group_layer_estimate_memsize (GimpDrawable *drawable,
GimpComponentType component_type,
gint width,
gint height);
@@ -414,7 +414,7 @@ gimp_group_layer_set_expanded (GimpViewable *viewable,
}
static gboolean
-gimp_group_layer_is_position_locked (const GimpItem *item)
+gimp_group_layer_is_position_locked (GimpItem *item)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (item);
GList *list;
@@ -811,10 +811,10 @@ gimp_group_layer_transform (GimpItem *item,
}
static gint64
-gimp_group_layer_estimate_memsize (const GimpDrawable *drawable,
- GimpComponentType component_type,
- gint width,
- gint height)
+gimp_group_layer_estimate_memsize (GimpDrawable *drawable,
+ GimpComponentType component_type,
+ gint width,
+ gint height)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (drawable);
GList *list;
diff --git a/app/core/gimpimage-colormap.c b/app/core/gimpimage-colormap.c
index d7af0d7..23a6617 100644
--- a/app/core/gimpimage-colormap.c
+++ b/app/core/gimpimage-colormap.c
@@ -139,7 +139,7 @@ gimp_image_colormap_free (GimpImage *image)
}
const Babl *
-gimp_image_colormap_get_rgb_format (const GimpImage *image)
+gimp_image_colormap_get_rgb_format (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -147,7 +147,7 @@ gimp_image_colormap_get_rgb_format (const GimpImage *image)
}
const Babl *
-gimp_image_colormap_get_rgba_format (const GimpImage *image)
+gimp_image_colormap_get_rgba_format (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -163,7 +163,7 @@ gimp_image_get_colormap_palette (GimpImage *image)
}
const guchar *
-gimp_image_get_colormap (const GimpImage *image)
+gimp_image_get_colormap (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -171,7 +171,7 @@ gimp_image_get_colormap (const GimpImage *image)
}
gint
-gimp_image_get_colormap_size (const GimpImage *image)
+gimp_image_get_colormap_size (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
diff --git a/app/core/gimpimage-colormap.h b/app/core/gimpimage-colormap.h
index e4c1cad..bbe6234 100644
--- a/app/core/gimpimage-colormap.h
+++ b/app/core/gimpimage-colormap.h
@@ -22,34 +22,34 @@
#define GIMP_IMAGE_COLORMAP_SIZE 768
-void gimp_image_colormap_init (GimpImage *image);
-void gimp_image_colormap_dispose (GimpImage *image);
-void gimp_image_colormap_free (GimpImage *image);
-
-const Babl * gimp_image_colormap_get_rgb_format (const GimpImage *image);
-const Babl * gimp_image_colormap_get_rgba_format (const GimpImage *image);
-
-GimpPalette * gimp_image_get_colormap_palette (GimpImage *image);
-
-const guchar * gimp_image_get_colormap (const GimpImage *image);
-gint gimp_image_get_colormap_size (const GimpImage *image);
-void gimp_image_set_colormap (GimpImage *image,
- const guchar *colormap,
- gint n_colors,
- gboolean push_undo);
-void gimp_image_unset_colormap (GimpImage *image,
- gboolean push_undo);
-
-void gimp_image_get_colormap_entry (GimpImage *image,
- gint color_index,
- GimpRGB *color);
-void gimp_image_set_colormap_entry (GimpImage *image,
- gint color_index,
- const GimpRGB *color,
- gboolean push_undo);
-
-void gimp_image_add_colormap_entry (GimpImage *image,
- const GimpRGB *color);
+void gimp_image_colormap_init (GimpImage *image);
+void gimp_image_colormap_dispose (GimpImage *image);
+void gimp_image_colormap_free (GimpImage *image);
+
+const Babl * gimp_image_colormap_get_rgb_format (GimpImage *image);
+const Babl * gimp_image_colormap_get_rgba_format (GimpImage *image);
+
+GimpPalette * gimp_image_get_colormap_palette (GimpImage *image);
+
+const guchar * gimp_image_get_colormap (GimpImage *image);
+gint gimp_image_get_colormap_size (GimpImage *image);
+void gimp_image_set_colormap (GimpImage *image,
+ const guchar *colormap,
+ gint n_colors,
+ gboolean push_undo);
+void gimp_image_unset_colormap (GimpImage *image,
+ gboolean push_undo);
+
+void gimp_image_get_colormap_entry (GimpImage *image,
+ gint color_index,
+ GimpRGB *color);
+void gimp_image_set_colormap_entry (GimpImage *image,
+ gint color_index,
+ const GimpRGB *color,
+ gboolean push_undo);
+
+void gimp_image_add_colormap_entry (GimpImage *image,
+ const GimpRGB *color);
#endif /* __GIMP_IMAGE_COLORMAP_H__ */
diff --git a/app/core/gimpimage-item-list.c b/app/core/gimpimage-item-list.c
index 43ba715..e3fef5e 100644
--- a/app/core/gimpimage-item-list.c
+++ b/app/core/gimpimage-item-list.c
@@ -223,7 +223,7 @@ gimp_image_item_list_transform (GimpImage *image,
* Return value: The list of items.
**/
GList *
-gimp_image_item_list_get_list (const GimpImage *image,
+gimp_image_item_list_get_list (GimpImage *image,
GimpItemTypeMask type,
GimpItemSet set)
{
diff --git a/app/core/gimpimage-item-list.h b/app/core/gimpimage-item-list.h
index 849f188..bd0f446 100644
--- a/app/core/gimpimage-item-list.h
+++ b/app/core/gimpimage-item-list.h
@@ -53,7 +53,7 @@ void gimp_image_item_list_transform (GimpImage *image,
GimpTransformResize clip_result,
GimpProgress *progress);
-GList * gimp_image_item_list_get_list (const GimpImage *image,
+GList * gimp_image_item_list_get_list (GimpImage *image,
GimpItemTypeMask type,
GimpItemSet set);
diff --git a/app/core/gimpimage-pick-layer.c b/app/core/gimpimage-pick-layer.c
index 74c9a20..e2d0bb0 100644
--- a/app/core/gimpimage-pick-layer.c
+++ b/app/core/gimpimage-pick-layer.c
@@ -31,9 +31,9 @@
GimpLayer *
-gimp_image_pick_layer (const GimpImage *image,
- gint x,
- gint y)
+gimp_image_pick_layer (GimpImage *image,
+ gint x,
+ gint y)
{
GList *all_layers;
GList *list;
@@ -64,9 +64,9 @@ gimp_image_pick_layer (const GimpImage *image,
}
GimpLayer *
-gimp_image_pick_layer_by_bounds (const GimpImage *image,
- gint x,
- gint y)
+gimp_image_pick_layer_by_bounds (GimpImage *image,
+ gint x,
+ gint y)
{
GList *all_layers;
GList *list;
@@ -106,9 +106,9 @@ gimp_image_pick_layer_by_bounds (const GimpImage *image,
}
GimpTextLayer *
-gimp_image_pick_text_layer (const GimpImage *image,
- gint x,
- gint y)
+gimp_image_pick_text_layer (GimpImage *image,
+ gint x,
+ gint y)
{
GList *all_layers;
GList *list;
diff --git a/app/core/gimpimage-pick-layer.h b/app/core/gimpimage-pick-layer.h
index 625a140..9601fed 100644
--- a/app/core/gimpimage-pick-layer.h
+++ b/app/core/gimpimage-pick-layer.h
@@ -19,15 +19,15 @@
#define __GIMP_IMAGE_PICK_LAYER_H__
-GimpLayer * gimp_image_pick_layer (const GimpImage *image,
- gint x,
- gint y);
-GimpLayer * gimp_image_pick_layer_by_bounds (const GimpImage *image,
- gint x,
- gint y);
-GimpTextLayer * gimp_image_pick_text_layer (const GimpImage *image,
- gint x,
- gint y);
+GimpLayer * gimp_image_pick_layer (GimpImage *image,
+ gint x,
+ gint y);
+GimpLayer * gimp_image_pick_layer_by_bounds (GimpImage *image,
+ gint x,
+ gint y);
+GimpTextLayer * gimp_image_pick_text_layer (GimpImage *image,
+ gint x,
+ gint y);
#endif /* __GIMP_IMAGE_PICK_LAYER_H__ */
diff --git a/app/core/gimpimage-quick-mask.c b/app/core/gimpimage-quick-mask.c
index a36a14f..e26352f 100644
--- a/app/core/gimpimage-quick-mask.c
+++ b/app/core/gimpimage-quick-mask.c
@@ -158,7 +158,7 @@ gimp_image_set_quick_mask_state (GimpImage *image,
}
gboolean
-gimp_image_get_quick_mask_state (const GimpImage *image)
+gimp_image_get_quick_mask_state (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@@ -182,8 +182,8 @@ gimp_image_set_quick_mask_color (GimpImage *image,
}
void
-gimp_image_get_quick_mask_color (const GimpImage *image,
- GimpRGB *color)
+gimp_image_get_quick_mask_color (GimpImage *image,
+ GimpRGB *color)
{
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (color != NULL);
@@ -192,7 +192,7 @@ gimp_image_get_quick_mask_color (const GimpImage *image,
}
GimpChannel *
-gimp_image_get_quick_mask (const GimpImage *image)
+gimp_image_get_quick_mask (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -220,7 +220,7 @@ gimp_image_quick_mask_invert (GimpImage *image)
}
gboolean
-gimp_image_get_quick_mask_inverted (const GimpImage *image)
+gimp_image_get_quick_mask_inverted (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
diff --git a/app/core/gimpimage-quick-mask.h b/app/core/gimpimage-quick-mask.h
index f0d05cd..07da7f1 100644
--- a/app/core/gimpimage-quick-mask.h
+++ b/app/core/gimpimage-quick-mask.h
@@ -25,19 +25,19 @@
#define GIMP_IMAGE_QUICK_MASK_NAME "Qmask"
-void gimp_image_set_quick_mask_state (GimpImage *image,
- gboolean active);
-gboolean gimp_image_get_quick_mask_state (const GimpImage *image);
+void gimp_image_set_quick_mask_state (GimpImage *image,
+ gboolean active);
+gboolean gimp_image_get_quick_mask_state (GimpImage *image);
-void gimp_image_set_quick_mask_color (GimpImage *image,
- const GimpRGB *color);
-void gimp_image_get_quick_mask_color (const GimpImage *image,
- GimpRGB *color);
+void gimp_image_set_quick_mask_color (GimpImage *image,
+ const GimpRGB *color);
+void gimp_image_get_quick_mask_color (GimpImage *image,
+ GimpRGB *color);
-GimpChannel * gimp_image_get_quick_mask (const GimpImage *image);
+GimpChannel * gimp_image_get_quick_mask (GimpImage *image);
-void gimp_image_quick_mask_invert (GimpImage *image);
-gboolean gimp_image_get_quick_mask_inverted (const GimpImage *image);
+void gimp_image_quick_mask_invert (GimpImage *image);
+gboolean gimp_image_get_quick_mask_inverted (GimpImage *image);
#endif /* __GIMP_IMAGE_QUICK_MASK_H__ */
diff --git a/app/core/gimpimage-scale.c b/app/core/gimpimage-scale.c
index 6a517a7..fa405b0 100644
--- a/app/core/gimpimage-scale.c
+++ b/app/core/gimpimage-scale.c
@@ -260,11 +260,11 @@ gimp_image_scale (GimpImage *image,
* exceed the maximum specified in the preferences.
**/
GimpImageScaleCheckType
-gimp_image_scale_check (const GimpImage *image,
- gint new_width,
- gint new_height,
- gint64 max_memsize,
- gint64 *new_memsize)
+gimp_image_scale_check (GimpImage *image,
+ gint new_width,
+ gint new_height,
+ gint64 max_memsize,
+ gint64 *new_memsize)
{
GList *all_layers;
GList *list;
diff --git a/app/core/gimpimage-scale.h b/app/core/gimpimage-scale.h
index 8797716..4c0a720 100644
--- a/app/core/gimpimage-scale.h
+++ b/app/core/gimpimage-scale.h
@@ -26,7 +26,7 @@ void gimp_image_scale (GimpImage *image,
GimpProgress *progress);
GimpImageScaleCheckType
- gimp_image_scale_check (const GimpImage *image,
+ gimp_image_scale_check (GimpImage *image,
gint new_width,
gint new_height,
gint64 max_memsize,
diff --git a/app/core/gimpimage-undo.c b/app/core/gimpimage-undo.c
index 79ab5e1..f1d5cb1 100644
--- a/app/core/gimpimage-undo.c
+++ b/app/core/gimpimage-undo.c
@@ -50,7 +50,7 @@ static GimpDirtyMask gimp_image_undo_dirty_from_type (GimpUndoType undo_type);
/* public functions */
gboolean
-gimp_image_undo_is_enabled (const GimpImage *image)
+gimp_image_undo_is_enabled (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@@ -217,7 +217,7 @@ gimp_image_strong_redo (GimpImage *image)
}
GimpUndoStack *
-gimp_image_get_undo_stack (const GimpImage *image)
+gimp_image_get_undo_stack (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -225,7 +225,7 @@ gimp_image_get_undo_stack (const GimpImage *image)
}
GimpUndoStack *
-gimp_image_get_redo_stack (const GimpImage *image)
+gimp_image_get_redo_stack (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -264,7 +264,7 @@ gimp_image_undo_free (GimpImage *image)
}
gint
-gimp_image_get_undo_group_count (const GimpImage *image)
+gimp_image_get_undo_group_count (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
diff --git a/app/core/gimpimage-undo.h b/app/core/gimpimage-undo.h
index a7527cd..a79b7c8 100644
--- a/app/core/gimpimage-undo.h
+++ b/app/core/gimpimage-undo.h
@@ -19,41 +19,41 @@
#define __GIMP_IMAGE__UNDO_H__
-gboolean gimp_image_undo_is_enabled (const GimpImage *image);
-gboolean gimp_image_undo_enable (GimpImage *image);
-gboolean gimp_image_undo_disable (GimpImage *image);
-gboolean gimp_image_undo_freeze (GimpImage *image);
-gboolean gimp_image_undo_thaw (GimpImage *image);
-
-gboolean gimp_image_undo (GimpImage *image);
-gboolean gimp_image_redo (GimpImage *image);
-
-gboolean gimp_image_strong_undo (GimpImage *image);
-gboolean gimp_image_strong_redo (GimpImage *image);
-
-GimpUndoStack * gimp_image_get_undo_stack (const GimpImage *image);
-GimpUndoStack * gimp_image_get_redo_stack (const GimpImage *image);
-
-void gimp_image_undo_free (GimpImage *image);
-
-gint gimp_image_get_undo_group_count (const GimpImage *image);
-gboolean gimp_image_undo_group_start (GimpImage *image,
- GimpUndoType undo_type,
- const gchar *name);
-gboolean gimp_image_undo_group_end (GimpImage *image);
-
-GimpUndo * gimp_image_undo_push (GimpImage *image,
- GType object_type,
- GimpUndoType undo_type,
- const gchar *name,
- GimpDirtyMask dirty_mask,
+gboolean gimp_image_undo_is_enabled (GimpImage *image);
+gboolean gimp_image_undo_enable (GimpImage *image);
+gboolean gimp_image_undo_disable (GimpImage *image);
+gboolean gimp_image_undo_freeze (GimpImage *image);
+gboolean gimp_image_undo_thaw (GimpImage *image);
+
+gboolean gimp_image_undo (GimpImage *image);
+gboolean gimp_image_redo (GimpImage *image);
+
+gboolean gimp_image_strong_undo (GimpImage *image);
+gboolean gimp_image_strong_redo (GimpImage *image);
+
+GimpUndoStack * gimp_image_get_undo_stack (GimpImage *image);
+GimpUndoStack * gimp_image_get_redo_stack (GimpImage *image);
+
+void gimp_image_undo_free (GimpImage *image);
+
+gint gimp_image_get_undo_group_count (GimpImage *image);
+gboolean gimp_image_undo_group_start (GimpImage *image,
+ GimpUndoType undo_type,
+ const gchar *name);
+gboolean gimp_image_undo_group_end (GimpImage *image);
+
+GimpUndo * gimp_image_undo_push (GimpImage *image,
+ GType object_type,
+ GimpUndoType undo_type,
+ const gchar *name,
+ GimpDirtyMask dirty_mask,
...) G_GNUC_NULL_TERMINATED;
-GimpUndo * gimp_image_undo_can_compress (GimpImage *image,
- GType object_type,
- GimpUndoType undo_type);
+GimpUndo * gimp_image_undo_can_compress (GimpImage *image,
+ GType object_type,
+ GimpUndoType undo_type);
-GimpUndo * gimp_image_undo_get_fadeable (GimpImage *image);
+GimpUndo * gimp_image_undo_get_fadeable (GimpImage *image);
#endif /* __GIMP_IMAGE__UNDO_H__ */
diff --git a/app/core/gimpimage.c b/app/core/gimpimage.c
index a6654e5..f8d22f0 100644
--- a/app/core/gimpimage.c
+++ b/app/core/gimpimage.c
@@ -1757,7 +1757,7 @@ gimp_image_new (Gimp *gimp,
}
gint64
-gimp_image_estimate_memsize (const GimpImage *image,
+gimp_image_estimate_memsize (GimpImage *image,
GimpComponentType component_type,
gint width,
gint height)
@@ -1832,7 +1832,7 @@ gimp_image_estimate_memsize (const GimpImage *image,
}
GimpImageBaseType
-gimp_image_get_base_type (const GimpImage *image)
+gimp_image_get_base_type (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
@@ -1840,7 +1840,7 @@ gimp_image_get_base_type (const GimpImage *image)
}
GimpComponentType
-gimp_image_get_component_type (const GimpImage *image)
+gimp_image_get_component_type (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
@@ -1848,7 +1848,7 @@ gimp_image_get_component_type (const GimpImage *image)
}
GimpPrecision
-gimp_image_get_precision (const GimpImage *image)
+gimp_image_get_precision (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
@@ -1856,7 +1856,7 @@ gimp_image_get_precision (const GimpImage *image)
}
const Babl *
-gimp_image_get_format (const GimpImage *image,
+gimp_image_get_format (GimpImage *image,
GimpImageBaseType base_type,
GimpPrecision precision,
gboolean with_alpha)
@@ -1883,8 +1883,8 @@ gimp_image_get_format (const GimpImage *image,
}
const Babl *
-gimp_image_get_layer_format (const GimpImage *image,
- gboolean with_alpha)
+gimp_image_get_layer_format (GimpImage *image,
+ gboolean with_alpha)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -1895,7 +1895,7 @@ gimp_image_get_layer_format (const GimpImage *image,
}
const Babl *
-gimp_image_get_channel_format (const GimpImage *image)
+gimp_image_get_channel_format (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -1905,7 +1905,7 @@ gimp_image_get_channel_format (const GimpImage *image)
}
const Babl *
-gimp_image_get_mask_format (const GimpImage *image)
+gimp_image_get_mask_format (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -1913,7 +1913,7 @@ gimp_image_get_mask_format (const GimpImage *image)
}
gint
-gimp_image_get_ID (const GimpImage *image)
+gimp_image_get_ID (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
@@ -1956,7 +1956,7 @@ gimp_image_set_file (GimpImage *image,
* Returns: A #GFile saying "Untitled" for newly created images.
**/
GFile *
-gimp_image_get_untitled_file (const GimpImage *image)
+gimp_image_get_untitled_file (GimpImage *image)
{
GimpImagePrivate *private;
@@ -1979,7 +1979,7 @@ gimp_image_get_untitled_file (const GimpImage *image)
* Returns: A #GFile.
**/
GFile *
-gimp_image_get_file_or_untitled (const GimpImage *image)
+gimp_image_get_file_or_untitled (GimpImage *image)
{
GFile *file;
@@ -2002,7 +2002,7 @@ gimp_image_get_file_or_untitled (const GimpImage *image)
* Returns: The file, or NULL.
**/
GFile *
-gimp_image_get_file (const GimpImage *image)
+gimp_image_get_file (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2017,7 +2017,7 @@ gimp_image_get_file (const GimpImage *image)
* been saved as XCF after it was imported.
**/
GFile *
-gimp_image_get_imported_file (const GimpImage *image)
+gimp_image_get_imported_file (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2032,7 +2032,7 @@ gimp_image_get_imported_file (const GimpImage *image)
* NULL if the image has never been exported.
**/
GFile *
-gimp_image_get_exported_file (const GimpImage *image)
+gimp_image_get_exported_file (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2046,7 +2046,7 @@ gimp_image_get_exported_file (const GimpImage *image)
* Returns: The URI of the last copy that was saved of this XCF file.
**/
GFile *
-gimp_image_get_save_a_copy_file (const GimpImage *image)
+gimp_image_get_save_a_copy_file (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2061,7 +2061,7 @@ gimp_image_get_save_a_copy_file (const GimpImage *image)
* that order of precedence.
**/
GFile *
-gimp_image_get_any_file (const GimpImage *image)
+gimp_image_get_any_file (GimpImage *image)
{
GFile *file;
@@ -2300,7 +2300,7 @@ gimp_image_set_load_proc (GimpImage *image,
}
GimpPlugInProcedure *
-gimp_image_get_load_proc (const GimpImage *image)
+gimp_image_get_load_proc (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2317,7 +2317,7 @@ gimp_image_set_save_proc (GimpImage *image,
}
GimpPlugInProcedure *
-gimp_image_get_save_proc (const GimpImage *image)
+gimp_image_get_save_proc (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2334,7 +2334,7 @@ gimp_image_set_export_proc (GimpImage *image,
}
GimpPlugInProcedure *
-gimp_image_get_export_proc (const GimpImage *image)
+gimp_image_get_export_proc (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2437,7 +2437,7 @@ gimp_image_set_xcf_compat_mode (GimpImage *image,
}
gboolean
-gimp_image_get_xcf_compat_mode (const GimpImage *image)
+gimp_image_get_xcf_compat_mode (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@@ -2479,9 +2479,9 @@ gimp_image_set_resolution (GimpImage *image,
}
void
-gimp_image_get_resolution (const GimpImage *image,
- gdouble *xresolution,
- gdouble *yresolution)
+gimp_image_get_resolution (GimpImage *image,
+ gdouble *xresolution,
+ gdouble *yresolution)
{
GimpImagePrivate *private;
@@ -2524,7 +2524,7 @@ gimp_image_set_unit (GimpImage *image,
}
GimpUnit
-gimp_image_get_unit (const GimpImage *image)
+gimp_image_get_unit (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_UNIT_INCH);
@@ -2540,7 +2540,7 @@ gimp_image_unit_changed (GimpImage *image)
}
gint
-gimp_image_get_width (const GimpImage *image)
+gimp_image_get_width (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
@@ -2548,7 +2548,7 @@ gimp_image_get_width (const GimpImage *image)
}
gint
-gimp_image_get_height (const GimpImage *image)
+gimp_image_get_height (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
@@ -2556,7 +2556,7 @@ gimp_image_get_height (const GimpImage *image)
}
gboolean
-gimp_image_has_alpha (const GimpImage *image)
+gimp_image_has_alpha (GimpImage *image)
{
GimpImagePrivate *private;
GimpLayer *layer;
@@ -2572,7 +2572,7 @@ gimp_image_has_alpha (const GimpImage *image)
}
gboolean
-gimp_image_is_empty (const GimpImage *image)
+gimp_image_is_empty (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), TRUE);
@@ -2599,7 +2599,7 @@ gimp_image_set_floating_selection (GimpImage *image,
}
GimpLayer *
-gimp_image_get_floating_selection (const GimpImage *image)
+gimp_image_get_floating_selection (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2615,7 +2615,7 @@ gimp_image_floating_selection_changed (GimpImage *image)
}
GimpChannel *
-gimp_image_get_mask (const GimpImage *image)
+gimp_image_get_mask (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2655,7 +2655,7 @@ gimp_image_take_mask (GimpImage *image,
/* image components */
const Babl *
-gimp_image_get_component_format (const GimpImage *image,
+gimp_image_get_component_format (GimpImage *image,
GimpChannelType channel)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -2696,7 +2696,7 @@ gimp_image_get_component_format (const GimpImage *image,
}
gint
-gimp_image_get_component_index (const GimpImage *image,
+gimp_image_get_component_index (GimpImage *image,
GimpChannelType channel)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), -1);
@@ -2750,7 +2750,7 @@ gimp_image_set_component_active (GimpImage *image,
}
gboolean
-gimp_image_get_component_active (const GimpImage *image,
+gimp_image_get_component_active (GimpImage *image,
GimpChannelType channel)
{
gint index = -1;
@@ -2766,8 +2766,8 @@ gimp_image_get_component_active (const GimpImage *image,
}
void
-gimp_image_get_active_array (const GimpImage *image,
- gboolean *components)
+gimp_image_get_active_array (GimpImage *image,
+ gboolean *components)
{
GimpImagePrivate *private;
gint i;
@@ -2782,7 +2782,7 @@ gimp_image_get_active_array (const GimpImage *image,
}
GimpComponentMask
-gimp_image_get_active_mask (const GimpImage *image)
+gimp_image_get_active_mask (GimpImage *image)
{
GimpImagePrivate *private;
GimpComponentMask mask = 0;
@@ -2853,7 +2853,7 @@ gimp_image_set_component_visible (GimpImage *image,
}
gboolean
-gimp_image_get_component_visible (const GimpImage *image,
+gimp_image_get_component_visible (GimpImage *image,
GimpChannelType channel)
{
gint index = -1;
@@ -2869,8 +2869,8 @@ gimp_image_get_component_visible (const GimpImage *image,
}
void
-gimp_image_get_visible_array (const GimpImage *image,
- gboolean *components)
+gimp_image_get_visible_array (GimpImage *image,
+ gboolean *components)
{
GimpImagePrivate *private;
gint i;
@@ -2885,7 +2885,7 @@ gimp_image_get_visible_array (const GimpImage *image,
}
GimpComponentMask
-gimp_image_get_visible_mask (const GimpImage *image)
+gimp_image_get_visible_mask (GimpImage *image)
{
GimpImagePrivate *private;
GimpComponentMask mask = 0;
@@ -3204,7 +3204,7 @@ gimp_image_export_clean_all (GimpImage *image)
* Returns: True if the image is dirty, false otherwise.
**/
gint
-gimp_image_is_dirty (const GimpImage *image)
+gimp_image_is_dirty (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@@ -3218,7 +3218,7 @@ gimp_image_is_dirty (const GimpImage *image)
* Returns: True if the image export is dirty, false otherwise.
**/
gboolean
-gimp_image_is_export_dirty (const GimpImage *image)
+gimp_image_is_export_dirty (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@@ -3226,7 +3226,7 @@ gimp_image_is_export_dirty (const GimpImage *image)
}
gint64
-gimp_image_get_dirty_time (const GimpImage *image)
+gimp_image_get_dirty_time (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
@@ -3285,7 +3285,7 @@ gimp_image_flush (GimpImage *image)
/* display / instance counters */
gint
-gimp_image_get_display_count (const GimpImage *image)
+gimp_image_get_display_count (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
@@ -3309,7 +3309,7 @@ gimp_image_dec_display_count (GimpImage *image)
}
gint
-gimp_image_get_instance_count (const GimpImage *image)
+gimp_image_get_instance_count (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
@@ -3328,8 +3328,8 @@ gimp_image_inc_instance_count (GimpImage *image)
/* parasites */
const GimpParasite *
-gimp_image_parasite_find (const GimpImage *image,
- const gchar *name)
+gimp_image_parasite_find (GimpImage *image,
+ const gchar *name)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -3346,8 +3346,8 @@ list_func (gchar *key,
}
gchar **
-gimp_image_parasite_list (const GimpImage *image,
- gint *count)
+gimp_image_parasite_list (GimpImage *image,
+ gint *count)
{
GimpImagePrivate *private;
gchar **list;
@@ -3586,7 +3586,7 @@ gimp_image_set_tattoo_state (GimpImage *image,
/* projection */
GimpProjection *
-gimp_image_get_projection (const GimpImage *image)
+gimp_image_get_projection (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -3597,7 +3597,7 @@ gimp_image_get_projection (const GimpImage *image)
/* layers / channels / vectors */
GimpItemTree *
-gimp_image_get_layer_tree (const GimpImage *image)
+gimp_image_get_layer_tree (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -3605,7 +3605,7 @@ gimp_image_get_layer_tree (const GimpImage *image)
}
GimpItemTree *
-gimp_image_get_channel_tree (const GimpImage *image)
+gimp_image_get_channel_tree (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -3613,7 +3613,7 @@ gimp_image_get_channel_tree (const GimpImage *image)
}
GimpItemTree *
-gimp_image_get_vectors_tree (const GimpImage *image)
+gimp_image_get_vectors_tree (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -3621,7 +3621,7 @@ gimp_image_get_vectors_tree (const GimpImage *image)
}
GimpContainer *
-gimp_image_get_layers (const GimpImage *image)
+gimp_image_get_layers (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -3629,7 +3629,7 @@ gimp_image_get_layers (const GimpImage *image)
}
GimpContainer *
-gimp_image_get_channels (const GimpImage *image)
+gimp_image_get_channels (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -3637,7 +3637,7 @@ gimp_image_get_channels (const GimpImage *image)
}
GimpContainer *
-gimp_image_get_vectors (const GimpImage *image)
+gimp_image_get_vectors (GimpImage *image)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
@@ -3645,7 +3645,7 @@ gimp_image_get_vectors (const GimpImage *image)
}
gint
-gimp_image_get_n_layers (const GimpImage *image)
+gimp_image_get_n_layers (GimpImage *image)
{
GimpItemStack *stack;
@@ -3657,7 +3657,7 @@ gimp_image_get_n_layers (const GimpImage *image)
}
gint
-gimp_image_get_n_channels (const GimpImage *image)
+gimp_image_get_n_channels (GimpImage *image)
{
GimpItemStack *stack;
@@ -3669,7 +3669,7 @@ gimp_image_get_n_channels (const GimpImage *image)
}
gint
-gimp_image_get_n_vectors (const GimpImage *image)
+gimp_image_get_n_vectors (GimpImage *image)
{
GimpItemStack *stack;
@@ -3681,7 +3681,7 @@ gimp_image_get_n_vectors (const GimpImage *image)
}
GList *
-gimp_image_get_layer_iter (const GimpImage *image)
+gimp_image_get_layer_iter (GimpImage *image)
{
GimpItemStack *stack;
@@ -3693,7 +3693,7 @@ gimp_image_get_layer_iter (const GimpImage *image)
}
GList *
-gimp_image_get_channel_iter (const GimpImage *image)
+gimp_image_get_channel_iter (GimpImage *image)
{
GimpItemStack *stack;
@@ -3705,7 +3705,7 @@ gimp_image_get_channel_iter (const GimpImage *image)
}
GList *
-gimp_image_get_vectors_iter (const GimpImage *image)
+gimp_image_get_vectors_iter (GimpImage *image)
{
GimpItemStack *stack;
@@ -3717,7 +3717,7 @@ gimp_image_get_vectors_iter (const GimpImage *image)
}
GList *
-gimp_image_get_layer_list (const GimpImage *image)
+gimp_image_get_layer_list (GimpImage *image)
{
GimpItemStack *stack;
@@ -3729,7 +3729,7 @@ gimp_image_get_layer_list (const GimpImage *image)
}
GList *
-gimp_image_get_channel_list (const GimpImage *image)
+gimp_image_get_channel_list (GimpImage *image)
{
GimpItemStack *stack;
@@ -3741,7 +3741,7 @@ gimp_image_get_channel_list (const GimpImage *image)
}
GList *
-gimp_image_get_vectors_list (const GimpImage *image)
+gimp_image_get_vectors_list (GimpImage *image)
{
GimpItemStack *stack;
@@ -3756,7 +3756,7 @@ gimp_image_get_vectors_list (const GimpImage *image)
/* active drawable, layer, channel, vectors */
GimpDrawable *
-gimp_image_get_active_drawable (const GimpImage *image)
+gimp_image_get_active_drawable (GimpImage *image)
{
GimpImagePrivate *private;
GimpItem *active_channel;
@@ -3791,7 +3791,7 @@ gimp_image_get_active_drawable (const GimpImage *image)
}
GimpLayer *
-gimp_image_get_active_layer (const GimpImage *image)
+gimp_image_get_active_layer (GimpImage *image)
{
GimpImagePrivate *private;
@@ -3803,7 +3803,7 @@ gimp_image_get_active_layer (const GimpImage *image)
}
GimpChannel *
-gimp_image_get_active_channel (const GimpImage *image)
+gimp_image_get_active_channel (GimpImage *image)
{
GimpImagePrivate *private;
@@ -3815,7 +3815,7 @@ gimp_image_get_active_channel (const GimpImage *image)
}
GimpVectors *
-gimp_image_get_active_vectors (const GimpImage *image)
+gimp_image_get_active_vectors (GimpImage *image)
{
GimpImagePrivate *private;
@@ -3940,8 +3940,8 @@ gimp_image_set_active_vectors (GimpImage *image,
/* layer, channel, vectors by tattoo */
GimpLayer *
-gimp_image_get_layer_by_tattoo (const GimpImage *image,
- GimpTattoo tattoo)
+gimp_image_get_layer_by_tattoo (GimpImage *image,
+ GimpTattoo tattoo)
{
GimpItemStack *stack;
@@ -3953,8 +3953,8 @@ gimp_image_get_layer_by_tattoo (const GimpImage *image,
}
GimpChannel *
-gimp_image_get_channel_by_tattoo (const GimpImage *image,
- GimpTattoo tattoo)
+gimp_image_get_channel_by_tattoo (GimpImage *image,
+ GimpTattoo tattoo)
{
GimpItemStack *stack;
@@ -3966,8 +3966,8 @@ gimp_image_get_channel_by_tattoo (const GimpImage *image,
}
GimpVectors *
-gimp_image_get_vectors_by_tattoo (const GimpImage *image,
- GimpTattoo tattoo)
+gimp_image_get_vectors_by_tattoo (GimpImage *image,
+ GimpTattoo tattoo)
{
GimpItemStack *stack;
@@ -3982,8 +3982,8 @@ gimp_image_get_vectors_by_tattoo (const GimpImage *image,
/* layer, channel, vectors by name */
GimpLayer *
-gimp_image_get_layer_by_name (const GimpImage *image,
- const gchar *name)
+gimp_image_get_layer_by_name (GimpImage *image,
+ const gchar *name)
{
GimpItemTree *tree;
@@ -3996,8 +3996,8 @@ gimp_image_get_layer_by_name (const GimpImage *image,
}
GimpChannel *
-gimp_image_get_channel_by_name (const GimpImage *image,
- const gchar *name)
+gimp_image_get_channel_by_name (GimpImage *image,
+ const gchar *name)
{
GimpItemTree *tree;
@@ -4010,8 +4010,8 @@ gimp_image_get_channel_by_name (const GimpImage *image,
}
GimpVectors *
-gimp_image_get_vectors_by_name (const GimpImage *image,
- const gchar *name)
+gimp_image_get_vectors_by_name (GimpImage *image,
+ const gchar *name)
{
GimpItemTree *tree;
diff --git a/app/core/gimpimage.h b/app/core/gimpimage.h
index 28d7554..aa543cf 100644
--- a/app/core/gimpimage.h
+++ b/app/core/gimpimage.h
@@ -110,35 +110,35 @@ GimpImage * gimp_image_new (Gimp *gimp,
GimpImageBaseType base_type,
GimpPrecision precision);
-gint64 gimp_image_estimate_memsize (const GimpImage *image,
+gint64 gimp_image_estimate_memsize (GimpImage *image,
GimpComponentType component_type,
gint width,
gint height);
-GimpImageBaseType gimp_image_get_base_type (const GimpImage *image);
-GimpComponentType gimp_image_get_component_type (const GimpImage *image);
-GimpPrecision gimp_image_get_precision (const GimpImage *image);
+GimpImageBaseType gimp_image_get_base_type (GimpImage *image);
+GimpComponentType gimp_image_get_component_type (GimpImage *image);
+GimpPrecision gimp_image_get_precision (GimpImage *image);
-const Babl * gimp_image_get_format (const GimpImage *image,
+const Babl * gimp_image_get_format (GimpImage *image,
GimpImageBaseType base_type,
GimpPrecision precision,
gboolean with_alpha);
-const Babl * gimp_image_get_layer_format (const GimpImage *image,
+const Babl * gimp_image_get_layer_format (GimpImage *image,
gboolean with_alpha);
-const Babl * gimp_image_get_channel_format (const GimpImage *image);
-const Babl * gimp_image_get_mask_format (const GimpImage *image);
+const Babl * gimp_image_get_channel_format (GimpImage *image);
+const Babl * gimp_image_get_mask_format (GimpImage *image);
-gint gimp_image_get_ID (const GimpImage *image);
+gint gimp_image_get_ID (GimpImage *image);
GimpImage * gimp_image_get_by_ID (Gimp *gimp,
gint id);
-GFile * gimp_image_get_file (const GimpImage *image);
-GFile * gimp_image_get_untitled_file (const GimpImage *image);
-GFile * gimp_image_get_file_or_untitled (const GimpImage *image);
-GFile * gimp_image_get_imported_file (const GimpImage *image);
-GFile * gimp_image_get_exported_file (const GimpImage *image);
-GFile * gimp_image_get_save_a_copy_file (const GimpImage *image);
-GFile * gimp_image_get_any_file (const GimpImage *image);
+GFile * gimp_image_get_file (GimpImage *image);
+GFile * gimp_image_get_untitled_file (GimpImage *image);
+GFile * gimp_image_get_file_or_untitled (GimpImage *image);
+GFile * gimp_image_get_imported_file (GimpImage *image);
+GFile * gimp_image_get_exported_file (GimpImage *image);
+GFile * gimp_image_get_save_a_copy_file (GimpImage *image);
+GFile * gimp_image_get_any_file (GimpImage *image);
void gimp_image_set_file (GimpImage *image,
GFile *file);
@@ -154,15 +154,15 @@ const gchar * gimp_image_get_display_path (GimpImage *image);
void gimp_image_set_load_proc (GimpImage *image,
GimpPlugInProcedure *proc);
-GimpPlugInProcedure * gimp_image_get_load_proc (const GimpImage *image);
+GimpPlugInProcedure * gimp_image_get_load_proc (GimpImage *image);
void gimp_image_set_save_proc (GimpImage *image,
GimpPlugInProcedure *proc);
-GimpPlugInProcedure * gimp_image_get_save_proc (const GimpImage *image);
+GimpPlugInProcedure * gimp_image_get_save_proc (GimpImage *image);
void gimp_image_saved (GimpImage *image,
GFile *file);
void gimp_image_set_export_proc (GimpImage *image,
GimpPlugInProcedure *proc);
-GimpPlugInProcedure * gimp_image_get_export_proc (const GimpImage *image);
+GimpPlugInProcedure * gimp_image_get_export_proc (GimpImage *image);
void gimp_image_exported (GimpImage *image,
GFile *file);
@@ -173,60 +173,60 @@ gint gimp_image_get_xcf_version (GimpImage *image,
void gimp_image_set_xcf_compat_mode (GimpImage *image,
gboolean compat_mode);
-gboolean gimp_image_get_xcf_compat_mode (const GimpImage *image);
+gboolean gimp_image_get_xcf_compat_mode (GimpImage *image);
void gimp_image_set_resolution (GimpImage *image,
gdouble xres,
gdouble yres);
-void gimp_image_get_resolution (const GimpImage *image,
+void gimp_image_get_resolution (GimpImage *image,
gdouble *xres,
gdouble *yres);
void gimp_image_resolution_changed (GimpImage *image);
void gimp_image_set_unit (GimpImage *image,
GimpUnit unit);
-GimpUnit gimp_image_get_unit (const GimpImage *image);
+GimpUnit gimp_image_get_unit (GimpImage *image);
void gimp_image_unit_changed (GimpImage *image);
-gint gimp_image_get_width (const GimpImage *image);
-gint gimp_image_get_height (const GimpImage *image);
+gint gimp_image_get_width (GimpImage *image);
+gint gimp_image_get_height (GimpImage *image);
-gboolean gimp_image_has_alpha (const GimpImage *image);
-gboolean gimp_image_is_empty (const GimpImage *image);
+gboolean gimp_image_has_alpha (GimpImage *image);
+gboolean gimp_image_is_empty (GimpImage *image);
void gimp_image_set_floating_selection (GimpImage *image,
GimpLayer *floating_sel);
-GimpLayer * gimp_image_get_floating_selection (const GimpImage *image);
+GimpLayer * gimp_image_get_floating_selection (GimpImage *image);
void gimp_image_floating_selection_changed (GimpImage *image);
-GimpChannel * gimp_image_get_mask (const GimpImage *image);
+GimpChannel * gimp_image_get_mask (GimpImage *image);
void gimp_image_mask_changed (GimpImage *image);
/* image components */
-const Babl * gimp_image_get_component_format (const GimpImage *image,
+const Babl * gimp_image_get_component_format (GimpImage *image,
GimpChannelType channel);
-gint gimp_image_get_component_index (const GimpImage *image,
+gint gimp_image_get_component_index (GimpImage *image,
GimpChannelType channel);
void gimp_image_set_component_active (GimpImage *image,
GimpChannelType type,
gboolean active);
-gboolean gimp_image_get_component_active (const GimpImage *image,
+gboolean gimp_image_get_component_active (GimpImage *image,
GimpChannelType type);
-void gimp_image_get_active_array (const GimpImage *image,
+void gimp_image_get_active_array (GimpImage *image,
gboolean *components);
-GimpComponentMask gimp_image_get_active_mask (const GimpImage *image);
+GimpComponentMask gimp_image_get_active_mask (GimpImage *image);
void gimp_image_set_component_visible (GimpImage *image,
GimpChannelType type,
gboolean visible);
-gboolean gimp_image_get_component_visible (const GimpImage *image,
+gboolean gimp_image_get_component_visible (GimpImage *image,
GimpChannelType type);
-void gimp_image_get_visible_array (const GimpImage *image,
+void gimp_image_get_visible_array (GimpImage *image,
gboolean *components);
-GimpComponentMask gimp_image_get_visible_mask (const GimpImage *image);
+GimpComponentMask gimp_image_get_visible_mask (GimpImage *image);
/* emitting image signals */
@@ -274,9 +274,9 @@ gint gimp_image_clean (GimpImage *image,
GimpDirtyMask dirty_mask);
void gimp_image_clean_all (GimpImage *image);
void gimp_image_export_clean_all (GimpImage *image);
-gint gimp_image_is_dirty (const GimpImage *image);
-gboolean gimp_image_is_export_dirty (const GimpImage *image);
-gint64 gimp_image_get_dirty_time (const GimpImage *image);
+gint gimp_image_is_dirty (GimpImage *image);
+gboolean gimp_image_is_export_dirty (GimpImage *image);
+gint64 gimp_image_get_dirty_time (GimpImage *image);
/* flush this image's displays */
@@ -286,23 +286,23 @@ void gimp_image_flush (GimpImage *image);
/* display / instance counters */
-gint gimp_image_get_display_count (const GimpImage *image);
+gint gimp_image_get_display_count (GimpImage *image);
void gimp_image_inc_display_count (GimpImage *image);
void gimp_image_dec_display_count (GimpImage *image);
-gint gimp_image_get_instance_count (const GimpImage *image);
+gint gimp_image_get_instance_count (GimpImage *image);
void gimp_image_inc_instance_count (GimpImage *image);
/* parasites */
-const GimpParasite * gimp_image_parasite_find (const GimpImage *image,
+const GimpParasite * gimp_image_parasite_find (GimpImage *image,
const gchar *name);
-gchar ** gimp_image_parasite_list (const GimpImage *image,
+gchar ** gimp_image_parasite_list (GimpImage *image,
gint *count);
-gboolean gimp_image_parasite_validate (GimpImage *image,
- const GimpParasite *parasite,
- GError **error);
+gboolean gimp_image_parasite_validate (GimpImage *image,
+ const GimpParasite *parasite,
+ GError **error);
void gimp_image_parasite_attach (GimpImage *image,
const GimpParasite *parasite);
void gimp_image_parasite_detach (GimpImage *image,
@@ -319,35 +319,35 @@ GimpTattoo gimp_image_get_tattoo_state (GimpImage *image);
/* projection */
-GimpProjection * gimp_image_get_projection (const GimpImage *image);
+GimpProjection * gimp_image_get_projection (GimpImage *image);
/* layers / channels / vectors */
-GimpItemTree * gimp_image_get_layer_tree (const GimpImage *image);
-GimpItemTree * gimp_image_get_channel_tree (const GimpImage *image);
-GimpItemTree * gimp_image_get_vectors_tree (const GimpImage *image);
+GimpItemTree * gimp_image_get_layer_tree (GimpImage *image);
+GimpItemTree * gimp_image_get_channel_tree (GimpImage *image);
+GimpItemTree * gimp_image_get_vectors_tree (GimpImage *image);
-GimpContainer * gimp_image_get_layers (const GimpImage *image);
-GimpContainer * gimp_image_get_channels (const GimpImage *image);
-GimpContainer * gimp_image_get_vectors (const GimpImage *image);
+GimpContainer * gimp_image_get_layers (GimpImage *image);
+GimpContainer * gimp_image_get_channels (GimpImage *image);
+GimpContainer * gimp_image_get_vectors (GimpImage *image);
-gint gimp_image_get_n_layers (const GimpImage *image);
-gint gimp_image_get_n_channels (const GimpImage *image);
-gint gimp_image_get_n_vectors (const GimpImage *image);
+gint gimp_image_get_n_layers (GimpImage *image);
+gint gimp_image_get_n_channels (GimpImage *image);
+gint gimp_image_get_n_vectors (GimpImage *image);
-GList * gimp_image_get_layer_iter (const GimpImage *image);
-GList * gimp_image_get_channel_iter (const GimpImage *image);
-GList * gimp_image_get_vectors_iter (const GimpImage *image);
+GList * gimp_image_get_layer_iter (GimpImage *image);
+GList * gimp_image_get_channel_iter (GimpImage *image);
+GList * gimp_image_get_vectors_iter (GimpImage *image);
-GList * gimp_image_get_layer_list (const GimpImage *image);
-GList * gimp_image_get_channel_list (const GimpImage *image);
-GList * gimp_image_get_vectors_list (const GimpImage *image);
+GList * gimp_image_get_layer_list (GimpImage *image);
+GList * gimp_image_get_channel_list (GimpImage *image);
+GList * gimp_image_get_vectors_list (GimpImage *image);
-GimpDrawable * gimp_image_get_active_drawable (const GimpImage *image);
-GimpLayer * gimp_image_get_active_layer (const GimpImage *image);
-GimpChannel * gimp_image_get_active_channel (const GimpImage *image);
-GimpVectors * gimp_image_get_active_vectors (const GimpImage *image);
+GimpDrawable * gimp_image_get_active_drawable (GimpImage *image);
+GimpLayer * gimp_image_get_active_layer (GimpImage *image);
+GimpChannel * gimp_image_get_active_channel (GimpImage *image);
+GimpVectors * gimp_image_get_active_vectors (GimpImage *image);
GimpLayer * gimp_image_set_active_layer (GimpImage *image,
GimpLayer *layer);
@@ -357,18 +357,18 @@ GimpChannel * gimp_image_unset_active_channel (GimpImage *image);
GimpVectors * gimp_image_set_active_vectors (GimpImage *image,
GimpVectors *vectors);
-GimpLayer * gimp_image_get_layer_by_tattoo (const GimpImage *image,
+GimpLayer * gimp_image_get_layer_by_tattoo (GimpImage *image,
GimpTattoo tattoo);
-GimpChannel * gimp_image_get_channel_by_tattoo (const GimpImage *image,
+GimpChannel * gimp_image_get_channel_by_tattoo (GimpImage *image,
GimpTattoo tattoo);
-GimpVectors * gimp_image_get_vectors_by_tattoo (const GimpImage *image,
+GimpVectors * gimp_image_get_vectors_by_tattoo (GimpImage *image,
GimpTattoo tattoo);
-GimpLayer * gimp_image_get_layer_by_name (const GimpImage *image,
+GimpLayer * gimp_image_get_layer_by_name (GimpImage *image,
const gchar *name);
-GimpChannel * gimp_image_get_channel_by_name (const GimpImage *image,
+GimpChannel * gimp_image_get_channel_by_name (GimpImage *image,
const gchar *name);
-GimpVectors * gimp_image_get_vectors_by_name (const GimpImage *image,
+GimpVectors * gimp_image_get_vectors_by_name (GimpImage *image,
const gchar *name);
gboolean gimp_image_reorder_item (GimpImage *image,
diff --git a/app/core/gimpitem-linked.c b/app/core/gimpitem-linked.c
index f3191ee..be525e0 100644
--- a/app/core/gimpitem-linked.c
+++ b/app/core/gimpitem-linked.c
@@ -37,7 +37,7 @@
/* public functions */
gboolean
-gimp_item_linked_is_locked (const GimpItem *item)
+gimp_item_linked_is_locked (GimpItem *item)
{
GList *list;
GList *l;
diff --git a/app/core/gimpitem-linked.h b/app/core/gimpitem-linked.h
index fc2106d..699d3ab 100644
--- a/app/core/gimpitem-linked.h
+++ b/app/core/gimpitem-linked.h
@@ -19,7 +19,7 @@
#define __GIMP_ITEM_LINKED_H__
-gboolean gimp_item_linked_is_locked (const GimpItem *item);
+gboolean gimp_item_linked_is_locked (GimpItem *item);
void gimp_item_linked_translate (GimpItem *item,
gint offset_x,
diff --git a/app/core/gimpitem.c b/app/core/gimpitem.c
index 047b5e4..6601515 100644
--- a/app/core/gimpitem.c
+++ b/app/core/gimpitem.c
@@ -118,8 +118,8 @@ static void gimp_item_get_property (GObject *object,
static gint64 gimp_item_get_memsize (GimpObject *object,
gint64 *gui_size);
-static gboolean gimp_item_real_is_content_locked (const GimpItem *item);
-static gboolean gimp_item_real_is_position_locked (const GimpItem *item);
+static gboolean gimp_item_real_is_content_locked (GimpItem *item);
+static gboolean gimp_item_real_is_position_locked (GimpItem *item);
static gboolean gimp_item_real_bounds (GimpItem *item,
gdouble *x,
gdouble *y,
@@ -438,7 +438,7 @@ gimp_item_get_memsize (GimpObject *object,
}
static gboolean
-gimp_item_real_is_content_locked (const GimpItem *item)
+gimp_item_real_is_content_locked (GimpItem *item)
{
GimpItem *parent = gimp_item_get_parent (item);
@@ -449,7 +449,7 @@ gimp_item_real_is_content_locked (const GimpItem *item)
}
static gboolean
-gimp_item_real_is_position_locked (const GimpItem *item)
+gimp_item_real_is_position_locked (GimpItem *item)
{
if (gimp_item_get_linked (item))
if (gimp_item_linked_is_locked (item))
@@ -709,7 +709,7 @@ gimp_item_removed (GimpItem *item)
* Returns: %TRUE if the 'removed' flag is set for @item, %FALSE otherwise.
*/
gboolean
-gimp_item_is_removed (const GimpItem *item)
+gimp_item_is_removed (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
@@ -751,7 +751,7 @@ gimp_item_unset_removed (GimpItem *item)
* Returns: %TRUE if the item is attached to an image, %FALSE otherwise.
*/
gboolean
-gimp_item_is_attached (const GimpItem *item)
+gimp_item_is_attached (GimpItem *item)
{
GimpItem *parent;
@@ -766,7 +766,7 @@ gimp_item_is_attached (const GimpItem *item)
}
GimpItem *
-gimp_item_get_parent (const GimpItem *item)
+gimp_item_get_parent (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), NULL);
@@ -1008,7 +1008,7 @@ gimp_item_rename (GimpItem *item,
* Returns: The width of the item.
*/
gint
-gimp_item_get_width (const GimpItem *item)
+gimp_item_get_width (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), -1);
@@ -1022,7 +1022,7 @@ gimp_item_get_width (const GimpItem *item)
* Returns: The height of the item.
*/
gint
-gimp_item_get_height (const GimpItem *item)
+gimp_item_get_height (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), -1);
@@ -1072,9 +1072,9 @@ gimp_item_set_size (GimpItem *item,
* Reveals the X and Y offsets of the item.
*/
void
-gimp_item_get_offset (const GimpItem *item,
- gint *offset_x,
- gint *offset_y)
+gimp_item_get_offset (GimpItem *item,
+ gint *offset_x,
+ gint *offset_y)
{
GimpItemPrivate *private;
@@ -1190,9 +1190,9 @@ gimp_item_translate (GimpItem *item,
* of this; otherwise, returns #TRUE.
**/
gboolean
-gimp_item_check_scaling (const GimpItem *item,
- gint new_width,
- gint new_height)
+gimp_item_check_scaling (GimpItem *item,
+ gint new_width,
+ gint new_height)
{
GimpImage *image;
gdouble img_scale_w;
@@ -1687,7 +1687,7 @@ gimp_item_get_by_ID (Gimp *gimp,
}
GimpTattoo
-gimp_item_get_tattoo (const GimpItem *item)
+gimp_item_get_tattoo (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), 0);
@@ -1704,7 +1704,7 @@ gimp_item_set_tattoo (GimpItem *item,
}
GimpImage *
-gimp_item_get_image (const GimpItem *item)
+gimp_item_get_image (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), NULL);
@@ -1858,7 +1858,7 @@ gimp_item_set_parasites (GimpItem *item,
* Return value: The @item's #GimpParasiteList.
**/
GimpParasiteList *
-gimp_item_get_parasites (const GimpItem *item)
+gimp_item_get_parasites (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), NULL);
@@ -1984,8 +1984,8 @@ gimp_item_parasite_detach (GimpItem *item,
}
const GimpParasite *
-gimp_item_parasite_find (const GimpItem *item,
- const gchar *name)
+gimp_item_parasite_find (GimpItem *item,
+ const gchar *name)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), NULL);
@@ -2001,8 +2001,8 @@ gimp_item_parasite_list_foreach_func (gchar *name,
}
gchar **
-gimp_item_parasite_list (const GimpItem *item,
- gint *count)
+gimp_item_parasite_list (GimpItem *item,
+ gint *count)
{
GimpItemPrivate *private;
gchar **list;
@@ -2048,7 +2048,7 @@ gimp_item_set_visible (GimpItem *item,
}
gboolean
-gimp_item_get_visible (const GimpItem *item)
+gimp_item_get_visible (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
@@ -2056,7 +2056,7 @@ gimp_item_get_visible (const GimpItem *item)
}
gboolean
-gimp_item_is_visible (const GimpItem *item)
+gimp_item_is_visible (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
@@ -2091,7 +2091,7 @@ gimp_item_set_linked (GimpItem *item,
}
gboolean
-gimp_item_get_linked (const GimpItem *item)
+gimp_item_get_linked (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
@@ -2129,7 +2129,7 @@ gimp_item_set_lock_content (GimpItem *item,
}
gboolean
-gimp_item_get_lock_content (const GimpItem *item)
+gimp_item_get_lock_content (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
@@ -2137,7 +2137,7 @@ gimp_item_get_lock_content (const GimpItem *item)
}
gboolean
-gimp_item_can_lock_content (const GimpItem *item)
+gimp_item_can_lock_content (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
@@ -2145,7 +2145,7 @@ gimp_item_can_lock_content (const GimpItem *item)
}
gboolean
-gimp_item_is_content_locked (const GimpItem *item)
+gimp_item_is_content_locked (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
@@ -2180,7 +2180,7 @@ gimp_item_set_lock_position (GimpItem *item,
}
gboolean
-gimp_item_get_lock_position (const GimpItem *item)
+gimp_item_get_lock_position (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
@@ -2188,7 +2188,7 @@ gimp_item_get_lock_position (const GimpItem *item)
}
gboolean
-gimp_item_can_lock_position (const GimpItem *item)
+gimp_item_can_lock_position (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
@@ -2199,7 +2199,7 @@ gimp_item_can_lock_position (const GimpItem *item)
}
gboolean
-gimp_item_is_position_locked (const GimpItem *item)
+gimp_item_is_position_locked (GimpItem *item)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
diff --git a/app/core/gimpitem.h b/app/core/gimpitem.h
index ce1f7d5..680671e 100644
--- a/app/core/gimpitem.h
+++ b/app/core/gimpitem.h
@@ -49,9 +49,9 @@ struct _GimpItemClass
/* virtual functions */
void (* unset_removed) (GimpItem *item);
- gboolean (* is_attached) (const GimpItem *item);
- gboolean (* is_content_locked) (const GimpItem *item);
- gboolean (* is_position_locked) (const GimpItem *item);
+ gboolean (* is_attached) (GimpItem *item);
+ gboolean (* is_content_locked) (GimpItem *item);
+ gboolean (* is_position_locked) (GimpItem *item);
GimpItemTree * (* get_tree) (GimpItem *item);
gboolean (* bounds) (GimpItem *item,
gdouble *x,
@@ -155,12 +155,12 @@ GimpItem * gimp_item_new (GType type,
gint height);
void gimp_item_removed (GimpItem *item);
-gboolean gimp_item_is_removed (const GimpItem *item);
+gboolean gimp_item_is_removed (GimpItem *item);
void gimp_item_unset_removed (GimpItem *item);
-gboolean gimp_item_is_attached (const GimpItem *item);
+gboolean gimp_item_is_attached (GimpItem *item);
-GimpItem * gimp_item_get_parent (const GimpItem *item);
+GimpItem * gimp_item_get_parent (GimpItem *item);
GimpItemTree * gimp_item_get_tree (GimpItem *item);
GimpContainer * gimp_item_get_container (GimpItem *item);
@@ -189,13 +189,13 @@ gboolean gimp_item_rename (GimpItem *item,
const gchar *new_name,
GError **error);
-gint gimp_item_get_width (const GimpItem *item);
-gint gimp_item_get_height (const GimpItem *item);
+gint gimp_item_get_width (GimpItem *item);
+gint gimp_item_get_height (GimpItem *item);
void gimp_item_set_size (GimpItem *item,
gint width,
gint height);
-void gimp_item_get_offset (const GimpItem *item,
+void gimp_item_get_offset (GimpItem *item,
gint *offset_x,
gint *offset_y);
void gimp_item_set_offset (GimpItem *item,
@@ -209,7 +209,7 @@ void gimp_item_translate (GimpItem *item,
gint offset_y,
gboolean push_undo);
-gboolean gimp_item_check_scaling (const GimpItem *item,
+gboolean gimp_item_check_scaling (GimpItem *item,
gint new_width,
gint new_height);
void gimp_item_scale (GimpItem *item,
@@ -288,11 +288,11 @@ gint gimp_item_get_ID (GimpItem *item);
GimpItem * gimp_item_get_by_ID (Gimp *gimp,
gint id);
-GimpTattoo gimp_item_get_tattoo (const GimpItem *item);
+GimpTattoo gimp_item_get_tattoo (GimpItem *item);
void gimp_item_set_tattoo (GimpItem *item,
GimpTattoo tattoo);
-GimpImage * gimp_item_get_image (const GimpItem *item);
+GimpImage * gimp_item_get_image (GimpItem *item);
void gimp_item_set_image (GimpItem *item,
GimpImage *image);
@@ -301,7 +301,7 @@ void gimp_item_replace_item (GimpItem *item,
void gimp_item_set_parasites (GimpItem *item,
GimpParasiteList *parasites);
-GimpParasiteList * gimp_item_get_parasites (const GimpItem *item);
+GimpParasiteList * gimp_item_get_parasites (GimpItem *item);
gboolean gimp_item_parasite_validate (GimpItem *item,
const GimpParasite *parasite,
@@ -312,35 +312,35 @@ void gimp_item_parasite_attach (GimpItem *item,
void gimp_item_parasite_detach (GimpItem *item,
const gchar *name,
gboolean push_undo);
-const GimpParasite * gimp_item_parasite_find (const GimpItem *item,
+const GimpParasite * gimp_item_parasite_find (GimpItem *item,
const gchar *name);
-gchar ** gimp_item_parasite_list (const GimpItem *item,
+gchar ** gimp_item_parasite_list (GimpItem *item,
gint *count);
void gimp_item_set_visible (GimpItem *item,
gboolean visible,
gboolean push_undo);
-gboolean gimp_item_get_visible (const GimpItem *item);
-gboolean gimp_item_is_visible (const GimpItem *item);
+gboolean gimp_item_get_visible (GimpItem *item);
+gboolean gimp_item_is_visible (GimpItem *item);
void gimp_item_set_linked (GimpItem *item,
gboolean linked,
gboolean push_undo);
-gboolean gimp_item_get_linked (const GimpItem *item);
+gboolean gimp_item_get_linked (GimpItem *item);
void gimp_item_set_lock_content (GimpItem *item,
gboolean lock_content,
gboolean push_undo);
-gboolean gimp_item_get_lock_content (const GimpItem *item);
-gboolean gimp_item_can_lock_content (const GimpItem *item);
-gboolean gimp_item_is_content_locked (const GimpItem *item);
+gboolean gimp_item_get_lock_content (GimpItem *item);
+gboolean gimp_item_can_lock_content (GimpItem *item);
+gboolean gimp_item_is_content_locked (GimpItem *item);
void gimp_item_set_lock_position (GimpItem *item,
gboolean lock_position,
gboolean push_undo);
-gboolean gimp_item_get_lock_position (const GimpItem *item);
-gboolean gimp_item_can_lock_position (const GimpItem *item);
-gboolean gimp_item_is_position_locked (const GimpItem *item);
+gboolean gimp_item_get_lock_position (GimpItem *item);
+gboolean gimp_item_can_lock_position (GimpItem *item);
+gboolean gimp_item_is_position_locked (GimpItem *item);
gboolean gimp_item_mask_bounds (GimpItem *item,
gint *x1,
diff --git a/app/core/gimplayer.c b/app/core/gimplayer.c
index ebbe011..f066d6a 100644
--- a/app/core/gimplayer.c
+++ b/app/core/gimplayer.c
@@ -106,7 +106,7 @@ static GeglNode * gimp_layer_get_node (GimpFilter *filter);
static void gimp_layer_removed (GimpItem *item);
static void gimp_layer_unset_removed (GimpItem *item);
-static gboolean gimp_layer_is_attached (const GimpItem *item);
+static gboolean gimp_layer_is_attached (GimpItem *item);
static GimpItemTree * gimp_layer_get_tree (GimpItem *item);
static GimpItem * gimp_layer_duplicate (GimpItem *item,
GType new_type);
@@ -160,7 +160,7 @@ static void gimp_layer_to_selection (GimpItem *item,
gdouble feather_radius_y);
static void gimp_layer_alpha_changed (GimpDrawable *drawable);
-static gint64 gimp_layer_estimate_memsize (const GimpDrawable *drawable,
+static gint64 gimp_layer_estimate_memsize (GimpDrawable *drawable,
GimpComponentType component_type,
gint width,
gint height);
@@ -175,10 +175,10 @@ static void gimp_layer_convert_type (GimpDrawable *drawable,
gboolean push_undo,
GimpProgress *progress);
static void gimp_layer_invalidate_boundary (GimpDrawable *drawable);
-static void gimp_layer_get_active_components (const GimpDrawable *drawable,
+static void gimp_layer_get_active_components (GimpDrawable *drawable,
gboolean *active);
static GimpComponentMask
- gimp_layer_get_active_mask (const GimpDrawable *drawable);
+ gimp_layer_get_active_mask (GimpDrawable *drawable);
static void gimp_layer_set_buffer (GimpDrawable *drawable,
gboolean push_undo,
const gchar *undo_desc,
@@ -708,7 +708,7 @@ gimp_layer_unset_removed (GimpItem *item)
}
static gboolean
-gimp_layer_is_attached (const GimpItem *item)
+gimp_layer_is_attached (GimpItem *item)
{
GimpImage *image = gimp_item_get_image (item);
@@ -1031,10 +1031,10 @@ gimp_layer_alpha_changed (GimpDrawable *drawable)
}
static gint64
-gimp_layer_estimate_memsize (const GimpDrawable *drawable,
- GimpComponentType component_type,
- gint width,
- gint height)
+gimp_layer_estimate_memsize (GimpDrawable *drawable,
+ GimpComponentType component_type,
+ gint width,
+ gint height)
{
GimpLayer *layer = GIMP_LAYER (drawable);
gint64 memsize = 0;
@@ -1153,8 +1153,8 @@ gimp_layer_invalidate_boundary (GimpDrawable *drawable)
}
static void
-gimp_layer_get_active_components (const GimpDrawable *drawable,
- gboolean *active)
+gimp_layer_get_active_components (GimpDrawable *drawable,
+ gboolean *active)
{
GimpLayer *layer = GIMP_LAYER (drawable);
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
@@ -1168,7 +1168,7 @@ gimp_layer_get_active_components (const GimpDrawable *drawable,
}
static GimpComponentMask
-gimp_layer_get_active_mask (const GimpDrawable *drawable)
+gimp_layer_get_active_mask (GimpDrawable *drawable)
{
GimpLayer *layer = GIMP_LAYER (drawable);
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
@@ -1277,7 +1277,7 @@ gimp_layer_get_parent (GimpLayer *layer)
}
GimpLayerMask *
-gimp_layer_get_mask (const GimpLayer *layer)
+gimp_layer_get_mask (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
@@ -1384,7 +1384,7 @@ gimp_layer_add_mask (GimpLayer *layer,
}
GimpLayerMask *
-gimp_layer_create_mask (const GimpLayer *layer,
+gimp_layer_create_mask (GimpLayer *layer,
GimpAddMaskType add_mask_type,
GimpChannel *channel)
{
@@ -1745,7 +1745,7 @@ gimp_layer_set_apply_mask (GimpLayer *layer,
}
gboolean
-gimp_layer_get_apply_mask (const GimpLayer *layer)
+gimp_layer_get_apply_mask (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
g_return_val_if_fail (layer->mask, FALSE);
@@ -1769,7 +1769,7 @@ gimp_layer_set_edit_mask (GimpLayer *layer,
}
gboolean
-gimp_layer_get_edit_mask (const GimpLayer *layer)
+gimp_layer_get_edit_mask (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
g_return_val_if_fail (layer->mask, FALSE);
@@ -1834,7 +1834,7 @@ gimp_layer_set_show_mask (GimpLayer *layer,
}
gboolean
-gimp_layer_get_show_mask (const GimpLayer *layer)
+gimp_layer_get_show_mask (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
g_return_val_if_fail (layer->mask, FALSE);
@@ -1935,7 +1935,7 @@ gimp_layer_resize_to_image (GimpLayer *layer,
/**********************/
GimpDrawable *
-gimp_layer_get_floating_sel_drawable (const GimpLayer *layer)
+gimp_layer_get_floating_sel_drawable (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
@@ -1971,7 +1971,7 @@ gimp_layer_set_floating_sel_drawable (GimpLayer *layer,
}
gboolean
-gimp_layer_is_floating_sel (const GimpLayer *layer)
+gimp_layer_is_floating_sel (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
@@ -2012,7 +2012,7 @@ gimp_layer_set_opacity (GimpLayer *layer,
}
gdouble
-gimp_layer_get_opacity (const GimpLayer *layer)
+gimp_layer_get_opacity (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), GIMP_OPACITY_OPAQUE);
@@ -2051,7 +2051,7 @@ gimp_layer_set_mode (GimpLayer *layer,
}
GimpLayerModeEffects
-gimp_layer_get_mode (const GimpLayer *layer)
+gimp_layer_get_mode (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), GIMP_NORMAL_MODE);
@@ -2085,7 +2085,7 @@ gimp_layer_set_lock_alpha (GimpLayer *layer,
}
gboolean
-gimp_layer_get_lock_alpha (const GimpLayer *layer)
+gimp_layer_get_lock_alpha (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
@@ -2093,7 +2093,7 @@ gimp_layer_get_lock_alpha (const GimpLayer *layer)
}
gboolean
-gimp_layer_can_lock_alpha (const GimpLayer *layer)
+gimp_layer_can_lock_alpha (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
diff --git a/app/core/gimplayer.h b/app/core/gimplayer.h
index db2f276..bc3d8ab 100644
--- a/app/core/gimplayer.h
+++ b/app/core/gimplayer.h
@@ -78,8 +78,8 @@ GType gimp_layer_get_type (void) G_GNUC_CONST;
GimpLayer * gimp_layer_get_parent (GimpLayer *layer);
-GimpLayerMask * gimp_layer_get_mask (const GimpLayer *layer);
-GimpLayerMask * gimp_layer_create_mask (const GimpLayer *layer,
+GimpLayerMask * gimp_layer_get_mask (GimpLayer *layer);
+GimpLayerMask * gimp_layer_create_mask (GimpLayer *layer,
GimpAddMaskType mask_type,
GimpChannel *channel);
GimpLayerMask * gimp_layer_add_mask (GimpLayer *layer,
@@ -93,16 +93,16 @@ void gimp_layer_apply_mask (GimpLayer *layer,
void gimp_layer_set_apply_mask (GimpLayer *layer,
gboolean apply,
gboolean push_undo);
-gboolean gimp_layer_get_apply_mask (const GimpLayer *layer);
+gboolean gimp_layer_get_apply_mask (GimpLayer *layer);
void gimp_layer_set_edit_mask (GimpLayer *layer,
gboolean edit);
-gboolean gimp_layer_get_edit_mask (const GimpLayer *layer);
+gboolean gimp_layer_get_edit_mask (GimpLayer *layer);
void gimp_layer_set_show_mask (GimpLayer *layer,
gboolean show,
gboolean push_undo);
-gboolean gimp_layer_get_show_mask (const GimpLayer *layer);
+gboolean gimp_layer_get_show_mask (GimpLayer *layer);
void gimp_layer_add_alpha (GimpLayer *layer);
void gimp_layer_flatten (GimpLayer *layer,
@@ -111,26 +111,26 @@ void gimp_layer_flatten (GimpLayer *layer,
void gimp_layer_resize_to_image (GimpLayer *layer,
GimpContext *context);
-GimpDrawable * gimp_layer_get_floating_sel_drawable (const GimpLayer *layer);
+GimpDrawable * gimp_layer_get_floating_sel_drawable (GimpLayer *layer);
void gimp_layer_set_floating_sel_drawable (GimpLayer *layer,
GimpDrawable *drawable);
-gboolean gimp_layer_is_floating_sel (const GimpLayer *layer);
+gboolean gimp_layer_is_floating_sel (GimpLayer *layer);
void gimp_layer_set_opacity (GimpLayer *layer,
gdouble opacity,
gboolean push_undo);
-gdouble gimp_layer_get_opacity (const GimpLayer *layer);
+gdouble gimp_layer_get_opacity (GimpLayer *layer);
void gimp_layer_set_mode (GimpLayer *layer,
GimpLayerModeEffects mode,
gboolean push_undo);
-GimpLayerModeEffects gimp_layer_get_mode (const GimpLayer *layer);
+GimpLayerModeEffects gimp_layer_get_mode (GimpLayer *layer);
void gimp_layer_set_lock_alpha (GimpLayer *layer,
gboolean lock_alpha,
gboolean push_undo);
-gboolean gimp_layer_get_lock_alpha (const GimpLayer *layer);
-gboolean gimp_layer_can_lock_alpha (const GimpLayer *layer);
+gboolean gimp_layer_get_lock_alpha (GimpLayer *layer);
+gboolean gimp_layer_can_lock_alpha (GimpLayer *layer);
#endif /* __GIMP_LAYER_H__ */
diff --git a/app/core/gimplayermask.c b/app/core/gimplayermask.c
index 435a60d..6141074 100644
--- a/app/core/gimplayermask.c
+++ b/app/core/gimplayermask.c
@@ -38,9 +38,9 @@
#include "gimp-intl.h"
-static gboolean gimp_layer_mask_is_attached (const GimpItem *item);
-static gboolean gimp_layer_mask_is_content_locked (const GimpItem *item);
-static gboolean gimp_layer_mask_is_position_locked (const GimpItem *item);
+static gboolean gimp_layer_mask_is_attached (GimpItem *item);
+static gboolean gimp_layer_mask_is_content_locked (GimpItem *item);
+static gboolean gimp_layer_mask_is_position_locked (GimpItem *item);
static GimpItemTree * gimp_layer_mask_get_tree (GimpItem *item);
static GimpItem * gimp_layer_mask_duplicate (GimpItem *item,
GType new_type);
@@ -94,7 +94,7 @@ gimp_layer_mask_init (GimpLayerMask *layer_mask)
}
static gboolean
-gimp_layer_mask_is_content_locked (const GimpItem *item)
+gimp_layer_mask_is_content_locked (GimpItem *item)
{
GimpLayerMask *mask = GIMP_LAYER_MASK (item);
GimpLayer *layer = gimp_layer_mask_get_layer (mask);
@@ -106,7 +106,7 @@ gimp_layer_mask_is_content_locked (const GimpItem *item)
}
static gboolean
-gimp_layer_mask_is_position_locked (const GimpItem *item)
+gimp_layer_mask_is_position_locked (GimpItem *item)
{
GimpLayerMask *mask = GIMP_LAYER_MASK (item);
GimpLayer *layer = gimp_layer_mask_get_layer (mask);
@@ -118,7 +118,7 @@ gimp_layer_mask_is_position_locked (const GimpItem *item)
}
static gboolean
-gimp_layer_mask_is_attached (const GimpItem *item)
+gimp_layer_mask_is_attached (GimpItem *item)
{
GimpLayerMask *mask = GIMP_LAYER_MASK (item);
GimpLayer *layer = gimp_layer_mask_get_layer (mask);
@@ -266,7 +266,7 @@ gimp_layer_mask_set_layer (GimpLayerMask *layer_mask,
}
GimpLayer *
-gimp_layer_mask_get_layer (const GimpLayerMask *layer_mask)
+gimp_layer_mask_get_layer (GimpLayerMask *layer_mask)
{
g_return_val_if_fail (GIMP_IS_LAYER_MASK (layer_mask), NULL);
diff --git a/app/core/gimplayermask.h b/app/core/gimplayermask.h
index 2fbed71..c5f6c60 100644
--- a/app/core/gimplayermask.h
+++ b/app/core/gimplayermask.h
@@ -49,19 +49,19 @@ struct _GimpLayerMaskClass
GType gimp_layer_mask_get_type (void) G_GNUC_CONST;
-GimpLayerMask * gimp_layer_mask_new (GimpImage *image,
- gint width,
- gint height,
- const gchar *name,
- const GimpRGB *color);
-GimpLayerMask * gimp_layer_mask_new_from_buffer (GeglBuffer *buffer,
- GimpImage *image,
- const gchar *name,
- const GimpRGB *color);
-
-void gimp_layer_mask_set_layer (GimpLayerMask *layer_mask,
- GimpLayer *layer);
-GimpLayer * gimp_layer_mask_get_layer (const GimpLayerMask *layer_mask);
+GimpLayerMask * gimp_layer_mask_new (GimpImage *image,
+ gint width,
+ gint height,
+ const gchar *name,
+ const GimpRGB *color);
+GimpLayerMask * gimp_layer_mask_new_from_buffer (GeglBuffer *buffer,
+ GimpImage *image,
+ const gchar *name,
+ const GimpRGB *color);
+
+void gimp_layer_mask_set_layer (GimpLayerMask *layer_mask,
+ GimpLayer *layer);
+GimpLayer * gimp_layer_mask_get_layer (GimpLayerMask *layer_mask);
#endif /* __GIMP_LAYER_MASK_H__ */
diff --git a/app/core/gimplist.c b/app/core/gimplist.c
index ddadc80..143c806 100644
--- a/app/core/gimplist.c
+++ b/app/core/gimplist.c
@@ -40,43 +40,43 @@ enum
};
-static void gimp_list_finalize (GObject *object);
-static void gimp_list_set_property (GObject *object,
- guint property_id,
- const GValue *value,
- GParamSpec *pspec);
-static void gimp_list_get_property (GObject *object,
- guint property_id,
- GValue *value,
- GParamSpec *pspec);
-
-static gint64 gimp_list_get_memsize (GimpObject *object,
- gint64 *gui_size);
-
-static void gimp_list_add (GimpContainer *container,
- GimpObject *object);
-static void gimp_list_remove (GimpContainer *container,
- GimpObject *object);
-static void gimp_list_reorder (GimpContainer *container,
- GimpObject *object,
- gint new_index);
-static void gimp_list_clear (GimpContainer *container);
-static gboolean gimp_list_have (const GimpContainer *container,
- const GimpObject *object);
-static void gimp_list_foreach (const GimpContainer *container,
- GFunc func,
- gpointer user_data);
-static GimpObject * gimp_list_get_child_by_name (const GimpContainer *container,
- const gchar *name);
-static GimpObject * gimp_list_get_child_by_index (const GimpContainer *container,
- gint index);
-static gint gimp_list_get_child_index (const GimpContainer *container,
- const GimpObject *object);
-
-static void gimp_list_uniquefy_name (GimpList *gimp_list,
- GimpObject *object);
-static void gimp_list_object_renamed (GimpObject *object,
- GimpList *list);
+static void gimp_list_finalize (GObject *object);
+static void gimp_list_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gimp_list_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+static gint64 gimp_list_get_memsize (GimpObject *object,
+ gint64 *gui_size);
+
+static void gimp_list_add (GimpContainer *container,
+ GimpObject *object);
+static void gimp_list_remove (GimpContainer *container,
+ GimpObject *object);
+static void gimp_list_reorder (GimpContainer *container,
+ GimpObject *object,
+ gint new_index);
+static void gimp_list_clear (GimpContainer *container);
+static gboolean gimp_list_have (GimpContainer *container,
+ GimpObject *object);
+static void gimp_list_foreach (GimpContainer *container,
+ GFunc func,
+ gpointer user_data);
+static GimpObject * gimp_list_get_child_by_name (GimpContainer *container,
+ const gchar *name);
+static GimpObject * gimp_list_get_child_by_index (GimpContainer *container,
+ gint index);
+static gint gimp_list_get_child_index (GimpContainer *container,
+ GimpObject *object);
+
+static void gimp_list_uniquefy_name (GimpList *gimp_list,
+ GimpObject *object);
+static void gimp_list_object_renamed (GimpObject *object,
+ GimpList *list);
G_DEFINE_TYPE (GimpList, gimp_list, GIMP_TYPE_CONTAINER)
@@ -308,8 +308,8 @@ gimp_list_clear (GimpContainer *container)
}
static gboolean
-gimp_list_have (const GimpContainer *container,
- const GimpObject *object)
+gimp_list_have (GimpContainer *container,
+ GimpObject *object)
{
GimpList *list = GIMP_LIST (container);
@@ -317,9 +317,9 @@ gimp_list_have (const GimpContainer *container,
}
static void
-gimp_list_foreach (const GimpContainer *container,
- GFunc func,
- gpointer user_data)
+gimp_list_foreach (GimpContainer *container,
+ GFunc func,
+ gpointer user_data)
{
GimpList *list = GIMP_LIST (container);
@@ -327,8 +327,8 @@ gimp_list_foreach (const GimpContainer *container,
}
static GimpObject *
-gimp_list_get_child_by_name (const GimpContainer *container,
- const gchar *name)
+gimp_list_get_child_by_name (GimpContainer *container,
+ const gchar *name)
{
GimpList *list = GIMP_LIST (container);
GList *glist;
@@ -345,8 +345,8 @@ gimp_list_get_child_by_name (const GimpContainer *container,
}
static GimpObject *
-gimp_list_get_child_by_index (const GimpContainer *container,
- gint index)
+gimp_list_get_child_by_index (GimpContainer *container,
+ gint index)
{
GimpList *list = GIMP_LIST (container);
@@ -354,8 +354,8 @@ gimp_list_get_child_by_index (const GimpContainer *container,
}
static gint
-gimp_list_get_child_index (const GimpContainer *container,
- const GimpObject *object)
+gimp_list_get_child_index (GimpContainer *container,
+ GimpObject *object)
{
GimpList *list = GIMP_LIST (container);
diff --git a/app/core/gimpparasitelist.c b/app/core/gimpparasitelist.c
index 1da08fa..27ffee3 100644
--- a/app/core/gimpparasitelist.c
+++ b/app/core/gimpparasitelist.c
@@ -292,7 +292,7 @@ gimp_parasite_list_new (void)
}
GimpParasiteList *
-gimp_parasite_list_copy (const GimpParasiteList *list)
+gimp_parasite_list_copy (GimpParasiteList *list)
{
GimpParasiteList *newlist;
diff --git a/app/core/gimpparasitelist.h b/app/core/gimpparasitelist.h
index e9833a5..526b1c7 100644
--- a/app/core/gimpparasitelist.h
+++ b/app/core/gimpparasitelist.h
@@ -52,7 +52,7 @@ struct _GimpParasiteListClass
GType gimp_parasite_list_get_type (void) G_GNUC_CONST;
GimpParasiteList * gimp_parasite_list_new (void);
-GimpParasiteList * gimp_parasite_list_copy (const GimpParasiteList *list);
+GimpParasiteList * gimp_parasite_list_copy (GimpParasiteList *list);
void gimp_parasite_list_add (GimpParasiteList *list,
const GimpParasite *parasite);
void gimp_parasite_list_remove (GimpParasiteList *list,
diff --git a/app/core/gimppattern.c b/app/core/gimppattern.c
index 817c680..98a1a73 100644
--- a/app/core/gimppattern.c
+++ b/app/core/gimppattern.c
@@ -266,7 +266,7 @@ gimp_pattern_get_standard (GimpContext *context)
}
GimpTempBuf *
-gimp_pattern_get_mask (const GimpPattern *pattern)
+gimp_pattern_get_mask (GimpPattern *pattern)
{
g_return_val_if_fail (GIMP_IS_PATTERN (pattern), NULL);
@@ -274,7 +274,7 @@ gimp_pattern_get_mask (const GimpPattern *pattern)
}
GeglBuffer *
-gimp_pattern_create_buffer (const GimpPattern *pattern)
+gimp_pattern_create_buffer (GimpPattern *pattern)
{
g_return_val_if_fail (GIMP_IS_PATTERN (pattern), NULL);
diff --git a/app/core/gimppattern.h b/app/core/gimppattern.h
index 9e6350c..efbf077 100644
--- a/app/core/gimppattern.h
+++ b/app/core/gimppattern.h
@@ -47,12 +47,12 @@ struct _GimpPatternClass
GType gimp_pattern_get_type (void) G_GNUC_CONST;
-GimpData * gimp_pattern_new (GimpContext *context,
- const gchar *name);
-GimpData * gimp_pattern_get_standard (GimpContext *context);
+GimpData * gimp_pattern_new (GimpContext *context,
+ const gchar *name);
+GimpData * gimp_pattern_get_standard (GimpContext *context);
-GimpTempBuf * gimp_pattern_get_mask (const GimpPattern *pattern);
-GeglBuffer * gimp_pattern_create_buffer (const GimpPattern *pattern);
+GimpTempBuf * gimp_pattern_get_mask (GimpPattern *pattern);
+GeglBuffer * gimp_pattern_create_buffer (GimpPattern *pattern);
#endif /* __GIMP_PATTERN_H__ */
diff --git a/app/core/gimpselection.c b/app/core/gimpselection.c
index 9fe6108..87a40fc 100644
--- a/app/core/gimpselection.c
+++ b/app/core/gimpselection.c
@@ -46,7 +46,7 @@
#include "gimp-intl.h"
-static gboolean gimp_selection_is_attached (const GimpItem *item);
+static gboolean gimp_selection_is_attached (GimpItem *item);
static GimpItemTree * gimp_selection_get_tree (GimpItem *item);
static void gimp_selection_translate (GimpItem *item,
gint offset_x,
@@ -203,7 +203,7 @@ gimp_selection_init (GimpSelection *selection)
}
static gboolean
-gimp_selection_is_attached (const GimpItem *item)
+gimp_selection_is_attached (GimpItem *item)
{
return (GIMP_IS_IMAGE (gimp_item_get_image (item)) &&
gimp_image_get_mask (gimp_item_get_image (item)) ==
diff --git a/app/core/gimptag.c b/app/core/gimptag.c
index 2682169..e732f92 100644
--- a/app/core/gimptag.c
+++ b/app/core/gimptag.c
@@ -213,8 +213,8 @@ gimp_tag_get_hash (GimpTag *tag)
* Return value: TRUE if tags are equal, FALSE otherwise.
**/
gboolean
-gimp_tag_equals (const GimpTag *tag,
- const GimpTag *other)
+gimp_tag_equals (GimpTag *tag,
+ GimpTag *other)
{
g_return_val_if_fail (GIMP_IS_TAG (tag), FALSE);
g_return_val_if_fail (GIMP_IS_TAG (other), FALSE);
diff --git a/app/core/gimptag.h b/app/core/gimptag.h
index af56482..98bd78b 100644
--- a/app/core/gimptag.h
+++ b/app/core/gimptag.h
@@ -52,29 +52,29 @@ struct _GimpTagClass
GType gimp_tag_get_type (void) G_GNUC_CONST;
-GimpTag * gimp_tag_new (const gchar *tag_string);
-GimpTag * gimp_tag_try_new (const gchar *tag_string);
-
-const gchar * gimp_tag_get_name (GimpTag *tag);
-guint gimp_tag_get_hash (GimpTag *tag);
-
-gboolean gimp_tag_get_internal (GimpTag *tag);
-void gimp_tag_set_internal (GimpTag *tag,
- gboolean internal);
-
-gboolean gimp_tag_equals (const GimpTag *tag,
- const GimpTag *other);
-gint gimp_tag_compare_func (const void *p1,
- const void *p2);
-gint gimp_tag_compare_with_string (GimpTag *tag,
- const gchar *tag_string);
-gboolean gimp_tag_has_prefix (GimpTag *tag,
- const gchar *prefix_string);
-gchar * gimp_tag_string_make_valid (const gchar *tag_string);
-gboolean gimp_tag_is_tag_separator (gunichar c);
-
-void gimp_tag_or_null_ref (GimpTag *tag_or_null);
-void gimp_tag_or_null_unref (GimpTag *tag_or_null);
+GimpTag * gimp_tag_new (const gchar *tag_string);
+GimpTag * gimp_tag_try_new (const gchar *tag_string);
+
+const gchar * gimp_tag_get_name (GimpTag *tag);
+guint gimp_tag_get_hash (GimpTag *tag);
+
+gboolean gimp_tag_get_internal (GimpTag *tag);
+void gimp_tag_set_internal (GimpTag *tag,
+ gboolean internal);
+
+gboolean gimp_tag_equals (GimpTag *tag,
+ GimpTag *other);
+gint gimp_tag_compare_func (const void *p1,
+ const void *p2);
+gint gimp_tag_compare_with_string (GimpTag *tag,
+ const gchar *tag_string);
+gboolean gimp_tag_has_prefix (GimpTag *tag,
+ const gchar *prefix_string);
+gchar * gimp_tag_string_make_valid (const gchar *tag_string);
+gboolean gimp_tag_is_tag_separator (gunichar c);
+
+void gimp_tag_or_null_ref (GimpTag *tag_or_null);
+void gimp_tag_or_null_unref (GimpTag *tag_or_null);
#endif /* __GIMP_TAG_H__ */
diff --git a/app/core/gimptoolinfo.c b/app/core/gimptoolinfo.c
index e36753c..d521600 100644
--- a/app/core/gimptoolinfo.c
+++ b/app/core/gimptoolinfo.c
@@ -218,8 +218,8 @@ gimp_tool_info_get_description (GimpViewable *viewable,
}
static gboolean
-gimp_tool_info_filter_preset (const GimpObject *object,
- gpointer user_data)
+gimp_tool_info_filter_preset (GimpObject *object,
+ gpointer user_data)
{
GimpToolPreset *preset = GIMP_TOOL_PRESET (object);
GimpToolInfo *tool_info = user_data;
diff --git a/app/dialogs/convert-indexed-dialog.c b/app/dialogs/convert-indexed-dialog.c
index 664d50e..d403ca9 100644
--- a/app/dialogs/convert-indexed-dialog.c
+++ b/app/dialogs/convert-indexed-dialog.c
@@ -63,16 +63,16 @@ typedef struct
} IndexedDialog;
-static void convert_dialog_response (GtkWidget *widget,
- gint response_id,
- IndexedDialog *dialog);
-static GtkWidget * convert_dialog_palette_box (IndexedDialog *dialog);
-static gboolean convert_dialog_palette_filter (const GimpObject *object,
- gpointer user_data);
-static void convert_dialog_palette_changed (GimpContext *context,
- GimpPalette *palette,
- IndexedDialog *dialog);
-static void convert_dialog_free (IndexedDialog *dialog);
+static void convert_dialog_response (GtkWidget *widget,
+ gint response_id,
+ IndexedDialog *dialog);
+static GtkWidget * convert_dialog_palette_box (IndexedDialog *dialog);
+static gboolean convert_dialog_palette_filter (GimpObject *object,
+ gpointer user_data);
+static void convert_dialog_palette_changed (GimpContext *context,
+ GimpPalette *palette,
+ IndexedDialog *dialog);
+static void convert_dialog_free (IndexedDialog *dialog);
/* defaults */
@@ -413,8 +413,8 @@ convert_dialog_palette_box (IndexedDialog *dialog)
}
static gboolean
-convert_dialog_palette_filter (const GimpObject *object,
- gpointer user_data)
+convert_dialog_palette_filter (GimpObject *object,
+ gpointer user_data)
{
GimpPalette *palette = GIMP_PALETTE (object);
diff --git a/app/display/gimpdisplayshell-transform.c b/app/display/gimpdisplayshell-transform.c
index bc08912..179bcae 100644
--- a/app/display/gimpdisplayshell-transform.c
+++ b/app/display/gimpdisplayshell-transform.c
@@ -45,9 +45,9 @@
* objects can be rendered at the correct points on the display.
**/
void
-gimp_display_shell_zoom_coords (const GimpDisplayShell *shell,
- const GimpCoords *image_coords,
- GimpCoords *display_coords)
+gimp_display_shell_zoom_coords (GimpDisplayShell *shell,
+ const GimpCoords *image_coords,
+ GimpCoords *display_coords)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (image_coords != NULL);
@@ -72,9 +72,9 @@ gimp_display_shell_zoom_coords (const GimpDisplayShell *shell,
* points on the display can be mapped to points in the image.
**/
void
-gimp_display_shell_unzoom_coords (const GimpDisplayShell *shell,
- const GimpCoords *display_coords,
- GimpCoords *image_coords)
+gimp_display_shell_unzoom_coords (GimpDisplayShell *shell,
+ const GimpCoords *display_coords,
+ GimpCoords *image_coords)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (display_coords != NULL);
@@ -100,11 +100,11 @@ gimp_display_shell_unzoom_coords (const GimpDisplayShell *shell,
* Zooms an image coordinate to a shell coordinate.
**/
void
-gimp_display_shell_zoom_xy (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gint *nx,
- gint *ny)
+gimp_display_shell_zoom_xy (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gint *nx,
+ gint *ny)
{
gint64 tx;
gint64 ty;
@@ -142,12 +142,12 @@ gimp_display_shell_zoom_xy (const GimpDisplayShell *shell,
* in the image.
**/
void
-gimp_display_shell_unzoom_xy (const GimpDisplayShell *shell,
- gint x,
- gint y,
- gint *nx,
- gint *ny,
- gboolean round)
+gimp_display_shell_unzoom_xy (GimpDisplayShell *shell,
+ gint x,
+ gint y,
+ gint *nx,
+ gint *ny,
+ gboolean round)
{
gint64 tx;
gint64 ty;
@@ -183,11 +183,11 @@ gimp_display_shell_unzoom_xy (const GimpDisplayShell *shell,
* coordinates.
**/
void
-gimp_display_shell_zoom_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny)
+gimp_display_shell_zoom_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (nx != NULL);
@@ -210,11 +210,11 @@ gimp_display_shell_zoom_xy_f (const GimpDisplayShell *shell,
* ints, and consequently there is no option related to rounding.
**/
void
-gimp_display_shell_unzoom_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny)
+gimp_display_shell_unzoom_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (nx != NULL);
@@ -235,12 +235,12 @@ gimp_display_shell_unzoom_xy_f (const GimpDisplayShell *shell,
* objects can be rendered at the correct points on the display.
**/
void
-gimp_display_shell_zoom_segments (const GimpDisplayShell *shell,
- const GimpBoundSeg *src_segs,
- GimpSegment *dest_segs,
- gint n_segs,
- gdouble offset_x,
- gdouble offset_y)
+gimp_display_shell_zoom_segments (GimpDisplayShell *shell,
+ const GimpBoundSeg *src_segs,
+ GimpSegment *dest_segs,
+ gint n_segs,
+ gdouble offset_x,
+ gdouble offset_y)
{
gint i;
@@ -274,9 +274,9 @@ gimp_display_shell_zoom_segments (const GimpDisplayShell *shell,
* on the display.
**/
void
-gimp_display_shell_rotate_coords (const GimpDisplayShell *shell,
- const GimpCoords *unrotated_coords,
- GimpCoords *rotated_coords)
+gimp_display_shell_rotate_coords (GimpDisplayShell *shell,
+ const GimpCoords *unrotated_coords,
+ GimpCoords *rotated_coords)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (unrotated_coords != NULL);
@@ -299,9 +299,9 @@ gimp_display_shell_rotate_coords (const GimpDisplayShell *shell,
* Rotates from rotated display coordinates to unrotated display coordinates.
**/
void
-gimp_display_shell_unrotate_coords (const GimpDisplayShell *shell,
- const GimpCoords *rotated_coords,
- GimpCoords *unrotated_coords)
+gimp_display_shell_unrotate_coords (GimpDisplayShell *shell,
+ const GimpCoords *rotated_coords,
+ GimpCoords *unrotated_coords)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (rotated_coords != NULL);
@@ -326,11 +326,11 @@ gimp_display_shell_unrotate_coords (const GimpDisplayShell *shell,
* Rotates an unrotated display coordinate to a rotated shell coordinate.
**/
void
-gimp_display_shell_rotate_xy (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gint *nx,
- gint *ny)
+gimp_display_shell_rotate_xy (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gint *nx,
+ gint *ny)
{
gint64 tx;
gint64 ty;
@@ -365,11 +365,11 @@ gimp_display_shell_rotate_xy (const GimpDisplayShell *shell,
* coordinates.
**/
void
-gimp_display_shell_unrotate_xy (const GimpDisplayShell *shell,
- gint x,
- gint y,
- gint *nx,
- gint *ny)
+gimp_display_shell_unrotate_xy (GimpDisplayShell *shell,
+ gint x,
+ gint y,
+ gint *nx,
+ gint *ny)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (nx != NULL);
@@ -404,11 +404,11 @@ gimp_display_shell_unrotate_xy (const GimpDisplayShell *shell,
* coordinates.
**/
void
-gimp_display_shell_rotate_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny)
+gimp_display_shell_rotate_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (nx != NULL);
@@ -434,11 +434,11 @@ gimp_display_shell_rotate_xy_f (const GimpDisplayShell *shell,
* than ints.
**/
void
-gimp_display_shell_unrotate_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny)
+gimp_display_shell_unrotate_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (nx != NULL);
@@ -548,9 +548,9 @@ gimp_display_shell_unrotate_bounds (GimpDisplayShell *shell,
* objects can be rendered at the correct points on the display.
**/
void
-gimp_display_shell_transform_coords (const GimpDisplayShell *shell,
- const GimpCoords *image_coords,
- GimpCoords *display_coords)
+gimp_display_shell_transform_coords (GimpDisplayShell *shell,
+ const GimpCoords *image_coords,
+ GimpCoords *display_coords)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (image_coords != NULL);
@@ -580,9 +580,9 @@ gimp_display_shell_transform_coords (const GimpDisplayShell *shell,
* points on the display can be mapped to points in the image.
**/
void
-gimp_display_shell_untransform_coords (const GimpDisplayShell *shell,
- const GimpCoords *display_coords,
- GimpCoords *image_coords)
+gimp_display_shell_untransform_coords (GimpDisplayShell *shell,
+ const GimpCoords *display_coords,
+ GimpCoords *image_coords)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (display_coords != NULL);
@@ -617,11 +617,11 @@ gimp_display_shell_untransform_coords (const GimpDisplayShell *shell,
* Transforms an image coordinate to a shell coordinate.
**/
void
-gimp_display_shell_transform_xy (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gint *nx,
- gint *ny)
+gimp_display_shell_transform_xy (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gint *nx,
+ gint *ny)
{
gint64 tx;
gint64 ty;
@@ -670,12 +670,12 @@ gimp_display_shell_transform_xy (const GimpDisplayShell *shell,
* in the image.
**/
void
-gimp_display_shell_untransform_xy (const GimpDisplayShell *shell,
- gint x,
- gint y,
- gint *nx,
- gint *ny,
- gboolean round)
+gimp_display_shell_untransform_xy (GimpDisplayShell *shell,
+ gint x,
+ gint y,
+ gint *nx,
+ gint *ny,
+ gboolean round)
{
gint64 tx;
gint64 ty;
@@ -722,11 +722,11 @@ gimp_display_shell_untransform_xy (const GimpDisplayShell *shell,
* coordinates.
**/
void
-gimp_display_shell_transform_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny)
+gimp_display_shell_transform_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (nx != NULL);
@@ -752,11 +752,11 @@ gimp_display_shell_transform_xy_f (const GimpDisplayShell *shell,
* ints, and consequently there is no option related to rounding.
**/
void
-gimp_display_shell_untransform_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny)
+gimp_display_shell_untransform_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (nx != NULL);
@@ -770,15 +770,15 @@ gimp_display_shell_untransform_xy_f (const GimpDisplayShell *shell,
}
void
-gimp_display_shell_transform_bounds (const GimpDisplayShell *shell,
- gdouble x1,
- gdouble y1,
- gdouble x2,
- gdouble y2,
- gdouble *nx1,
- gdouble *ny1,
- gdouble *nx2,
- gdouble *ny2)
+gimp_display_shell_transform_bounds (GimpDisplayShell *shell,
+ gdouble x1,
+ gdouble y1,
+ gdouble x2,
+ gdouble y2,
+ gdouble *nx1,
+ gdouble *ny1,
+ gdouble *nx2,
+ gdouble *ny2)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (nx1 != NULL);
@@ -811,15 +811,15 @@ gimp_display_shell_transform_bounds (const GimpDisplayShell *shell,
}
void
-gimp_display_shell_untransform_bounds (const GimpDisplayShell *shell,
- gdouble x1,
- gdouble y1,
- gdouble x2,
- gdouble y2,
- gdouble *nx1,
- gdouble *ny1,
- gdouble *nx2,
- gdouble *ny2)
+gimp_display_shell_untransform_bounds (GimpDisplayShell *shell,
+ gdouble x1,
+ gdouble y1,
+ gdouble x2,
+ gdouble y2,
+ gdouble *nx1,
+ gdouble *ny1,
+ gdouble *nx2,
+ gdouble *ny2)
{
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (nx1 != NULL);
@@ -863,11 +863,11 @@ gimp_display_shell_untransform_bounds (const GimpDisplayShell *shell,
* that corresponds to the display viewport.
**/
void
-gimp_display_shell_untransform_viewport (const GimpDisplayShell *shell,
- gint *x,
- gint *y,
- gint *width,
- gint *height)
+gimp_display_shell_untransform_viewport (GimpDisplayShell *shell,
+ gint *x,
+ gint *y,
+ gint *width,
+ gint *height)
{
GimpImage *image;
gint x1, y1, x2, y2;
diff --git a/app/display/gimpdisplayshell-transform.h b/app/display/gimpdisplayshell-transform.h
index d263cbd..8d5bd6b 100644
--- a/app/display/gimpdisplayshell-transform.h
+++ b/app/display/gimpdisplayshell-transform.h
@@ -23,95 +23,95 @@
* space and back, taking into account scroll offset and scale
*/
-void gimp_display_shell_zoom_coords (const GimpDisplayShell *shell,
- const GimpCoords *image_coords,
- GimpCoords *display_coords);
-void gimp_display_shell_unzoom_coords (const GimpDisplayShell *shell,
- const GimpCoords *display_coords,
- GimpCoords *image_coords);
-
-void gimp_display_shell_zoom_xy (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gint *nx,
- gint *ny);
-void gimp_display_shell_unzoom_xy (const GimpDisplayShell *shell,
- gint x,
- gint y,
- gint *nx,
- gint *ny,
- gboolean round);
-
-void gimp_display_shell_zoom_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny);
-void gimp_display_shell_unzoom_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny);
-
-void gimp_display_shell_zoom_segments (const GimpDisplayShell *shell,
- const GimpBoundSeg *src_segs,
- GimpSegment *dest_segs,
- gint n_segs,
- gdouble offset_x,
- gdouble offset_y);
+void gimp_display_shell_zoom_coords (GimpDisplayShell *shell,
+ const GimpCoords *image_coords,
+ GimpCoords *display_coords);
+void gimp_display_shell_unzoom_coords (GimpDisplayShell *shell,
+ const GimpCoords *display_coords,
+ GimpCoords *image_coords);
+
+void gimp_display_shell_zoom_xy (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gint *nx,
+ gint *ny);
+void gimp_display_shell_unzoom_xy (GimpDisplayShell *shell,
+ gint x,
+ gint y,
+ gint *nx,
+ gint *ny,
+ gboolean round);
+
+void gimp_display_shell_zoom_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny);
+void gimp_display_shell_unzoom_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny);
+
+void gimp_display_shell_zoom_segments (GimpDisplayShell *shell,
+ const GimpBoundSeg *src_segs,
+ GimpSegment *dest_segs,
+ gint n_segs,
+ gdouble offset_x,
+ gdouble offset_y);
/* rotate: functions to transform from unrotated and unflipped but
* zoomed display space to rotated and filpped display space and back
*/
-void gimp_display_shell_rotate_coords (const GimpDisplayShell *shell,
- const GimpCoords *image_coords,
- GimpCoords *display_coords);
-void gimp_display_shell_unrotate_coords (const GimpDisplayShell *shell,
- const GimpCoords *display_coords,
- GimpCoords *image_coords);
-
-void gimp_display_shell_rotate_xy (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gint *nx,
- gint *ny);
-void gimp_display_shell_unrotate_xy (const GimpDisplayShell *shell,
- gint x,
- gint y,
- gint *nx,
- gint *ny);
-
-void gimp_display_shell_rotate_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny);
-void gimp_display_shell_unrotate_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny);
-
-void gimp_display_shell_rotate_bounds (GimpDisplayShell *shell,
- gdouble x1,
- gdouble y1,
- gdouble x2,
- gdouble y2,
- gdouble *nx1,
- gdouble *ny1,
- gdouble *nx2,
- gdouble *ny2);
-void gimp_display_shell_unrotate_bounds (GimpDisplayShell *shell,
- gdouble x1,
- gdouble y1,
- gdouble x2,
- gdouble y2,
- gdouble *nx1,
- gdouble *ny1,
- gdouble *nx2,
- gdouble *ny2);
+void gimp_display_shell_rotate_coords (GimpDisplayShell *shell,
+ const GimpCoords *image_coords,
+ GimpCoords *display_coords);
+void gimp_display_shell_unrotate_coords (GimpDisplayShell *shell,
+ const GimpCoords *display_coords,
+ GimpCoords *image_coords);
+
+void gimp_display_shell_rotate_xy (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gint *nx,
+ gint *ny);
+void gimp_display_shell_unrotate_xy (GimpDisplayShell *shell,
+ gint x,
+ gint y,
+ gint *nx,
+ gint *ny);
+
+void gimp_display_shell_rotate_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny);
+void gimp_display_shell_unrotate_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny);
+
+void gimp_display_shell_rotate_bounds (GimpDisplayShell *shell,
+ gdouble x1,
+ gdouble y1,
+ gdouble x2,
+ gdouble y2,
+ gdouble *nx1,
+ gdouble *ny1,
+ gdouble *nx2,
+ gdouble *ny2);
+void gimp_display_shell_unrotate_bounds (GimpDisplayShell *shell,
+ gdouble x1,
+ gdouble y1,
+ gdouble x2,
+ gdouble y2,
+ gdouble *nx1,
+ gdouble *ny1,
+ gdouble *nx2,
+ gdouble *ny2);
/* transform: functions to transform from image space to rotated
@@ -119,60 +119,60 @@ void gimp_display_shell_unrotate_bounds (GimpDisplayShell *shell,
* rotation and flipping
*/
-void gimp_display_shell_transform_coords (const GimpDisplayShell *shell,
- const GimpCoords *image_coords,
- GimpCoords *display_coords);
-void gimp_display_shell_untransform_coords (const GimpDisplayShell *shell,
- const GimpCoords *display_coords,
- GimpCoords *image_coords);
-
-void gimp_display_shell_transform_xy (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gint *nx,
- gint *ny);
-void gimp_display_shell_untransform_xy (const GimpDisplayShell *shell,
- gint x,
- gint y,
- gint *nx,
- gint *ny,
- gboolean round);
-
-void gimp_display_shell_transform_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny);
-void gimp_display_shell_untransform_xy_f (const GimpDisplayShell *shell,
- gdouble x,
- gdouble y,
- gdouble *nx,
- gdouble *ny);
-
-void gimp_display_shell_transform_bounds (const GimpDisplayShell *shell,
- gdouble x1,
- gdouble y1,
- gdouble x2,
- gdouble y2,
- gdouble *nx1,
- gdouble *ny1,
- gdouble *nx2,
- gdouble *ny2);
-void gimp_display_shell_untransform_bounds (const GimpDisplayShell *shell,
- gdouble x1,
- gdouble y1,
- gdouble x2,
- gdouble y2,
- gdouble *nx1,
- gdouble *ny1,
- gdouble *nx2,
- gdouble *ny2);
-
-void gimp_display_shell_untransform_viewport (const GimpDisplayShell *shell,
- gint *x,
- gint *y,
- gint *width,
- gint *height);
+void gimp_display_shell_transform_coords (GimpDisplayShell *shell,
+ const GimpCoords *image_coords,
+ GimpCoords *display_coords);
+void gimp_display_shell_untransform_coords (GimpDisplayShell *shell,
+ const GimpCoords *display_coords,
+ GimpCoords *image_coords);
+
+void gimp_display_shell_transform_xy (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gint *nx,
+ gint *ny);
+void gimp_display_shell_untransform_xy (GimpDisplayShell *shell,
+ gint x,
+ gint y,
+ gint *nx,
+ gint *ny,
+ gboolean round);
+
+void gimp_display_shell_transform_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny);
+void gimp_display_shell_untransform_xy_f (GimpDisplayShell *shell,
+ gdouble x,
+ gdouble y,
+ gdouble *nx,
+ gdouble *ny);
+
+void gimp_display_shell_transform_bounds (GimpDisplayShell *shell,
+ gdouble x1,
+ gdouble y1,
+ gdouble x2,
+ gdouble y2,
+ gdouble *nx1,
+ gdouble *ny1,
+ gdouble *nx2,
+ gdouble *ny2);
+void gimp_display_shell_untransform_bounds (GimpDisplayShell *shell,
+ gdouble x1,
+ gdouble y1,
+ gdouble x2,
+ gdouble y2,
+ gdouble *nx1,
+ gdouble *ny1,
+ gdouble *nx2,
+ gdouble *ny2);
+
+void gimp_display_shell_untransform_viewport (GimpDisplayShell *shell,
+ gint *x,
+ gint *y,
+ gint *width,
+ gint *height);
#endif /* __GIMP_DISPLAY_SHELL_TRANSFORM_H__ */
diff --git a/app/file/file-open.c b/app/file/file-open.c
index 6484f73..e9ca68d 100644
--- a/app/file/file-open.c
+++ b/app/file/file-open.c
@@ -61,7 +61,7 @@ static void file_open_sanitize_image (GimpImage *image,
static void file_open_convert_items (GimpImage *dest_image,
const gchar *basename,
GList *items);
-static GList * file_open_get_layers (const GimpImage *image,
+static GList * file_open_get_layers (GimpImage *image,
gboolean merge_visible,
gint *n_visible);
static gboolean file_open_file_proc_is_import (GimpPlugInProcedure *file_proc);
@@ -761,9 +761,9 @@ file_open_convert_items (GimpImage *dest_image,
}
static GList *
-file_open_get_layers (const GimpImage *image,
- gboolean merge_visible,
- gint *n_visible)
+file_open_get_layers (GimpImage *image,
+ gboolean merge_visible,
+ gint *n_visible)
{
GList *iter = NULL;
GList *layers = NULL;
diff --git a/app/plug-in/gimppluginprocedure.c b/app/plug-in/gimppluginprocedure.c
index da7886d..ad8214e 100644
--- a/app/plug-in/gimppluginprocedure.c
+++ b/app/plug-in/gimppluginprocedure.c
@@ -83,7 +83,7 @@ static void gimp_plug_in_procedure_execute_async (GimpProcedure *procedur
GimpValueArray *args,
GimpObject *display);
-static GFile * gimp_plug_in_procedure_real_get_file (const GimpPlugInProcedure *procedure);
+static GFile * gimp_plug_in_procedure_real_get_file (GimpPlugInProcedure *procedure);
static gboolean gimp_plug_in_procedure_validate_args (GimpPlugInProcedure *proc,
Gimp *gimp,
@@ -452,7 +452,7 @@ gimp_plug_in_procedure_execute_async (GimpProcedure *procedure,
}
static GFile *
-gimp_plug_in_procedure_real_get_file (const GimpPlugInProcedure *procedure)
+gimp_plug_in_procedure_real_get_file (GimpPlugInProcedure *procedure)
{
return procedure->file;
}
@@ -550,7 +550,7 @@ gimp_plug_in_procedure_find (GSList *list,
}
GFile *
-gimp_plug_in_procedure_get_file (const GimpPlugInProcedure *proc)
+gimp_plug_in_procedure_get_file (GimpPlugInProcedure *proc)
{
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
@@ -567,7 +567,7 @@ gimp_plug_in_procedure_set_locale_domain (GimpPlugInProcedure *proc,
}
const gchar *
-gimp_plug_in_procedure_get_locale_domain (const GimpPlugInProcedure *proc)
+gimp_plug_in_procedure_get_locale_domain (GimpPlugInProcedure *proc)
{
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
@@ -584,7 +584,7 @@ gimp_plug_in_procedure_set_help_domain (GimpPlugInProcedure *proc,
}
const gchar *
-gimp_plug_in_procedure_get_help_domain (const GimpPlugInProcedure *proc)
+gimp_plug_in_procedure_get_help_domain (GimpPlugInProcedure *proc)
{
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
diff --git a/app/plug-in/gimppluginprocedure.h b/app/plug-in/gimppluginprocedure.h
index c2187e9..e71247d 100644
--- a/app/plug-in/gimppluginprocedure.h
+++ b/app/plug-in/gimppluginprocedure.h
@@ -72,62 +72,62 @@ struct _GimpPlugInProcedureClass
GimpProcedureClass parent_class;
/* virtual functions */
- GFile * (* get_file) (const GimpPlugInProcedure *procedure);
+ GFile * (* get_file) (GimpPlugInProcedure *procedure);
/* signals */
- void (* menu_path_added) (GimpPlugInProcedure *procedure,
- const gchar *menu_path);
+ void (* menu_path_added) (GimpPlugInProcedure *procedure,
+ const gchar *menu_path);
};
-GType gimp_plug_in_procedure_get_type (void) G_GNUC_CONST;
+GType gimp_plug_in_procedure_get_type (void) G_GNUC_CONST;
-GimpProcedure * gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
- GFile *file);
+GimpProcedure * gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
+ GFile *file);
-GimpPlugInProcedure * gimp_plug_in_procedure_find (GSList *list,
- const gchar *proc_name);
+GimpPlugInProcedure * gimp_plug_in_procedure_find (GSList *list,
+ const gchar *proc_name);
-GFile * gimp_plug_in_procedure_get_file (const GimpPlugInProcedure *proc);
+GFile * gimp_plug_in_procedure_get_file (GimpPlugInProcedure *proc);
-void gimp_plug_in_procedure_set_locale_domain (GimpPlugInProcedure *proc,
- const gchar *locale_domain);
-const gchar * gimp_plug_in_procedure_get_locale_domain (const GimpPlugInProcedure *proc);
+void gimp_plug_in_procedure_set_locale_domain (GimpPlugInProcedure *proc,
+ const gchar *locale_domain);
+const gchar * gimp_plug_in_procedure_get_locale_domain (GimpPlugInProcedure *proc);
-void gimp_plug_in_procedure_set_help_domain (GimpPlugInProcedure *proc,
- const gchar *help_domain);
-const gchar * gimp_plug_in_procedure_get_help_domain (const GimpPlugInProcedure *proc);
+void gimp_plug_in_procedure_set_help_domain (GimpPlugInProcedure *proc,
+ const gchar *help_domain);
+const gchar * gimp_plug_in_procedure_get_help_domain (GimpPlugInProcedure *proc);
-gboolean gimp_plug_in_procedure_add_menu_path (GimpPlugInProcedure *proc,
- const gchar *menu_path,
- GError **error);
+gboolean gimp_plug_in_procedure_add_menu_path (GimpPlugInProcedure *proc,
+ const gchar *menu_path,
+ GError **error);
-void gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
- GimpIconType type,
- const guint8 *data,
- gint data_length);
-void gimp_plug_in_procedure_take_icon (GimpPlugInProcedure *proc,
- GimpIconType type,
- guint8 *data,
- gint data_length);
+void gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
+ GimpIconType type,
+ const guint8 *data,
+ gint data_length);
+void gimp_plug_in_procedure_take_icon (GimpPlugInProcedure *proc,
+ GimpIconType type,
+ guint8 *data,
+ gint data_length);
-void gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
- const gchar *image_types);
-void gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
- const gchar *extensions,
- const gchar *prefixes,
- const gchar *magics);
-void gimp_plug_in_procedure_set_mime_type (GimpPlugInProcedure *proc,
- const gchar *mime_ype);
-void gimp_plug_in_procedure_set_handles_uri (GimpPlugInProcedure *proc);
-void gimp_plug_in_procedure_set_thumb_loader(GimpPlugInProcedure *proc,
- const gchar *thumbnailer);
+void gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
+ const gchar *image_types);
+void gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
+ const gchar *extensions,
+ const gchar *prefixes,
+ const gchar *magics);
+void gimp_plug_in_procedure_set_mime_type (GimpPlugInProcedure *proc,
+ const gchar *mime_ype);
+void gimp_plug_in_procedure_set_handles_uri (GimpPlugInProcedure *proc);
+void gimp_plug_in_procedure_set_thumb_loader (GimpPlugInProcedure *proc,
+ const gchar *thumbnailer);
-void gimp_plug_in_procedure_handle_return_values (GimpPlugInProcedure *proc,
- Gimp *gimp,
- GimpProgress *progress,
+void gimp_plug_in_procedure_handle_return_values (GimpPlugInProcedure *proc,
+ Gimp *gimp,
+ GimpProgress *progress,
- GimpValueArray *return_vals);
+ GimpValueArray *return_vals);
#endif /* __GIMP_PLUG_IN_PROCEDURE_H__ */
diff --git a/app/plug-in/gimptemporaryprocedure.c b/app/plug-in/gimptemporaryprocedure.c
index 7b22114..c8e3ee7 100644
--- a/app/plug-in/gimptemporaryprocedure.c
+++ b/app/plug-in/gimptemporaryprocedure.c
@@ -51,7 +51,7 @@ static void gimp_temporary_procedure_execute_async (GimpProcedure *proce
GimpValueArray *args,
GimpObject *display);
-static GFile * gimp_temporary_procedure_get_file (const GimpPlugInProcedure *procedure);
+static GFile * gimp_temporary_procedure_get_file (GimpPlugInProcedure *procedure);
G_DEFINE_TYPE (GimpTemporaryProcedure, gimp_temporary_procedure,
@@ -131,7 +131,7 @@ gimp_temporary_procedure_execute_async (GimpProcedure *procedure,
}
static GFile *
-gimp_temporary_procedure_get_file (const GimpPlugInProcedure *procedure)
+gimp_temporary_procedure_get_file (GimpPlugInProcedure *procedure)
{
return GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in->file;
}
diff --git a/app/vectors/gimpbezierstroke.c b/app/vectors/gimpbezierstroke.c
index e879d0f..b1b2522 100644
--- a/app/vectors/gimpbezierstroke.c
+++ b/app/vectors/gimpbezierstroke.c
@@ -38,9 +38,9 @@
/* local prototypes */
static gdouble
- gimp_bezier_stroke_nearest_point_get (const GimpStroke *stroke,
+ gimp_bezier_stroke_nearest_point_get (GimpStroke *stroke,
const GimpCoords *coord,
- const gdouble precision,
+ gdouble precision,
GimpCoords *ret_point,
GimpAnchor **ret_segment_start,
GimpAnchor **ret_segment_end,
@@ -49,15 +49,15 @@ static gdouble
gimp_bezier_stroke_segment_nearest_point_get
(const GimpCoords *beziercoords,
const GimpCoords *coord,
- const gdouble precision,
+ gdouble precision,
GimpCoords *ret_point,
gdouble *ret_pos,
gint depth);
static gdouble
- gimp_bezier_stroke_nearest_tangent_get (const GimpStroke *stroke,
+ gimp_bezier_stroke_nearest_tangent_get (GimpStroke *stroke,
const GimpCoords *coord1,
const GimpCoords *coord2,
- const gdouble precision,
+ gdouble precision,
GimpCoords *nearest,
GimpAnchor **ret_segment_start,
GimpAnchor **ret_segment_end,
@@ -67,7 +67,7 @@ static gdouble
(const GimpCoords *beziercoords,
const GimpCoords *coord1,
const GimpCoords *coord2,
- const gdouble precision,
+ gdouble precision,
GimpCoords *ret_point,
gdouble *ret_pos);
static void
@@ -129,11 +129,11 @@ static gboolean
GimpStroke *extension,
GimpAnchor *neighbor);
static GArray *
- gimp_bezier_stroke_interpolate (const GimpStroke *stroke,
- const gdouble precision,
+ gimp_bezier_stroke_interpolate (GimpStroke *stroke,
+ gdouble precision,
gboolean *closed);
static GimpBezierDesc *
- gimp_bezier_stroke_make_bezier (const GimpStroke *stroke);
+ gimp_bezier_stroke_make_bezier (GimpStroke *stroke);
static void gimp_bezier_stroke_finalize (GObject *object);
@@ -555,13 +555,13 @@ gimp_bezier_stroke_close (GimpStroke *stroke)
}
static gdouble
-gimp_bezier_stroke_nearest_point_get (const GimpStroke *stroke,
- const GimpCoords *coord,
- const gdouble precision,
- GimpCoords *ret_point,
- GimpAnchor **ret_segment_start,
- GimpAnchor **ret_segment_end,
- gdouble *ret_pos)
+gimp_bezier_stroke_nearest_point_get (GimpStroke *stroke,
+ const GimpCoords *coord,
+ gdouble precision,
+ GimpCoords *ret_point,
+ GimpAnchor **ret_segment_start,
+ GimpAnchor **ret_segment_end,
+ gdouble *ret_pos)
{
gdouble min_dist, dist, pos;
GimpCoords point = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
@@ -663,12 +663,12 @@ gimp_bezier_stroke_nearest_point_get (const GimpStroke *stroke,
static gdouble
-gimp_bezier_stroke_segment_nearest_point_get (const GimpCoords *beziercoords,
- const GimpCoords *coord,
- const gdouble precision,
- GimpCoords *ret_point,
- gdouble *ret_pos,
- gint depth)
+gimp_bezier_stroke_segment_nearest_point_get (const GimpCoords *beziercoords,
+ const GimpCoords *coord,
+ gdouble precision,
+ GimpCoords *ret_point,
+ gdouble *ret_pos,
+ gint depth)
{
/*
* beziercoords has to contain four GimpCoords with the four control points
@@ -791,10 +791,10 @@ gimp_bezier_stroke_segment_nearest_point_get (const GimpCoords *beziercoords,
static gdouble
-gimp_bezier_stroke_nearest_tangent_get (const GimpStroke *stroke,
+gimp_bezier_stroke_nearest_tangent_get (GimpStroke *stroke,
const GimpCoords *coord1,
const GimpCoords *coord2,
- const gdouble precision,
+ gdouble precision,
GimpCoords *nearest,
GimpAnchor **ret_segment_start,
GimpAnchor **ret_segment_end,
@@ -901,7 +901,7 @@ static gdouble
gimp_bezier_stroke_segment_nearest_tangent_get (const GimpCoords *beziercoords,
const GimpCoords *coord1,
const GimpCoords *coord2,
- const gdouble precision,
+ gdouble precision,
GimpCoords *ret_point,
gdouble *ret_pos)
{
@@ -1457,7 +1457,7 @@ gimp_bezier_stroke_anchor_convert (GimpStroke *stroke,
static GimpBezierDesc *
-gimp_bezier_stroke_make_bezier (const GimpStroke *stroke)
+gimp_bezier_stroke_make_bezier (GimpStroke *stroke)
{
GArray *points;
GArray *cmd_array;
@@ -1543,9 +1543,9 @@ gimp_bezier_stroke_make_bezier (const GimpStroke *stroke)
static GArray *
-gimp_bezier_stroke_interpolate (const GimpStroke *stroke,
- gdouble precision,
- gboolean *ret_closed)
+gimp_bezier_stroke_interpolate (GimpStroke *stroke,
+ gdouble precision,
+ gboolean *ret_closed)
{
GArray *ret_coords;
GimpAnchor *anchor;
diff --git a/app/vectors/gimpstroke.c b/app/vectors/gimpstroke.c
index 8351852..150f558 100644
--- a/app/vectors/gimpstroke.c
+++ b/app/vectors/gimpstroke.c
@@ -59,9 +59,9 @@ static void gimp_stroke_finalize (GObject *object);
static gint64 gimp_stroke_get_memsize (GimpObject *object,
gint64 *gui_size);
-static GimpAnchor * gimp_stroke_real_anchor_get (const GimpStroke *stroke,
+static GimpAnchor * gimp_stroke_real_anchor_get (GimpStroke *stroke,
const GimpCoords *coord);
-static GimpAnchor * gimp_stroke_real_anchor_get_next (const GimpStroke *stroke,
+static GimpAnchor * gimp_stroke_real_anchor_get_next (GimpStroke *stroke,
const GimpAnchor *prev);
static void gimp_stroke_real_anchor_select (GimpStroke *stroke,
GimpAnchor *anchor,
@@ -122,17 +122,17 @@ gboolean gimp_stroke_real_connect_stroke (GimpStroke *stroke,
GimpAnchor *neighbor);
-static gboolean gimp_stroke_real_is_empty (const GimpStroke *stroke);
+static gboolean gimp_stroke_real_is_empty (GimpStroke *stroke);
-static gdouble gimp_stroke_real_get_length (const GimpStroke *stroke,
- const gdouble precision);
-static gdouble gimp_stroke_real_get_distance (const GimpStroke *stroke,
+static gdouble gimp_stroke_real_get_length (GimpStroke *stroke,
+ gdouble precision);
+static gdouble gimp_stroke_real_get_distance (GimpStroke *stroke,
const GimpCoords *coord);
-static GArray * gimp_stroke_real_interpolate (const GimpStroke *stroke,
+static GArray * gimp_stroke_real_interpolate (GimpStroke *stroke,
gdouble precision,
gboolean *closed);
-static GimpStroke * gimp_stroke_real_duplicate (const GimpStroke *stroke);
-static GimpBezierDesc * gimp_stroke_real_make_bezier (const GimpStroke *stroke);
+static GimpStroke * gimp_stroke_real_duplicate (GimpStroke *stroke);
+static GimpBezierDesc * gimp_stroke_real_make_bezier (GimpStroke *stroke);
static void gimp_stroke_real_translate (GimpStroke *stroke,
gdouble offset_x,
@@ -140,29 +140,29 @@ static void gimp_stroke_real_translate (GimpStroke *stroke,
static void gimp_stroke_real_scale (GimpStroke *stroke,
gdouble scale_x,
gdouble scale_y);
-static void gimp_stroke_real_rotate (GimpStroke *stroke,
- gdouble center_x,
- gdouble center_y,
- gdouble angle);
-static void gimp_stroke_real_flip (GimpStroke *stroke,
- GimpOrientationType flip_type,
- gdouble axis);
-static void gimp_stroke_real_flip_free (GimpStroke *stroke,
- gdouble x1,
- gdouble y1,
- gdouble x2,
- gdouble y2);
+static void gimp_stroke_real_rotate (GimpStroke *stroke,
+ gdouble center_x,
+ gdouble center_y,
+ gdouble angle);
+static void gimp_stroke_real_flip (GimpStroke *stroke,
+ GimpOrientationType flip_type,
+ gdouble axis);
+static void gimp_stroke_real_flip_free (GimpStroke *stroke,
+ gdouble x1,
+ gdouble y1,
+ gdouble x2,
+ gdouble y2);
static void gimp_stroke_real_transform (GimpStroke *stroke,
const GimpMatrix3 *matrix);
-static GList * gimp_stroke_real_get_draw_anchors (const GimpStroke *stroke);
-static GList * gimp_stroke_real_get_draw_controls (const GimpStroke *stroke);
-static GArray * gimp_stroke_real_get_draw_lines (const GimpStroke *stroke);
-static GArray * gimp_stroke_real_control_points_get (const GimpStroke *stroke,
+static GList * gimp_stroke_real_get_draw_anchors (GimpStroke *stroke);
+static GList * gimp_stroke_real_get_draw_controls (GimpStroke *stroke);
+static GArray * gimp_stroke_real_get_draw_lines (GimpStroke *stroke);
+static GArray * gimp_stroke_real_control_points_get (GimpStroke *stroke,
gboolean *ret_closed);
-static gboolean gimp_stroke_real_get_point_at_dist (const GimpStroke *stroke,
- const gdouble dist,
- const gdouble precision,
+static gboolean gimp_stroke_real_get_point_at_dist (GimpStroke *stroke,
+ gdouble dist,
+ gdouble precision,
GimpCoords *position,
gdouble *slope);
@@ -366,7 +366,7 @@ gimp_stroke_set_ID (GimpStroke *stroke,
}
gint
-gimp_stroke_get_ID (const GimpStroke *stroke)
+gimp_stroke_get_ID (GimpStroke *stroke)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), -1);
@@ -375,7 +375,7 @@ gimp_stroke_get_ID (const GimpStroke *stroke)
GimpAnchor *
-gimp_stroke_anchor_get (const GimpStroke *stroke,
+gimp_stroke_anchor_get (GimpStroke *stroke,
const GimpCoords *coord)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL);
@@ -385,7 +385,7 @@ gimp_stroke_anchor_get (const GimpStroke *stroke,
gdouble
-gimp_stroke_nearest_point_get (const GimpStroke *stroke,
+gimp_stroke_nearest_point_get (GimpStroke *stroke,
const GimpCoords *coord,
const gdouble precision,
GimpCoords *ret_point,
@@ -408,14 +408,14 @@ gimp_stroke_nearest_point_get (const GimpStroke *stroke,
}
gdouble
-gimp_stroke_nearest_tangent_get (const GimpStroke *stroke,
- const GimpCoords *coords1,
- const GimpCoords *coords2,
- gdouble precision,
- GimpCoords *nearest,
- GimpAnchor **ret_segment_start,
- GimpAnchor **ret_segment_end,
- gdouble *ret_pos)
+gimp_stroke_nearest_tangent_get (GimpStroke *stroke,
+ const GimpCoords *coords1,
+ const GimpCoords *coords2,
+ gdouble precision,
+ GimpCoords *nearest,
+ GimpAnchor **ret_segment_start,
+ GimpAnchor **ret_segment_end,
+ gdouble *ret_pos)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE);
g_return_val_if_fail (coords1 != NULL, FALSE);
@@ -434,14 +434,14 @@ gimp_stroke_nearest_tangent_get (const GimpStroke *stroke,
}
gdouble
-gimp_stroke_nearest_intersection_get (const GimpStroke *stroke,
- const GimpCoords *coords1,
- const GimpCoords *direction,
- gdouble precision,
- GimpCoords *nearest,
- GimpAnchor **ret_segment_start,
- GimpAnchor **ret_segment_end,
- gdouble *ret_pos)
+gimp_stroke_nearest_intersection_get (GimpStroke *stroke,
+ const GimpCoords *coords1,
+ const GimpCoords *direction,
+ gdouble precision,
+ GimpCoords *nearest,
+ GimpAnchor **ret_segment_start,
+ GimpAnchor **ret_segment_end,
+ gdouble *ret_pos)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE);
g_return_val_if_fail (coords1 != NULL, FALSE);
@@ -460,7 +460,7 @@ gimp_stroke_nearest_intersection_get (const GimpStroke *stroke,
}
static GimpAnchor *
-gimp_stroke_real_anchor_get (const GimpStroke *stroke,
+gimp_stroke_real_anchor_get (GimpStroke *stroke,
const GimpCoords *coord)
{
gdouble dx, dy;
@@ -506,7 +506,7 @@ gimp_stroke_real_anchor_get (const GimpStroke *stroke,
GimpAnchor *
-gimp_stroke_anchor_get_next (const GimpStroke *stroke,
+gimp_stroke_anchor_get_next (GimpStroke *stroke,
const GimpAnchor *prev)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL);
@@ -515,7 +515,7 @@ gimp_stroke_anchor_get_next (const GimpStroke *stroke,
}
static GimpAnchor *
-gimp_stroke_real_anchor_get_next (const GimpStroke *stroke,
+gimp_stroke_real_anchor_get_next (GimpStroke *stroke,
const GimpAnchor *prev)
{
GList *list;
@@ -878,7 +878,7 @@ gimp_stroke_real_connect_stroke (GimpStroke *stroke,
}
gboolean
-gimp_stroke_is_empty (const GimpStroke *stroke)
+gimp_stroke_is_empty (GimpStroke *stroke)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE);
@@ -886,15 +886,15 @@ gimp_stroke_is_empty (const GimpStroke *stroke)
}
static gboolean
-gimp_stroke_real_is_empty (const GimpStroke *stroke)
+gimp_stroke_real_is_empty (GimpStroke *stroke)
{
return g_queue_is_empty (stroke->anchors);
}
gdouble
-gimp_stroke_get_length (const GimpStroke *stroke,
- const gdouble precision)
+gimp_stroke_get_length (GimpStroke *stroke,
+ gdouble precision)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0);
@@ -902,8 +902,8 @@ gimp_stroke_get_length (const GimpStroke *stroke,
}
static gdouble
-gimp_stroke_real_get_length (const GimpStroke *stroke,
- const gdouble precision)
+gimp_stroke_real_get_length (GimpStroke *stroke,
+ gdouble precision)
{
GArray *points;
gint i;
@@ -934,8 +934,8 @@ gimp_stroke_real_get_length (const GimpStroke *stroke,
gdouble
-gimp_stroke_get_distance (const GimpStroke *stroke,
- const GimpCoords *coord)
+gimp_stroke_get_distance (GimpStroke *stroke,
+ const GimpCoords *coord)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0);
@@ -943,8 +943,8 @@ gimp_stroke_get_distance (const GimpStroke *stroke,
}
static gdouble
-gimp_stroke_real_get_distance (const GimpStroke *stroke,
- const GimpCoords *coord)
+gimp_stroke_real_get_distance (GimpStroke *stroke,
+ const GimpCoords *coord)
{
g_printerr ("gimp_stroke_get_distance: default implementation\n");
@@ -953,9 +953,9 @@ gimp_stroke_real_get_distance (const GimpStroke *stroke,
GArray *
-gimp_stroke_interpolate (const GimpStroke *stroke,
- gdouble precision,
- gboolean *ret_closed)
+gimp_stroke_interpolate (GimpStroke *stroke,
+ gdouble precision,
+ gboolean *ret_closed)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL);
@@ -964,9 +964,9 @@ gimp_stroke_interpolate (const GimpStroke *stroke,
}
static GArray *
-gimp_stroke_real_interpolate (const GimpStroke *stroke,
- gdouble precision,
- gboolean *ret_closed)
+gimp_stroke_real_interpolate (GimpStroke *stroke,
+ gdouble precision,
+ gboolean *ret_closed)
{
g_printerr ("gimp_stroke_interpolate: default implementation\n");
@@ -974,7 +974,7 @@ gimp_stroke_real_interpolate (const GimpStroke *stroke,
}
GimpStroke *
-gimp_stroke_duplicate (const GimpStroke *stroke)
+gimp_stroke_duplicate (GimpStroke *stroke)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL);
@@ -982,7 +982,7 @@ gimp_stroke_duplicate (const GimpStroke *stroke)
}
static GimpStroke *
-gimp_stroke_real_duplicate (const GimpStroke *stroke)
+gimp_stroke_real_duplicate (GimpStroke *stroke)
{
GimpStroke *new_stroke;
GList *list;
@@ -1006,7 +1006,7 @@ gimp_stroke_real_duplicate (const GimpStroke *stroke)
GimpBezierDesc *
-gimp_stroke_make_bezier (const GimpStroke *stroke)
+gimp_stroke_make_bezier (GimpStroke *stroke)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL);
@@ -1014,7 +1014,7 @@ gimp_stroke_make_bezier (const GimpStroke *stroke)
}
static GimpBezierDesc *
-gimp_stroke_real_make_bezier (const GimpStroke *stroke)
+gimp_stroke_real_make_bezier (GimpStroke *stroke)
{
g_printerr ("gimp_stroke_make_bezier: default implementation\n");
@@ -1102,9 +1102,9 @@ gimp_stroke_real_rotate (GimpStroke *stroke,
}
void
-gimp_stroke_flip (GimpStroke *stroke,
- GimpOrientationType flip_type,
- gdouble axis)
+gimp_stroke_flip (GimpStroke *stroke,
+ GimpOrientationType flip_type,
+ gdouble axis)
{
g_return_if_fail (GIMP_IS_STROKE (stroke));
@@ -1112,9 +1112,9 @@ gimp_stroke_flip (GimpStroke *stroke,
}
static void
-gimp_stroke_real_flip (GimpStroke *stroke,
- GimpOrientationType flip_type,
- gdouble axis)
+gimp_stroke_real_flip (GimpStroke *stroke,
+ GimpOrientationType flip_type,
+ gdouble axis)
{
GimpMatrix3 matrix;
@@ -1124,11 +1124,11 @@ gimp_stroke_real_flip (GimpStroke *stroke,
}
void
-gimp_stroke_flip_free (GimpStroke *stroke,
- gdouble x1,
- gdouble y1,
- gdouble x2,
- gdouble y2)
+gimp_stroke_flip_free (GimpStroke *stroke,
+ gdouble x1,
+ gdouble y1,
+ gdouble x2,
+ gdouble y2)
{
g_return_if_fail (GIMP_IS_STROKE (stroke));
@@ -1136,11 +1136,11 @@ gimp_stroke_flip_free (GimpStroke *stroke,
}
static void
-gimp_stroke_real_flip_free (GimpStroke *stroke,
- gdouble x1,
- gdouble y1,
- gdouble x2,
- gdouble y2)
+gimp_stroke_real_flip_free (GimpStroke *stroke,
+ gdouble x1,
+ gdouble y1,
+ gdouble x2,
+ gdouble y2)
{
/* x, y, width and height parameter in gimp_transform_matrix_flip_free are unused */
GimpMatrix3 matrix;
@@ -1180,7 +1180,7 @@ gimp_stroke_real_transform (GimpStroke *stroke,
GList *
-gimp_stroke_get_draw_anchors (const GimpStroke *stroke)
+gimp_stroke_get_draw_anchors (GimpStroke *stroke)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL);
@@ -1188,7 +1188,7 @@ gimp_stroke_get_draw_anchors (const GimpStroke *stroke)
}
static GList *
-gimp_stroke_real_get_draw_anchors (const GimpStroke *stroke)
+gimp_stroke_real_get_draw_anchors (GimpStroke *stroke)
{
GList *list;
GList *ret_list = NULL;
@@ -1204,7 +1204,7 @@ gimp_stroke_real_get_draw_anchors (const GimpStroke *stroke)
GList *
-gimp_stroke_get_draw_controls (const GimpStroke *stroke)
+gimp_stroke_get_draw_controls (GimpStroke *stroke)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL);
@@ -1212,7 +1212,7 @@ gimp_stroke_get_draw_controls (const GimpStroke *stroke)
}
static GList *
-gimp_stroke_real_get_draw_controls (const GimpStroke *stroke)
+gimp_stroke_real_get_draw_controls (GimpStroke *stroke)
{
GList *list;
GList *ret_list = NULL;
@@ -1253,7 +1253,7 @@ gimp_stroke_real_get_draw_controls (const GimpStroke *stroke)
GArray *
-gimp_stroke_get_draw_lines (const GimpStroke *stroke)
+gimp_stroke_get_draw_lines (GimpStroke *stroke)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL);
@@ -1261,7 +1261,7 @@ gimp_stroke_get_draw_lines (const GimpStroke *stroke)
}
static GArray *
-gimp_stroke_real_get_draw_lines (const GimpStroke *stroke)
+gimp_stroke_real_get_draw_lines (GimpStroke *stroke)
{
GList *list;
GArray *ret_lines = NULL;
@@ -1303,8 +1303,8 @@ gimp_stroke_real_get_draw_lines (const GimpStroke *stroke)
}
GArray *
-gimp_stroke_control_points_get (const GimpStroke *stroke,
- gboolean *ret_closed)
+gimp_stroke_control_points_get (GimpStroke *stroke,
+ gboolean *ret_closed)
{
g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL);
@@ -1313,12 +1313,12 @@ gimp_stroke_control_points_get (const GimpStroke *stroke,
}
static GArray *
-gimp_stroke_real_control_points_get (const GimpStroke *stroke,
- gboolean *ret_closed)
+gimp_stroke_real_control_points_get (GimpStroke *stroke,
+ gboolean *ret_closed)
{
- guint num_anchors;
+ guint num_anchors;
GArray *ret_array;
- GList *list;
+ GList *list;
num_anchors = g_queue_get_length (stroke->anchors);
ret_array = g_array_sized_new (FALSE, FALSE,
@@ -1336,28 +1336,28 @@ gimp_stroke_real_control_points_get (const GimpStroke *stroke,
}
gboolean
-gimp_stroke_get_point_at_dist (const GimpStroke *stroke,
- const gdouble dist,
- const gdouble precision,
- GimpCoords *position,
- gdouble *slope)
+gimp_stroke_get_point_at_dist (GimpStroke *stroke,
+ gdouble dist,
+ gdouble precision,
+ GimpCoords *position,
+ gdouble *slope)
{
- g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE);
+ g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE);
- return GIMP_STROKE_GET_CLASS (stroke)->get_point_at_dist (stroke,
- dist,
- precision,
- position,
- slope);
+ return GIMP_STROKE_GET_CLASS (stroke)->get_point_at_dist (stroke,
+ dist,
+ precision,
+ position,
+ slope);
}
static gboolean
-gimp_stroke_real_get_point_at_dist (const GimpStroke *stroke,
- const gdouble dist,
- const gdouble precision,
- GimpCoords *position,
- gdouble *slope)
+gimp_stroke_real_get_point_at_dist (GimpStroke *stroke,
+ gdouble dist,
+ gdouble precision,
+ GimpCoords *position,
+ gdouble *slope)
{
GArray *points;
gint i;
diff --git a/app/vectors/gimpstroke.h b/app/vectors/gimpstroke.h
index 1823382..022ead0 100644
--- a/app/vectors/gimpstroke.h
+++ b/app/vectors/gimpstroke.h
@@ -51,33 +51,33 @@ struct _GimpStrokeClass
void (* changed) (GimpStroke *stroke);
void (* removed) (GimpStroke *stroke);
- GimpAnchor * (* anchor_get) (const GimpStroke *stroke,
+ GimpAnchor * (* anchor_get) (GimpStroke *stroke,
const GimpCoords *coord);
- gdouble (* nearest_point_get) (const GimpStroke *stroke,
+ gdouble (* nearest_point_get) (GimpStroke *stroke,
const GimpCoords *coord,
- const gdouble precision,
+ gdouble precision,
GimpCoords *ret_point,
GimpAnchor **ret_segment_start,
GimpAnchor **ret_segment_end,
gdouble *ret_pos);
- gdouble (* nearest_tangent_get) (const GimpStroke *stroke,
+ gdouble (* nearest_tangent_get) (GimpStroke *stroke,
const GimpCoords *coord1,
const GimpCoords *coord2,
- const gdouble precision,
+ gdouble precision,
GimpCoords *nearest,
GimpAnchor **ret_segment_start,
GimpAnchor **ret_segment_end,
gdouble *ret_pos);
gdouble (* nearest_intersection_get)
- (const GimpStroke *stroke,
+ (GimpStroke *stroke,
const GimpCoords *coord1,
const GimpCoords *direction,
- const gdouble precision,
+ gdouble precision,
GimpCoords *nearest,
GimpAnchor **ret_segment_start,
GimpAnchor **ret_segment_end,
gdouble *ret_pos);
- GimpAnchor * (* anchor_get_next) (const GimpStroke *stroke,
+ GimpAnchor * (* anchor_get_next) (GimpStroke *stroke,
const GimpAnchor *prev);
void (* anchor_select) (GimpStroke *stroke,
GimpAnchor *anchor,
@@ -131,24 +131,24 @@ struct _GimpStrokeClass
GimpStroke *extension,
GimpAnchor *neighbor);
- gboolean (* is_empty) (const GimpStroke *stroke);
- gdouble (* get_length) (const GimpStroke *stroke,
- const gdouble precision);
- gdouble (* get_distance) (const GimpStroke *stroke,
+ gboolean (* is_empty) (GimpStroke *stroke);
+ gdouble (* get_length) (GimpStroke *stroke,
+ gdouble precision);
+ gdouble (* get_distance) (GimpStroke *stroke,
const GimpCoords *coord);
- gboolean (* get_point_at_dist) (const GimpStroke *stroke,
- const gdouble dist,
- const gdouble precision,
+ gboolean (* get_point_at_dist) (GimpStroke *stroke,
+ gdouble dist,
+ gdouble precision,
GimpCoords *position,
gdouble *slope);
- GArray * (* interpolate) (const GimpStroke *stroke,
- const gdouble precision,
+ GArray * (* interpolate) (GimpStroke *stroke,
+ gdouble precision,
gboolean *ret_closed);
- GimpStroke * (* duplicate) (const GimpStroke *stroke);
+ GimpStroke * (* duplicate) (GimpStroke *stroke);
- GimpBezierDesc * (* make_bezier) (const GimpStroke *stroke);
+ GimpBezierDesc * (* make_bezier) (GimpStroke *stroke);
void (* translate) (GimpStroke *stroke,
gdouble offset_x,
@@ -171,10 +171,10 @@ struct _GimpStrokeClass
void (* transform) (GimpStroke *stroke,
const GimpMatrix3 *matrix);
- GList * (* get_draw_anchors) (const GimpStroke *stroke);
- GList * (* get_draw_controls) (const GimpStroke *stroke);
- GArray * (* get_draw_lines) (const GimpStroke *stroke);
- GArray * (* control_points_get) (const GimpStroke *stroke,
+ GList * (* get_draw_anchors) (GimpStroke *stroke);
+ GList * (* get_draw_controls) (GimpStroke *stroke);
+ GArray * (* get_draw_lines) (GimpStroke *stroke);
+ GArray * (* control_points_get) (GimpStroke *stroke,
gboolean *ret_closed);
};
@@ -183,25 +183,25 @@ GType gimp_stroke_get_type (void) G_GNUC_CONST;
void gimp_stroke_set_ID (GimpStroke *stroke,
gint id);
-gint gimp_stroke_get_ID (const GimpStroke *stroke);
+gint gimp_stroke_get_ID (GimpStroke *stroke);
/* accessing / modifying the anchors */
-GArray * gimp_stroke_control_points_get (const GimpStroke *stroke,
+GArray * gimp_stroke_control_points_get (GimpStroke *stroke,
gboolean *closed);
-GimpAnchor * gimp_stroke_anchor_get (const GimpStroke *stroke,
+GimpAnchor * gimp_stroke_anchor_get (GimpStroke *stroke,
const GimpCoords *coord);
-gdouble gimp_stroke_nearest_point_get (const GimpStroke *stroke,
+gdouble gimp_stroke_nearest_point_get (GimpStroke *stroke,
const GimpCoords *coord,
- const gdouble precision,
+ gdouble precision,
GimpCoords *ret_point,
GimpAnchor **ret_segment_start,
GimpAnchor **ret_segment_end,
gdouble *ret_pos);
-gdouble gimp_stroke_nearest_tangent_get (const GimpStroke *stroke,
+gdouble gimp_stroke_nearest_tangent_get (GimpStroke *stroke,
const GimpCoords *coords1,
const GimpCoords *coords2,
gdouble precision,
@@ -209,7 +209,7 @@ gdouble gimp_stroke_nearest_tangent_get (const GimpStroke *stroke,
GimpAnchor **ret_segment_start,
GimpAnchor **ret_segment_end,
gdouble *ret_pos);
-gdouble gimp_stroke_nearest_intersection_get (const GimpStroke *stroke,
+gdouble gimp_stroke_nearest_intersection_get (GimpStroke *stroke,
const GimpCoords *coords1,
const GimpCoords *direction,
gdouble precision,
@@ -220,7 +220,7 @@ gdouble gimp_stroke_nearest_intersection_get (const GimpStroke *stroke,
/* prev == NULL: "first" anchor */
-GimpAnchor * gimp_stroke_anchor_get_next (const GimpStroke *stroke,
+GimpAnchor * gimp_stroke_anchor_get_next (GimpStroke *stroke,
const GimpAnchor *prev);
void gimp_stroke_anchor_select (GimpStroke *stroke,
@@ -286,30 +286,30 @@ gboolean gimp_stroke_connect_stroke (GimpStroke *stroke,
GimpStroke *extension,
GimpAnchor *neighbor);
-gboolean gimp_stroke_is_empty (const GimpStroke *stroke);
+gboolean gimp_stroke_is_empty (GimpStroke *stroke);
/* accessing the shape of the curve */
-gdouble gimp_stroke_get_length (const GimpStroke *stroke,
- const gdouble precision);
-gdouble gimp_stroke_get_distance (const GimpStroke *stroke,
+gdouble gimp_stroke_get_length (GimpStroke *stroke,
+ gdouble precision);
+gdouble gimp_stroke_get_distance (GimpStroke *stroke,
const GimpCoords *coord);
-gboolean gimp_stroke_get_point_at_dist (const GimpStroke *stroke,
- const gdouble dist,
- const gdouble precision,
+gboolean gimp_stroke_get_point_at_dist (GimpStroke *stroke,
+ gdouble dist,
+ gdouble precision,
GimpCoords *position,
gdouble *slope);
/* returns an array of valid coordinates */
-GArray * gimp_stroke_interpolate (const GimpStroke *stroke,
+GArray * gimp_stroke_interpolate (GimpStroke *stroke,
const gdouble precision,
gboolean *closed);
-GimpStroke * gimp_stroke_duplicate (const GimpStroke *stroke);
+GimpStroke * gimp_stroke_duplicate (GimpStroke *stroke);
/* creates a bezier approximation. */
-GimpBezierDesc * gimp_stroke_make_bezier (const GimpStroke *stroke);
+GimpBezierDesc * gimp_stroke_make_bezier (GimpStroke *stroke);
void gimp_stroke_translate (GimpStroke *stroke,
gdouble offset_x,
@@ -333,9 +333,9 @@ void gimp_stroke_transform (GimpStroke *stroke,
const GimpMatrix3 *matrix);
-GList * gimp_stroke_get_draw_anchors (const GimpStroke *stroke);
-GList * gimp_stroke_get_draw_controls (const GimpStroke *stroke);
-GArray * gimp_stroke_get_draw_lines (const GimpStroke *stroke);
+GList * gimp_stroke_get_draw_anchors (GimpStroke *stroke);
+GList * gimp_stroke_get_draw_controls (GimpStroke *stroke);
+GArray * gimp_stroke_get_draw_lines (GimpStroke *stroke);
#endif /* __GIMP_STROKE_H__ */
diff --git a/app/vectors/gimpvectors-export.c b/app/vectors/gimpvectors-export.c
index 3694420..3cc5f68 100644
--- a/app/vectors/gimpvectors-export.c
+++ b/app/vectors/gimpvectors-export.c
@@ -36,13 +36,13 @@
#include "gimp-intl.h"
-static GString * gimp_vectors_export (const GimpImage *image,
- const GimpVectors *vectors);
-static void gimp_vectors_export_image_size (const GimpImage *image,
- GString *str);
-static void gimp_vectors_export_path (const GimpVectors *vectors,
- GString *str);
-static gchar * gimp_vectors_export_path_data (const GimpVectors *vectors);
+static GString * gimp_vectors_export (GimpImage *image,
+ GimpVectors *vectors);
+static void gimp_vectors_export_image_size (GimpImage *image,
+ GString *str);
+static void gimp_vectors_export_path (GimpVectors *vectors,
+ GString *str);
+static gchar * gimp_vectors_export_path_data (GimpVectors *vectors);
/**
@@ -58,10 +58,10 @@ static gchar * gimp_vectors_export_path_data (const GimpVectors *vectors);
* %FALSE if there was an error writing the file
**/
gboolean
-gimp_vectors_export_file (const GimpImage *image,
- const GimpVectors *vectors,
- GFile *file,
- GError **error)
+gimp_vectors_export_file (GimpImage *image,
+ GimpVectors *vectors,
+ GFile *file,
+ GError **error)
{
GOutputStream *output;
GString *string;
@@ -108,8 +108,8 @@ gimp_vectors_export_file (const GimpImage *image,
* Return value: a %NUL-terminated string that holds a complete XML document
**/
gchar *
-gimp_vectors_export_string (const GimpImage *image,
- const GimpVectors *vectors)
+gimp_vectors_export_string (GimpImage *image,
+ GimpVectors *vectors)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors), NULL);
@@ -118,8 +118,8 @@ gimp_vectors_export_string (const GimpImage *image,
}
static GString *
-gimp_vectors_export (const GimpImage *image,
- const GimpVectors *vectors)
+gimp_vectors_export (GimpImage *image,
+ GimpVectors *vectors)
{
GString *str = g_string_new (NULL);
@@ -161,8 +161,8 @@ gimp_vectors_export (const GimpImage *image,
}
static void
-gimp_vectors_export_image_size (const GimpImage *image,
- GString *str)
+gimp_vectors_export_image_size (GimpImage *image,
+ GString *str)
{
GimpUnit unit;
const gchar *abbrev;
@@ -201,8 +201,8 @@ gimp_vectors_export_image_size (const GimpImage *image,
}
static void
-gimp_vectors_export_path (const GimpVectors *vectors,
- GString *str)
+gimp_vectors_export_path (GimpVectors *vectors,
+ GString *str)
{
const gchar *name = gimp_object_get_name (vectors);
gchar *data = gimp_vectors_export_path_data (vectors);
@@ -224,7 +224,7 @@ gimp_vectors_export_path (const GimpVectors *vectors,
#define NEWLINE "\n "
static gchar *
-gimp_vectors_export_path_data (const GimpVectors *vectors)
+gimp_vectors_export_path_data (GimpVectors *vectors)
{
GString *str;
GList *strokes;
diff --git a/app/vectors/gimpvectors-export.h b/app/vectors/gimpvectors-export.h
index 4bc2038..5d917d4 100644
--- a/app/vectors/gimpvectors-export.h
+++ b/app/vectors/gimpvectors-export.h
@@ -19,12 +19,12 @@
#define __GIMP_VECTORS_EXPORT_H__
-gboolean gimp_vectors_export_file (const GimpImage *image,
- const GimpVectors *vectors,
- GFile *file,
- GError **error);
-gchar * gimp_vectors_export_string (const GimpImage *image,
- const GimpVectors *vectors);
+gboolean gimp_vectors_export_file (GimpImage *image,
+ GimpVectors *vectors,
+ GFile *file,
+ GError **error);
+gchar * gimp_vectors_export_string (GimpImage *image,
+ GimpVectors *vectors);
#endif /* __GIMP_VECTORS_IMPORT_H__ */
diff --git a/app/vectors/gimpvectors-warp.c b/app/vectors/gimpvectors-warp.c
index 938b64c..12385c1 100644
--- a/app/vectors/gimpvectors-warp.c
+++ b/app/vectors/gimpvectors-warp.c
@@ -40,22 +40,22 @@
#define DX 2.0
-static void gimp_stroke_warp_point (const GimpStroke *stroke,
- gdouble x,
- gdouble y,
- GimpCoords *point_warped,
- gdouble y_offset);
+static void gimp_stroke_warp_point (GimpStroke *stroke,
+ gdouble x,
+ gdouble y,
+ GimpCoords *point_warped,
+ gdouble y_offset);
-static void gimp_vectors_warp_stroke (const GimpVectors *vectors,
- GimpStroke *stroke,
- gdouble y_offset);
+static void gimp_vectors_warp_stroke (GimpVectors *vectors,
+ GimpStroke *stroke,
+ gdouble y_offset);
void
-gimp_vectors_warp_point (const GimpVectors *vectors,
- GimpCoords *point,
- GimpCoords *point_warped,
- gdouble y_offset)
+gimp_vectors_warp_point (GimpVectors *vectors,
+ GimpCoords *point,
+ GimpCoords *point_warped,
+ gdouble y_offset)
{
gdouble x = point->x;
gdouble y = point->y;
@@ -88,11 +88,11 @@ gimp_vectors_warp_point (const GimpVectors *vectors,
}
static void
-gimp_stroke_warp_point (const GimpStroke *stroke,
- gdouble x,
- gdouble y,
- GimpCoords *point_warped,
- gdouble y_offset)
+gimp_stroke_warp_point (GimpStroke *stroke,
+ gdouble x,
+ gdouble y,
+ GimpCoords *point_warped,
+ gdouble y_offset)
{
GimpCoords point_zero = { 0, };
GimpCoords point_minus = { 0, };
@@ -135,9 +135,9 @@ gimp_stroke_warp_point (const GimpStroke *stroke,
}
static void
-gimp_vectors_warp_stroke (const GimpVectors *vectors,
- GimpStroke *stroke,
- gdouble y_offset)
+gimp_vectors_warp_stroke (GimpVectors *vectors,
+ GimpStroke *stroke,
+ gdouble y_offset)
{
GList *list;
@@ -152,9 +152,9 @@ gimp_vectors_warp_stroke (const GimpVectors *vectors,
}
void
-gimp_vectors_warp_vectors (const GimpVectors *vectors,
- GimpVectors *vectors_in,
- gdouble y_offset)
+gimp_vectors_warp_vectors (GimpVectors *vectors,
+ GimpVectors *vectors_in,
+ gdouble y_offset)
{
GList *list;
diff --git a/app/vectors/gimpvectors-warp.h b/app/vectors/gimpvectors-warp.h
index 32799d6..174a274 100644
--- a/app/vectors/gimpvectors-warp.h
+++ b/app/vectors/gimpvectors-warp.h
@@ -21,15 +21,16 @@
#ifndef __GIMP_VECTORS_WARP_H__
#define __GIMP_VECTORS_WARP_H__
-void gimp_vectors_warp_point (const GimpVectors *vectors,
- GimpCoords *point,
- GimpCoords *point_warped,
- gdouble y_offset);
+void gimp_vectors_warp_point (GimpVectors *vectors,
+ GimpCoords *point,
+ GimpCoords *point_warped,
+ gdouble y_offset);
+
+void gimp_vectors_warp_vectors (GimpVectors *vectors,
+ GimpVectors *vectors_in,
+ gdouble yoffset);
-void gimp_vectors_warp_vectors (const GimpVectors *vectors,
- GimpVectors *vectors_in,
- gdouble yoffset);
#endif /* __GIMP_VECTORS_WARP_H__ */
diff --git a/app/vectors/gimpvectors.c b/app/vectors/gimpvectors.c
index 95fddcd..b4d3911 100644
--- a/app/vectors/gimpvectors.c
+++ b/app/vectors/gimpvectors.c
@@ -68,7 +68,7 @@ static void gimp_vectors_finalize (GObject *object);
static gint64 gimp_vectors_get_memsize (GimpObject *object,
gint64 *gui_size);
-static gboolean gimp_vectors_is_attached (const GimpItem *item);
+static gboolean gimp_vectors_is_attached (GimpItem *item);
static GimpItemTree * gimp_vectors_get_tree (GimpItem *item);
static gboolean gimp_vectors_bounds (GimpItem *item,
gdouble *x,
@@ -140,29 +140,29 @@ static void gimp_vectors_real_stroke_add (GimpVectors *vectors,
GimpStroke *stroke);
static void gimp_vectors_real_stroke_remove (GimpVectors *vectors,
GimpStroke *stroke);
-static GimpStroke * gimp_vectors_real_stroke_get (const GimpVectors *vectors,
+static GimpStroke * gimp_vectors_real_stroke_get (GimpVectors *vectors,
const GimpCoords *coord);
-static GimpStroke *gimp_vectors_real_stroke_get_next(const GimpVectors *vectors,
- const GimpStroke *prev);
-static gdouble gimp_vectors_real_stroke_get_length (const GimpVectors *vectors,
- const GimpStroke *prev);
-static GimpAnchor * gimp_vectors_real_anchor_get (const GimpVectors *vectors,
+static GimpStroke *gimp_vectors_real_stroke_get_next(GimpVectors *vectors,
+ GimpStroke *prev);
+static gdouble gimp_vectors_real_stroke_get_length (GimpVectors *vectors,
+ GimpStroke *prev);
+static GimpAnchor * gimp_vectors_real_anchor_get (GimpVectors *vectors,
const GimpCoords *coord,
GimpStroke **ret_stroke);
static void gimp_vectors_real_anchor_delete (GimpVectors *vectors,
GimpAnchor *anchor);
-static gdouble gimp_vectors_real_get_length (const GimpVectors *vectors,
+static gdouble gimp_vectors_real_get_length (GimpVectors *vectors,
const GimpAnchor *start);
-static gdouble gimp_vectors_real_get_distance (const GimpVectors *vectors,
+static gdouble gimp_vectors_real_get_distance (GimpVectors *vectors,
const GimpCoords *coord);
-static gint gimp_vectors_real_interpolate (const GimpVectors *vectors,
- const GimpStroke *stroke,
+static gint gimp_vectors_real_interpolate (GimpVectors *vectors,
+ GimpStroke *stroke,
gdouble precision,
gint max_points,
GimpCoords *ret_coords);
-static GimpBezierDesc * gimp_vectors_make_bezier (const GimpVectors *vectors);
-static GimpBezierDesc * gimp_vectors_real_make_bezier (const GimpVectors *vectors);
+static GimpBezierDesc * gimp_vectors_make_bezier (GimpVectors *vectors);
+static GimpBezierDesc * gimp_vectors_real_make_bezier (GimpVectors *vectors);
G_DEFINE_TYPE (GimpVectors, gimp_vectors, GIMP_TYPE_ITEM)
@@ -317,7 +317,7 @@ gimp_vectors_get_memsize (GimpObject *object,
}
static gboolean
-gimp_vectors_is_attached (const GimpItem *item)
+gimp_vectors_is_attached (GimpItem *item)
{
GimpImage *image = gimp_item_get_image (item);
@@ -795,8 +795,8 @@ gimp_vectors_thaw (GimpVectors *vectors)
}
void
-gimp_vectors_copy_strokes (const GimpVectors *src_vectors,
- GimpVectors *dest_vectors)
+gimp_vectors_copy_strokes (GimpVectors *src_vectors,
+ GimpVectors *dest_vectors)
{
g_return_if_fail (GIMP_IS_VECTORS (src_vectors));
g_return_if_fail (GIMP_IS_VECTORS (dest_vectors));
@@ -816,8 +816,8 @@ gimp_vectors_copy_strokes (const GimpVectors *src_vectors,
void
-gimp_vectors_add_strokes (const GimpVectors *src_vectors,
- GimpVectors *dest_vectors)
+gimp_vectors_add_strokes (GimpVectors *src_vectors,
+ GimpVectors *dest_vectors)
{
GList *stroke;
@@ -910,7 +910,7 @@ gimp_vectors_real_stroke_remove (GimpVectors *vectors,
}
gint
-gimp_vectors_get_n_strokes (const GimpVectors *vectors)
+gimp_vectors_get_n_strokes (GimpVectors *vectors)
{
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0);
@@ -919,8 +919,8 @@ gimp_vectors_get_n_strokes (const GimpVectors *vectors)
GimpStroke *
-gimp_vectors_stroke_get (const GimpVectors *vectors,
- const GimpCoords *coord)
+gimp_vectors_stroke_get (GimpVectors *vectors,
+ const GimpCoords *coord)
{
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL);
@@ -928,8 +928,8 @@ gimp_vectors_stroke_get (const GimpVectors *vectors,
}
static GimpStroke *
-gimp_vectors_real_stroke_get (const GimpVectors *vectors,
- const GimpCoords *coord)
+gimp_vectors_real_stroke_get (GimpVectors *vectors,
+ const GimpCoords *coord)
{
GimpStroke *minstroke = NULL;
gdouble mindist = G_MAXDOUBLE;
@@ -957,8 +957,8 @@ gimp_vectors_real_stroke_get (const GimpVectors *vectors,
}
GimpStroke *
-gimp_vectors_stroke_get_by_ID (const GimpVectors *vectors,
- gint id)
+gimp_vectors_stroke_get_by_ID (GimpVectors *vectors,
+ gint id)
{
GList *list;
@@ -975,8 +975,8 @@ gimp_vectors_stroke_get_by_ID (const GimpVectors *vectors,
GimpStroke *
-gimp_vectors_stroke_get_next (const GimpVectors *vectors,
- const GimpStroke *prev)
+gimp_vectors_stroke_get_next (GimpVectors *vectors,
+ GimpStroke *prev)
{
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL);
@@ -984,8 +984,8 @@ gimp_vectors_stroke_get_next (const GimpVectors *vectors,
}
static GimpStroke *
-gimp_vectors_real_stroke_get_next (const GimpVectors *vectors,
- const GimpStroke *prev)
+gimp_vectors_real_stroke_get_next (GimpVectors *vectors,
+ GimpStroke *prev)
{
if (! prev)
{
@@ -1003,8 +1003,8 @@ gimp_vectors_real_stroke_get_next (const GimpVectors *vectors,
gdouble
-gimp_vectors_stroke_get_length (const GimpVectors *vectors,
- const GimpStroke *stroke)
+gimp_vectors_stroke_get_length (GimpVectors *vectors,
+ GimpStroke *stroke)
{
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0);
g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0);
@@ -1013,8 +1013,8 @@ gimp_vectors_stroke_get_length (const GimpVectors *vectors,
}
static gdouble
-gimp_vectors_real_stroke_get_length (const GimpVectors *vectors,
- const GimpStroke *stroke)
+gimp_vectors_real_stroke_get_length (GimpVectors *vectors,
+ GimpStroke *stroke)
{
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0);
g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0);
@@ -1024,7 +1024,7 @@ gimp_vectors_real_stroke_get_length (const GimpVectors *vectors,
GimpAnchor *
-gimp_vectors_anchor_get (const GimpVectors *vectors,
+gimp_vectors_anchor_get (GimpVectors *vectors,
const GimpCoords *coord,
GimpStroke **ret_stroke)
{
@@ -1035,7 +1035,7 @@ gimp_vectors_anchor_get (const GimpVectors *vectors,
}
static GimpAnchor *
-gimp_vectors_real_anchor_get (const GimpVectors *vectors,
+gimp_vectors_real_anchor_get (GimpVectors *vectors,
const GimpCoords *coord,
GimpStroke **ret_stroke)
{
@@ -1106,8 +1106,8 @@ gimp_vectors_anchor_select (GimpVectors *vectors,
gdouble
-gimp_vectors_get_length (const GimpVectors *vectors,
- const GimpAnchor *start)
+gimp_vectors_get_length (GimpVectors *vectors,
+ const GimpAnchor *start)
{
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0);
@@ -1115,8 +1115,8 @@ gimp_vectors_get_length (const GimpVectors *vectors,
}
static gdouble
-gimp_vectors_real_get_length (const GimpVectors *vectors,
- const GimpAnchor *start)
+gimp_vectors_real_get_length (GimpVectors *vectors,
+ const GimpAnchor *start)
{
g_printerr ("gimp_vectors_get_length: default implementation\n");
@@ -1125,8 +1125,8 @@ gimp_vectors_real_get_length (const GimpVectors *vectors,
gdouble
-gimp_vectors_get_distance (const GimpVectors *vectors,
- const GimpCoords *coord)
+gimp_vectors_get_distance (GimpVectors *vectors,
+ const GimpCoords *coord)
{
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0);
@@ -1134,8 +1134,8 @@ gimp_vectors_get_distance (const GimpVectors *vectors,
}
static gdouble
-gimp_vectors_real_get_distance (const GimpVectors *vectors,
- const GimpCoords *coord)
+gimp_vectors_real_get_distance (GimpVectors *vectors,
+ const GimpCoords *coord)
{
g_printerr ("gimp_vectors_get_distance: default implementation\n");
@@ -1143,11 +1143,11 @@ gimp_vectors_real_get_distance (const GimpVectors *vectors,
}
gint
-gimp_vectors_interpolate (const GimpVectors *vectors,
- const GimpStroke *stroke,
- gdouble precision,
- gint max_points,
- GimpCoords *ret_coords)
+gimp_vectors_interpolate (GimpVectors *vectors,
+ GimpStroke *stroke,
+ gdouble precision,
+ gint max_points,
+ GimpCoords *ret_coords)
{
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0);
@@ -1157,11 +1157,11 @@ gimp_vectors_interpolate (const GimpVectors *vectors,
}
static gint
-gimp_vectors_real_interpolate (const GimpVectors *vectors,
- const GimpStroke *stroke,
- gdouble precision,
- gint max_points,
- GimpCoords *ret_coords)
+gimp_vectors_real_interpolate (GimpVectors *vectors,
+ GimpStroke *stroke,
+ gdouble precision,
+ gint max_points,
+ GimpCoords *ret_coords)
{
g_printerr ("gimp_vectors_interpolate: default implementation\n");
@@ -1182,13 +1182,13 @@ gimp_vectors_get_bezier (GimpVectors *vectors)
}
static GimpBezierDesc *
-gimp_vectors_make_bezier (const GimpVectors *vectors)
+gimp_vectors_make_bezier (GimpVectors *vectors)
{
return GIMP_VECTORS_GET_CLASS (vectors)->make_bezier (vectors);
}
static GimpBezierDesc *
-gimp_vectors_real_make_bezier (const GimpVectors *vectors)
+gimp_vectors_real_make_bezier (GimpVectors *vectors)
{
GimpStroke *stroke;
GArray *cmd_array;
diff --git a/app/vectors/gimpvectors.h b/app/vectors/gimpvectors.h
index 8188953..5c4b413 100644
--- a/app/vectors/gimpvectors.h
+++ b/app/vectors/gimpvectors.h
@@ -67,27 +67,27 @@ struct _GimpVectorsClass
GimpStroke *stroke);
void (* stroke_remove) (GimpVectors *vectors,
GimpStroke *stroke);
- GimpStroke * (* stroke_get) (const GimpVectors *vectors,
+ GimpStroke * (* stroke_get) (GimpVectors *vectors,
const GimpCoords *coord);
- GimpStroke * (* stroke_get_next) (const GimpVectors *vectors,
- const GimpStroke *prev);
- gdouble (* stroke_get_length) (const GimpVectors *vectors,
- const GimpStroke *stroke);
- GimpAnchor * (* anchor_get) (const GimpVectors *vectors,
+ GimpStroke * (* stroke_get_next) (GimpVectors *vectors,
+ GimpStroke *prev);
+ gdouble (* stroke_get_length) (GimpVectors *vectors,
+ GimpStroke *stroke);
+ GimpAnchor * (* anchor_get) (GimpVectors *vectors,
const GimpCoords *coord,
GimpStroke **ret_stroke);
void (* anchor_delete) (GimpVectors *vectors,
GimpAnchor *anchor);
- gdouble (* get_length) (const GimpVectors *vectors,
+ gdouble (* get_length) (GimpVectors *vectors,
const GimpAnchor *start);
- gdouble (* get_distance) (const GimpVectors *vectors,
+ gdouble (* get_distance) (GimpVectors *vectors,
const GimpCoords *coord);
- gint (* interpolate) (const GimpVectors *vectors,
- const GimpStroke *stroke,
+ gint (* interpolate) (GimpVectors *vectors,
+ GimpStroke *stroke,
gdouble precision,
gint max_points,
GimpCoords *ret_coords);
- GimpBezierDesc * (* make_bezier) (const GimpVectors *vectors);
+ GimpBezierDesc * (* make_bezier) (GimpVectors *vectors);
};
@@ -103,20 +103,20 @@ GimpVectors * gimp_vectors_get_parent (GimpVectors *vectors);
void gimp_vectors_freeze (GimpVectors *vectors);
void gimp_vectors_thaw (GimpVectors *vectors);
-void gimp_vectors_copy_strokes (const GimpVectors *src_vectors,
+void gimp_vectors_copy_strokes (GimpVectors *src_vectors,
GimpVectors *dest_vectors);
-void gimp_vectors_add_strokes (const GimpVectors *src_vectors,
+void gimp_vectors_add_strokes (GimpVectors *src_vectors,
GimpVectors *dest_vectors);
/* accessing / modifying the anchors */
-GimpAnchor * gimp_vectors_anchor_get (const GimpVectors *vectors,
+GimpAnchor * gimp_vectors_anchor_get (GimpVectors *vectors,
const GimpCoords *coord,
GimpStroke **ret_stroke);
/* prev == NULL: "first" anchor */
-GimpAnchor * gimp_vectors_anchor_get_next (const GimpVectors *vectors,
+GimpAnchor * gimp_vectors_anchor_get_next (GimpVectors *vectors,
const GimpAnchor *prev);
/* type will be an xorable enum:
@@ -148,29 +148,29 @@ void gimp_vectors_stroke_add (GimpVectors *vectors,
GimpStroke *stroke);
void gimp_vectors_stroke_remove (GimpVectors *vectors,
GimpStroke *stroke);
-gint gimp_vectors_get_n_strokes (const GimpVectors *vectors);
-GimpStroke * gimp_vectors_stroke_get (const GimpVectors *vectors,
+gint gimp_vectors_get_n_strokes (GimpVectors *vectors);
+GimpStroke * gimp_vectors_stroke_get (GimpVectors *vectors,
const GimpCoords *coord);
-GimpStroke * gimp_vectors_stroke_get_by_ID (const GimpVectors *vectors,
+GimpStroke * gimp_vectors_stroke_get_by_ID (GimpVectors *vectors,
gint id);
/* prev == NULL: "first" stroke */
-GimpStroke * gimp_vectors_stroke_get_next (const GimpVectors *vectors,
- const GimpStroke *prev);
-gdouble gimp_vectors_stroke_get_length (const GimpVectors *vectors,
- const GimpStroke *stroke);
+GimpStroke * gimp_vectors_stroke_get_next (GimpVectors *vectors,
+ GimpStroke *prev);
+gdouble gimp_vectors_stroke_get_length (GimpVectors *vectors,
+ GimpStroke *stroke);
/* accessing the shape of the curve */
-gdouble gimp_vectors_get_length (const GimpVectors *vectors,
+gdouble gimp_vectors_get_length (GimpVectors *vectors,
const GimpAnchor *start);
-gdouble gimp_vectors_get_distance (const GimpVectors *vectors,
+gdouble gimp_vectors_get_distance (GimpVectors *vectors,
const GimpCoords *coord);
/* returns the number of valid coordinates */
-gint gimp_vectors_interpolate (const GimpVectors *vectors,
- const GimpStroke *stroke,
+gint gimp_vectors_interpolate (GimpVectors *vectors,
+ GimpStroke *stroke,
gdouble precision,
gint max_points,
GimpCoords *ret_coords);
diff --git a/app/widgets/gimpitemtreeview.h b/app/widgets/gimpitemtreeview.h
index c280906..5bd43a6 100644
--- a/app/widgets/gimpitemtreeview.h
+++ b/app/widgets/gimpitemtreeview.h
@@ -25,20 +25,20 @@
#include "gimpcontainertreeview.h"
-typedef GimpContainer * (* GimpGetContainerFunc) (const GimpImage *image);
-typedef GimpItem * (* GimpGetItemFunc) (const GimpImage *image);
-typedef void (* GimpSetItemFunc) (GimpImage *image,
- GimpItem *item);
-typedef void (* GimpAddItemFunc) (GimpImage *image,
- GimpItem *item,
- GimpItem *parent,
- gint index,
- gboolean push_undo);
-typedef void (* GimpRemoveItemFunc) (GimpImage *image,
- GimpItem *item,
- gboolean push_undo,
- GimpItem *new_active);
-typedef GimpItem * (* GimpNewItemFunc) (GimpImage *image);
+typedef GimpContainer * (* GimpGetContainerFunc) (GimpImage *image);
+typedef GimpItem * (* GimpGetItemFunc) (GimpImage *image);
+typedef void (* GimpSetItemFunc) (GimpImage *image,
+ GimpItem *item);
+typedef void (* GimpAddItemFunc) (GimpImage *image,
+ GimpItem *item,
+ GimpItem *parent,
+ gint index,
+ gboolean push_undo);
+typedef void (* GimpRemoveItemFunc) (GimpImage *image,
+ GimpItem *item,
+ gboolean push_undo,
+ GimpItem *new_active);
+typedef GimpItem * (* GimpNewItemFunc) (GimpImage *image);
#define GIMP_TYPE_ITEM_TREE_VIEW (gimp_item_tree_view_get_type ())
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
