← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/core/gimpimage-undo-push.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/gimpimage-undo-push.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
22
22
 
23
23
/*  image undos  */
24
24
 
25
 
gboolean gimp_image_undo_push_image_type            (GimpImage     *gimage,
26
 
                                                     const gchar   *undo_desc);
27
 
gboolean gimp_image_undo_push_image_size            (GimpImage     *gimage,
28
 
                                                     const gchar   *undo_desc);
29
 
gboolean gimp_image_undo_push_image_resolution      (GimpImage     *gimage,
30
 
                                                     const gchar   *undo_desc);
31
 
gboolean gimp_image_undo_push_image_grid            (GimpImage     *gimage,
 
25
GimpUndo * gimp_image_undo_push_image_type          (GimpImage     *image,
 
26
                                                     const gchar   *undo_desc);
 
27
GimpUndo * gimp_image_undo_push_image_size          (GimpImage     *image,
 
28
                                                     const gchar   *undo_desc);
 
29
GimpUndo * gimp_image_undo_push_image_resolution    (GimpImage     *image,
 
30
                                                     const gchar   *undo_desc);
 
31
GimpUndo * gimp_image_undo_push_image_grid          (GimpImage     *image,
32
32
                                                     const gchar   *undo_desc,
33
33
                                                     GimpGrid      *grid);
34
 
gboolean gimp_image_undo_push_image_guide           (GimpImage     *gimage,
 
34
GimpUndo * gimp_image_undo_push_image_colormap      (GimpImage     *image,
 
35
                                                     const gchar   *undo_desc);
 
36
GimpUndo * gimp_image_undo_push_image_parasite      (GimpImage     *image,
 
37
                                                     const gchar   *undo_desc,
 
38
                                                     const GimpParasite *parasite);
 
39
GimpUndo * gimp_image_undo_push_image_parasite_remove (GimpImage   *image,
 
40
                                                     const gchar   *undo_desc,
 
41
                                                     const gchar   *name);
 
42
 
 
43
 
 
44
/*  guide & sample point undos  */
 
45
 
 
46
GimpUndo * gimp_image_undo_push_guide               (GimpImage     *image,
35
47
                                                     const gchar   *undo_desc,
36
48
                                                     GimpGuide     *guide);
37
 
gboolean gimp_image_undo_push_image_colormap        (GimpImage     *gimage,
38
 
                                                     const gchar   *undo_desc);
39
 
 
40
 
 
41
 
/*  drawable undo  */
42
 
 
43
 
gboolean gimp_image_undo_push_drawable              (GimpImage     *gimage,
 
49
GimpUndo * gimp_image_undo_push_sample_point        (GimpImage     *image,
 
50
                                                     const gchar   *undo_desc,
 
51
                                                     GimpSamplePoint *sample_point);
 
52
 
 
53
 
 
54
/*  drawable undos  */
 
55
 
 
56
GimpUndo * gimp_image_undo_push_drawable            (GimpImage     *image,
44
57
                                                     const gchar   *undo_desc,
45
58
                                                     GimpDrawable  *drawable,
46
59
                                                     TileManager   *tiles,
49
62
                                                     gint           y,
50
63
                                                     gint           width,
51
64
                                                     gint           height);
52
 
gboolean gimp_image_undo_push_drawable_mod          (GimpImage     *gimage,
 
65
GimpUndo * gimp_image_undo_push_drawable_mod        (GimpImage     *image,
53
66
                                                     const gchar   *undo_desc,
54
67
                                                     GimpDrawable  *drawable);
55
68
 
56
69
 
57
70
/*  mask undo  */
58
71
 
59
 
gboolean gimp_image_undo_push_mask                  (GimpImage     *gimage,
 
72
GimpUndo * gimp_image_undo_push_mask                (GimpImage     *image,
60
73
                                                     const gchar   *undo_desc,
61
74
                                                     GimpChannel   *mask);
62
75
 
63
76
 
64
77
/*  item undos  */
65
78
 
66
 
gboolean gimp_image_undo_push_item_rename           (GimpImage     *gimage,
67
 
                                                     const gchar   *undo_desc,
68
 
                                                     GimpItem      *item);
69
 
gboolean gimp_image_undo_push_item_displace         (GimpImage     *gimage,
70
 
                                                     const gchar   *undo_desc,
71
 
                                                     GimpItem      *item);
72
 
gboolean gimp_image_undo_push_item_visibility       (GimpImage     *gimage,
73
 
                                                     const gchar   *undo_desc,
74
 
                                                     GimpItem      *item);
75
 
gboolean gimp_image_undo_push_item_linked           (GimpImage     *gimage,
76
 
                                                     const gchar   *undo_desc,
77
 
                                                     GimpItem      *item);
 
79
GimpUndo * gimp_image_undo_push_item_rename         (GimpImage     *image,
 
80
                                                     const gchar   *undo_desc,
 
81
                                                     GimpItem      *item);
 
82
GimpUndo * gimp_image_undo_push_item_displace       (GimpImage     *image,
 
83
                                                     const gchar   *undo_desc,
 
84
                                                     GimpItem      *item);
 
85
GimpUndo * gimp_image_undo_push_item_visibility     (GimpImage     *image,
 
86
                                                     const gchar   *undo_desc,
 
87
                                                     GimpItem      *item);
 
88
GimpUndo * gimp_image_undo_push_item_linked         (GimpImage     *image,
 
89
                                                     const gchar   *undo_desc,
 
90
                                                     GimpItem      *item);
 
91
GimpUndo * gimp_image_undo_push_item_parasite       (GimpImage     *image,
 
92
                                                     const gchar   *undo_desc,
 
93
                                                     GimpItem      *item,
 
94
                                                     const GimpParasite *parasite);
 
95
GimpUndo * gimp_image_undo_push_item_parasite_remove(GimpImage     *image,
 
96
                                                     const gchar   *undo_desc,
 
97
                                                     GimpItem      *item,
 
98
                                                     const gchar   *name);
 
99
 
78
100
 
79
101
 
80
102
/*  layer undos  */
81
103
 
82
 
gboolean gimp_image_undo_push_layer_add             (GimpImage     *gimage,
83
 
                                                     const gchar   *undo_desc,
84
 
                                                     GimpLayer     *layer,
85
 
                                                     gint           prev_position,
86
 
                                                     GimpLayer     *prev_layer);
87
 
gboolean gimp_image_undo_push_layer_remove          (GimpImage     *gimage,
88
 
                                                     const gchar   *undo_desc,
89
 
                                                     GimpLayer     *layer,
90
 
                                                     gint           prev_position,
91
 
                                                     GimpLayer     *prev_layer);
92
 
gboolean gimp_image_undo_push_layer_mask_add        (GimpImage     *gimage,
93
 
                                                     const gchar   *undo_desc,
94
 
                                                     GimpLayer     *layer,
95
 
                                                     GimpLayerMask *mask);
96
 
gboolean gimp_image_undo_push_layer_mask_remove     (GimpImage     *gimage,
97
 
                                                     const gchar   *undo_desc,
98
 
                                                     GimpLayer     *layer,
99
 
                                                     GimpLayerMask *mask);
100
 
gboolean gimp_image_undo_push_layer_reposition      (GimpImage     *gimage,
101
 
                                                     const gchar   *undo_desc,
102
 
                                                     GimpLayer     *layer);
103
 
gboolean gimp_image_undo_push_layer_mode            (GimpImage     *gimage,
104
 
                                                     const gchar   *undo_desc,
105
 
                                                     GimpLayer     *layer);
106
 
gboolean gimp_image_undo_push_layer_opacity         (GimpImage     *gimage,
107
 
                                                     const gchar   *undo_desc,
108
 
                                                     GimpLayer     *layer);
109
 
gboolean gimp_image_undo_push_layer_preserve_trans  (GimpImage     *gimage,
 
104
GimpUndo * gimp_image_undo_push_layer_add           (GimpImage     *image,
 
105
                                                     const gchar   *undo_desc,
 
106
                                                     GimpLayer     *layer,
 
107
                                                     GimpLayer     *prev_layer);
 
108
GimpUndo * gimp_image_undo_push_layer_remove        (GimpImage     *image,
 
109
                                                     const gchar   *undo_desc,
 
110
                                                     GimpLayer     *layer,
 
111
                                                     gint           prev_position,
 
112
                                                     GimpLayer     *prev_layer);
 
113
GimpUndo * gimp_image_undo_push_layer_reposition    (GimpImage     *image,
 
114
                                                     const gchar   *undo_desc,
 
115
                                                     GimpLayer     *layer);
 
116
GimpUndo * gimp_image_undo_push_layer_mode          (GimpImage     *image,
 
117
                                                     const gchar   *undo_desc,
 
118
                                                     GimpLayer     *layer);
 
119
GimpUndo * gimp_image_undo_push_layer_opacity       (GimpImage     *image,
 
120
                                                     const gchar   *undo_desc,
 
121
                                                     GimpLayer     *layer);
 
122
GimpUndo * gimp_image_undo_push_layer_lock_alpha    (GimpImage     *image,
110
123
                                                     const gchar   *undo_desc,
111
124
                                                     GimpLayer     *layer);
112
125
 
113
126
 
114
127
/*  text layer undos  */
115
128
 
116
 
gboolean gimp_image_undo_push_text_layer            (GimpImage     *gimage,
 
129
GimpUndo * gimp_image_undo_push_text_layer          (GimpImage     *image,
117
130
                                                     const gchar   *undo_desc,
118
131
                                                     GimpTextLayer *layer,
119
132
                                                     const GParamSpec *pspec);
120
 
gboolean gimp_image_undo_push_text_layer_modified   (GimpImage     *gimage,
 
133
GimpUndo * gimp_image_undo_push_text_layer_modified (GimpImage     *image,
121
134
                                                     const gchar   *undo_desc,
122
135
                                                     GimpTextLayer *layer);
123
136
 
124
137
 
 
138
/*  layer mask undos  */
 
139
 
 
140
GimpUndo * gimp_image_undo_push_layer_mask_add      (GimpImage     *image,
 
141
                                                     const gchar   *undo_desc,
 
142
                                                     GimpLayer     *layer,
 
143
                                                     GimpLayerMask *mask);
 
144
GimpUndo * gimp_image_undo_push_layer_mask_remove   (GimpImage     *image,
 
145
                                                     const gchar   *undo_desc,
 
146
                                                     GimpLayer     *layer,
 
147
                                                     GimpLayerMask *mask);
 
148
GimpUndo * gimp_image_undo_push_layer_mask_apply    (GimpImage     *image,
 
149
                                                     const gchar   *undo_desc,
 
150
                                                     GimpLayerMask *mask);
 
151
GimpUndo * gimp_image_undo_push_layer_mask_show     (GimpImage     *image,
 
152
                                                     const gchar   *undo_desc,
 
153
                                                     GimpLayerMask *mask);
 
154
 
 
155
 
125
156
/*  channel undos  */
126
157
 
127
 
gboolean gimp_image_undo_push_channel_add           (GimpImage     *gimage,
128
 
                                                     const gchar   *undo_desc,
129
 
                                                     GimpChannel   *channel,
130
 
                                                     gint           prev_position,
131
 
                                                     GimpChannel   *prev_channel);
132
 
gboolean gimp_image_undo_push_channel_remove        (GimpImage     *gimage,
133
 
                                                     const gchar   *undo_desc,
134
 
                                                     GimpChannel   *channel,
135
 
                                                     gint           prev_position,
136
 
                                                     GimpChannel   *prev_channel);
137
 
gboolean gimp_image_undo_push_channel_reposition    (GimpImage     *gimage,
 
158
GimpUndo * gimp_image_undo_push_channel_add         (GimpImage     *image,
 
159
                                                     const gchar   *undo_desc,
 
160
                                                     GimpChannel   *channel,
 
161
                                                     GimpChannel   *prev_channel);
 
162
GimpUndo * gimp_image_undo_push_channel_remove      (GimpImage     *image,
 
163
                                                     const gchar   *undo_desc,
 
164
                                                     GimpChannel   *channel,
 
165
                                                     gint           prev_position,
 
166
                                                     GimpChannel   *prev_channel);
 
167
GimpUndo * gimp_image_undo_push_channel_reposition  (GimpImage     *image,
138
168
                                                     const gchar   *undo_desc,
139
169
                                                     GimpChannel   *channel);
140
 
gboolean gimp_image_undo_push_channel_color         (GimpImage     *gimage,
 
170
GimpUndo * gimp_image_undo_push_channel_color       (GimpImage     *image,
141
171
                                                     const gchar   *undo_desc,
142
172
                                                     GimpChannel   *channel);
143
173
 
144
174
 
145
175
/*  vectors undos  */
146
176
 
147
 
gboolean gimp_image_undo_push_vectors_add           (GimpImage     *gimage,
 
177
GimpUndo * gimp_image_undo_push_vectors_add         (GimpImage     *image,
148
178
                                                     const gchar   *undo_desc,
149
179
                                                     GimpVectors   *vectors,
150
 
                                                     gint           prev_position,
151
180
                                                     GimpVectors   *prev_vectors);
152
 
gboolean gimp_image_undo_push_vectors_remove        (GimpImage     *gimage,
 
181
GimpUndo * gimp_image_undo_push_vectors_remove      (GimpImage     *image,
153
182
                                                     const gchar   *undo_desc,
154
183
                                                     GimpVectors   *channel,
155
184
                                                     gint           prev_position,
156
185
                                                     GimpVectors   *prev_vectors);
157
 
gboolean gimp_image_undo_push_vectors_mod           (GimpImage     *gimage,
 
186
GimpUndo * gimp_image_undo_push_vectors_mod         (GimpImage     *image,
158
187
                                                     const gchar   *undo_desc,
159
188
                                                     GimpVectors   *vectors);
160
 
gboolean gimp_image_undo_push_vectors_reposition    (GimpImage     *gimage,
 
189
GimpUndo * gimp_image_undo_push_vectors_reposition  (GimpImage     *image,
161
190
                                                     const gchar   *undo_desc,
162
191
                                                     GimpVectors   *vectors);
163
192
 
164
193
 
165
194
/*  floating selection undos  */
166
195
 
167
 
gboolean gimp_image_undo_push_fs_to_layer           (GimpImage     *gimage,
168
 
                                                     const gchar   *undo_desc,
169
 
                                                     GimpLayer     *floating_layer,
170
 
                                                     GimpDrawable  *drawable);
171
 
gboolean gimp_image_undo_push_fs_rigor              (GimpImage     *gimage,
172
 
                                                     const gchar   *undo_desc,
173
 
                                                     GimpLayer     *floating_layer);
174
 
gboolean gimp_image_undo_push_fs_relax              (GimpImage     *gimage,
175
 
                                                     const gchar   *undo_desc,
176
 
                                                     GimpLayer     *floating_layer);
177
 
 
178
 
 
179
 
/*  parasite undos  */
180
 
 
181
 
gboolean gimp_image_undo_push_image_parasite        (GimpImage     *gimage,
182
 
                                                     const gchar   *undo_desc,
183
 
                                                     gpointer       parasite);
184
 
gboolean gimp_image_undo_push_image_parasite_remove (GimpImage     *gimage,
185
 
                                                     const gchar   *undo_desc,
186
 
                                                     const gchar   *name);
187
 
 
188
 
gboolean gimp_image_undo_push_item_parasite         (GimpImage     *gimage,
189
 
                                                     const gchar   *undo_desc,
190
 
                                                     GimpItem      *item,
191
 
                                                     gpointer       parasite);
192
 
gboolean gimp_image_undo_push_item_parasite_remove  (GimpImage     *gimage,
193
 
                                                     const gchar   *undo_desc,
194
 
                                                     GimpItem      *item,
195
 
                                                     const gchar   *name);
 
196
GimpUndo * gimp_image_undo_push_fs_to_layer         (GimpImage     *image,
 
197
                                                     const gchar   *undo_desc,
 
198
                                                     GimpLayer     *floating_layer);
 
199
GimpUndo * gimp_image_undo_push_fs_rigor            (GimpImage     *image,
 
200
                                                     const gchar   *undo_desc,
 
201
                                                     GimpLayer     *floating_layer);
 
202
GimpUndo * gimp_image_undo_push_fs_relax            (GimpImage     *image,
 
203
                                                     const gchar   *undo_desc,
 
204
                                                     GimpLayer     *floating_layer);
196
205
 
197
206
 
198
207
/*  EEK undo  */
199
208
 
200
 
gboolean gimp_image_undo_push_cantundo              (GimpImage     *gimage,
 
209
GimpUndo * gimp_image_undo_push_cantundo            (GimpImage     *image,
201
210
                                                     const gchar   *undo_desc);
202
211
 
203
212