← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/core/gimpitem.h

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/core/gimpitem.h
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify
40
40
  gint              ID;                 /*  provides a unique ID     */
41
41
  guint32           tattoo;             /*  provides a permanent ID  */
42
42
 
43
 
  GimpImage        *gimage;             /*  gimage owner             */
 
43
  GimpImage        *image;              /*  item owner               */
44
44
 
45
45
  GimpParasiteList *parasites;          /*  Plug-in parasite data    */
46
46
 
50
50
  gboolean          visible;            /*  control visibility       */
51
51
  gboolean          linked;             /*  control linkage          */
52
52
 
53
 
  gboolean          floating;           /*  added to an image?       */
54
53
  gboolean          removed;            /*  removed from the image?  */
55
54
};
56
55
 
108
107
                               GimpInterpolationType   interpolation_type,
109
108
                               gboolean                supersample,
110
109
                               gint                    recursion_level,
111
 
                               gboolean                clip_result,
 
110
                               GimpTransformResize     clip_result,
112
111
                               GimpProgress           *progress);
113
112
  gboolean   (* stroke)       (GimpItem               *item,
114
113
                               GimpDrawable           *drawable,
115
 
                               GimpContext            *context,
116
114
                               GimpStrokeDesc         *stroke_desc);
117
115
 
118
116
  const gchar *default_name;
129
127
 
130
128
GType           gimp_item_get_type         (void) G_GNUC_CONST;
131
129
 
132
 
gboolean        gimp_item_is_floating      (const GimpItem *item);
133
 
void            gimp_item_sink             (GimpItem       *item);
134
 
 
135
 
void            gimp_item_removed          (GimpItem       *item);
136
 
gboolean        gimp_item_is_removed       (const GimpItem *item);
137
 
 
138
 
gboolean        gimp_item_is_attached      (GimpItem       *item);
139
 
 
140
 
void            gimp_item_configure        (GimpItem       *item,
141
 
                                            GimpImage      *gimage,
142
 
                                            gint            offset_x,
143
 
                                            gint            offset_y,
144
 
                                            gint            width,
145
 
                                            gint            height,
146
 
                                            const gchar    *name);
147
 
GimpItem      * gimp_item_duplicate        (GimpItem       *item,
148
 
                                            GType           new_type,
149
 
                                            gboolean        add_alpha);
150
 
GimpItem      * gimp_item_convert          (GimpItem       *item,
151
 
                                            GimpImage      *dest_image,
152
 
                                            GType           new_type,
153
 
                                            gboolean        add_alpha);
154
 
 
155
 
gboolean        gimp_item_rename           (GimpItem       *item,
156
 
                                            const gchar    *new_name);
157
 
 
158
 
gint            gimp_item_width            (const GimpItem *item);
159
 
gint            gimp_item_height           (const GimpItem *item);
160
 
void            gimp_item_offsets          (const GimpItem *item,
161
 
                                            gint           *offset_x,
162
 
                                            gint           *offset_y);
163
 
 
164
 
void            gimp_item_translate        (GimpItem       *item,
165
 
                                            gint            offset_x,
166
 
                                            gint            offset_y,
167
 
                                            gboolean        push_undo);
168
 
 
169
 
gboolean        gimp_item_check_scaling    (const GimpItem *item,
170
 
                                            gint            new_width,
171
 
                                            gint            new_height);
172
 
void            gimp_item_scale            (GimpItem       *item,
173
 
                                            gint            new_width,
174
 
                                            gint            new_height,
175
 
                                            gint            new_offset_x,
176
 
                                            gint            new_offset_y,
177
 
                                            GimpInterpolationType  interpolation,
178
 
                                            GimpProgress   *progress);
179
 
gboolean        gimp_item_scale_by_factors (GimpItem       *item,
180
 
                                            gdouble         w_factor,
181
 
                                            gdouble         h_factor,
182
 
                                            GimpInterpolationType interpolation,
183
 
                                            GimpProgress   *progress);
184
 
void            gimp_item_scale_by_origin  (GimpItem       *item,
185
 
                                            gint            new_width,
186
 
                                            gint            new_height,
187
 
                                            GimpInterpolationType interpolation,
188
 
                                            GimpProgress   *progress,
189
 
                                            gboolean        local_origin);
190
 
void            gimp_item_resize           (GimpItem       *item,
191
 
                                            GimpContext    *context,
192
 
                                            gint            new_width,
193
 
                                            gint            new_height,
194
 
                                            gint            offset_x,
195
 
                                            gint            offset_y);
196
 
void            gimp_item_resize_to_image  (GimpItem       *item);
197
 
 
198
 
void            gimp_item_flip             (GimpItem       *item,
199
 
                                            GimpContext    *context,
 
130
void            gimp_item_removed          (GimpItem           *item);
 
131
gboolean        gimp_item_is_removed       (const GimpItem     *item);
 
132
 
 
133
gboolean        gimp_item_is_attached      (GimpItem           *item);
 
134
 
 
135
void            gimp_item_configure        (GimpItem           *item,
 
136
                                            GimpImage          *image,
 
137
                                            gint                offset_x,
 
138
                                            gint                offset_y,
 
139
                                            gint                width,
 
140
                                            gint                height,
 
141
                                            const gchar        *name);
 
142
GimpItem      * gimp_item_duplicate        (GimpItem           *item,
 
143
                                            GType               new_type,
 
144
                                            gboolean            add_alpha);
 
145
GimpItem      * gimp_item_convert          (GimpItem           *item,
 
146
                                            GimpImage          *dest_image,
 
147
                                            GType               new_type,
 
148
                                            gboolean            add_alpha);
 
149
 
 
150
gboolean        gimp_item_rename           (GimpItem           *item,
 
151
                                            const gchar        *new_name);
 
152
 
 
153
gint            gimp_item_width            (const GimpItem     *item);
 
154
gint            gimp_item_height           (const GimpItem     *item);
 
155
void            gimp_item_offsets          (const GimpItem     *item,
 
156
                                            gint               *offset_x,
 
157
                                            gint               *offset_y);
 
158
 
 
159
void            gimp_item_translate        (GimpItem           *item,
 
160
                                            gint                offset_x,
 
161
                                            gint                offset_y,
 
162
                                            gboolean            push_undo);
 
163
 
 
164
gboolean        gimp_item_check_scaling    (const GimpItem     *item,
 
165
                                            gint                new_width,
 
166
                                            gint                new_height);
 
167
void            gimp_item_scale            (GimpItem           *item,
 
168
                                            gint                new_width,
 
169
                                            gint                new_height,
 
170
                                            gint                new_offset_x,
 
171
                                            gint                new_offset_y,
 
172
                                            GimpInterpolationType interpolation,
 
173
                                            GimpProgress       *progress);
 
174
gboolean        gimp_item_scale_by_factors (GimpItem           *item,
 
175
                                            gdouble             w_factor,
 
176
                                            gdouble             h_factor,
 
177
                                            GimpInterpolationType interpolation,
 
178
                                            GimpProgress       *progress);
 
179
void            gimp_item_scale_by_origin  (GimpItem           *item,
 
180
                                            gint                new_width,
 
181
                                            gint                new_height,
 
182
                                            GimpInterpolationType interpolation,
 
183
                                            GimpProgress       *progress,
 
184
                                            gboolean            local_origin);
 
185
void            gimp_item_resize           (GimpItem           *item,
 
186
                                            GimpContext        *context,
 
187
                                            gint                new_width,
 
188
                                            gint                new_height,
 
189
                                            gint                offset_x,
 
190
                                            gint                offset_y);
 
191
void            gimp_item_resize_to_image  (GimpItem           *item);
 
192
 
 
193
void            gimp_item_flip             (GimpItem           *item,
 
194
                                            GimpContext        *context,
200
195
                                            GimpOrientationType flip_type,
201
 
                                            gdouble         axis,
202
 
                                            gboolean        flip_result);
203
 
void            gimp_item_rotate           (GimpItem       *item,
204
 
                                            GimpContext    *context,
205
 
                                            GimpRotationType rotate_type,
206
 
                                            gdouble         center_x,
207
 
                                            gdouble         center_y,
208
 
                                            gboolean        flip_result);
209
 
void            gimp_item_transform        (GimpItem       *item,
210
 
                                            GimpContext    *context,
211
 
                                            const GimpMatrix3 *matrix,
 
196
                                            gdouble             axis,
 
197
                                            gboolean            flip_result);
 
198
void            gimp_item_rotate           (GimpItem           *item,
 
199
                                            GimpContext        *context,
 
200
                                            GimpRotationType    rotate_type,
 
201
                                            gdouble             center_x,
 
202
                                            gdouble             center_y,
 
203
                                            gboolean            flip_result);
 
204
void            gimp_item_transform        (GimpItem           *item,
 
205
                                            GimpContext        *context,
 
206
                                            const GimpMatrix3  *matrix,
212
207
                                            GimpTransformDirection direction,
213
208
                                            GimpInterpolationType interpolation_type,
214
 
                                            gboolean        supersample,
215
 
                                            gint            recursion_level,
216
 
                                            gboolean        clip_result,
217
 
                                            GimpProgress   *progress);
218
 
 
219
 
gboolean        gimp_item_stroke           (GimpItem       *item,
220
 
                                            GimpDrawable   *drawable,
221
 
                                            GimpContext    *context,
222
 
                                            GimpStrokeDesc *stroke_desc,
223
 
                                            gboolean        use_default_values);
224
 
 
225
 
gint            gimp_item_get_ID           (GimpItem       *item);
226
 
GimpItem      * gimp_item_get_by_ID        (Gimp           *gimp,
227
 
                                            gint            id);
228
 
 
229
 
GimpTattoo      gimp_item_get_tattoo       (const GimpItem *item);
230
 
void            gimp_item_set_tattoo       (GimpItem       *item,
231
 
                                            GimpTattoo      tattoo);
232
 
 
233
 
GimpImage     * gimp_item_get_image        (const GimpItem *item);
234
 
void            gimp_item_set_image        (GimpItem       *item,
235
 
                                            GimpImage      *gimage);
236
 
 
237
 
void            gimp_item_parasite_attach  (GimpItem       *item,
238
 
                                            GimpParasite   *parasite);
239
 
void            gimp_item_parasite_detach  (GimpItem       *item,
240
 
                                            const gchar    *name);
241
 
GimpParasite  * gimp_item_parasite_find    (const GimpItem *item,
242
 
                                            const gchar    *name);
243
 
gchar        ** gimp_item_parasite_list    (const GimpItem *item,
244
 
                                            gint           *count);
245
 
 
246
 
gboolean        gimp_item_get_visible      (const GimpItem *item);
247
 
void            gimp_item_set_visible      (GimpItem       *item,
248
 
                                            gboolean        visible,
249
 
                                            gboolean        push_undo);
250
 
 
251
 
void            gimp_item_set_linked       (GimpItem       *item,
252
 
                                            gboolean        linked,
253
 
                                            gboolean        push_undo);
254
 
gboolean        gimp_item_get_linked       (const GimpItem *item);
 
209
                                            gboolean            supersample,
 
210
                                            gint                recursion_level,
 
211
                                            GimpTransformResize clip_result,
 
212
                                            GimpProgress       *progress);
 
213
 
 
214
gboolean        gimp_item_stroke           (GimpItem           *item,
 
215
                                            GimpDrawable       *drawable,
 
216
                                            GimpContext        *context,
 
217
                                            GimpStrokeDesc     *stroke_desc,
 
218
                                            gboolean            use_default_values);
 
219
 
 
220
gint            gimp_item_get_ID           (GimpItem           *item);
 
221
GimpItem      * gimp_item_get_by_ID        (Gimp               *gimp,
 
222
                                            gint                id);
 
223
 
 
224
GimpTattoo      gimp_item_get_tattoo       (const GimpItem     *item);
 
225
void            gimp_item_set_tattoo       (GimpItem           *item,
 
226
                                            GimpTattoo          tattoo);
 
227
 
 
228
GimpImage     * gimp_item_get_image        (const GimpItem     *item);
 
229
void            gimp_item_set_image        (GimpItem           *item,
 
230
                                            GimpImage          *image);
 
231
 
 
232
void            gimp_item_parasite_attach  (GimpItem           *item,
 
233
                                            const GimpParasite *parasite);
 
234
void            gimp_item_parasite_detach  (GimpItem           *item,
 
235
                                            const gchar        *name);
 
236
const GimpParasite *gimp_item_parasite_find(const GimpItem     *item,
 
237
                                            const gchar        *name);
 
238
gchar        ** gimp_item_parasite_list    (const GimpItem     *item,
 
239
                                            gint               *count);
 
240
 
 
241
gboolean        gimp_item_get_visible      (const GimpItem     *item);
 
242
void            gimp_item_set_visible      (GimpItem           *item,
 
243
                                            gboolean            visible,
 
244
                                            gboolean            push_undo);
 
245
 
 
246
void            gimp_item_set_linked       (GimpItem           *item,
 
247
                                            gboolean            linked,
 
248
                                            gboolean            push_undo);
 
249
gboolean        gimp_item_get_linked       (const GimpItem     *item);
 
250
 
 
251
gboolean        gimp_item_is_in_set        (GimpItem           *item,
 
252
                                            GimpItemSet         set);
255
253
 
256
254
 
257
255
#endif /* __GIMP_ITEM_H__ */