← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/core/gimpdrawable.h

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2008-10-06 13:30:41 UTC
  • mto: This revision was merged to the branch mainline in revision 35.
  • Revision ID: james.westby@ubuntu.com-20081006133041-3panbkcanaymfsmp
Tags: upstream-2.6.0
Import upstream version 2.6.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/core/gimpdrawable.h
38
38
  GimpItem       parent_instance;
39
39
 
40
40
  TileManager   *tiles;              /* tiles for drawable data        */
 
41
  TileManager   *shadow;             /* shadow buffer tiles            */
41
42
 
42
43
  gint           bytes;              /* bytes per pixel                */
43
44
  GimpImageType  type;               /* type of drawable               */
53
54
  GimpItemClass  parent_class;
54
55
 
55
56
  /*  signals  */
56
 
  void   (* update)                (GimpDrawable         *drawable,
57
 
                                    gint                  x,
58
 
                                    gint                  y,
59
 
                                    gint                  width,
60
 
                                    gint                  height);
61
 
  void   (* alpha_changed)         (GimpDrawable         *drawable);
 
57
  void          (* update)                (GimpDrawable         *drawable,
 
58
                                           gint                  x,
 
59
                                           gint                  y,
 
60
                                           gint                  width,
 
61
                                           gint                  height);
 
62
  void          (* alpha_changed)         (GimpDrawable         *drawable);
62
63
 
63
64
  /*  virtual functions  */
64
 
  gint64 (* estimate_memsize)      (const GimpDrawable   *drawable,
65
 
                                    gint                  width,
66
 
                                    gint                  height);
67
 
  void   (* invalidate_boundary)   (GimpDrawable         *drawable);
68
 
  void   (* get_active_components) (const GimpDrawable   *drawable,
69
 
                                    gboolean             *active);
70
 
  void   (* apply_region)          (GimpDrawable         *drawable,
71
 
                                    PixelRegion          *src2PR,
72
 
                                    gboolean              push_undo,
73
 
                                    const gchar          *undo_desc,
74
 
                                    gdouble               opacity,
75
 
                                    GimpLayerModeEffects  mode,
76
 
                                    TileManager          *src1_tiles,
77
 
                                    gint                  x,
78
 
                                    gint                  y);
79
 
  void   (* replace_region)        (GimpDrawable         *drawable,
80
 
                                    PixelRegion          *src2PR,
81
 
                                    gboolean              push_undo,
82
 
                                    const gchar          *undo_desc,
83
 
                                    gdouble               opacity,
84
 
                                    PixelRegion          *maskPR,
85
 
                                    gint                  x,
86
 
                                    gint                  y);
87
 
  void   (* set_tiles)             (GimpDrawable         *drawable,
88
 
                                    gboolean              push_undo,
89
 
                                    const gchar          *undo_desc,
90
 
                                    TileManager          *tiles,
91
 
                                    GimpImageType         type,
92
 
                                    gint                  offset_x,
93
 
                                    gint                  offset_y);
 
65
  gint64        (* estimate_memsize)      (const GimpDrawable   *drawable,
 
66
                                           gint                  width,
 
67
                                           gint                  height);
 
68
  void          (* invalidate_boundary)   (GimpDrawable         *drawable);
 
69
  void          (* get_active_components) (const GimpDrawable   *drawable,
 
70
                                           gboolean             *active);
 
71
  void          (* apply_region)          (GimpDrawable         *drawable,
 
72
                                           PixelRegion          *src2PR,
 
73
                                           gboolean              push_undo,
 
74
                                           const gchar          *undo_desc,
 
75
                                           gdouble               opacity,
 
76
                                           GimpLayerModeEffects  mode,
 
77
                                           TileManager          *src1_tiles,
 
78
                                           gint                  x,
 
79
                                           gint                  y);
 
80
  void          (* replace_region)        (GimpDrawable         *drawable,
 
81
                                           PixelRegion          *src2PR,
 
82
                                           gboolean              push_undo,
 
83
                                           const gchar          *undo_desc,
 
84
                                           gdouble               opacity,
 
85
                                           PixelRegion          *maskPR,
 
86
                                           gint                  x,
 
87
                                           gint                  y);
 
88
  TileManager * (* get_tiles)             (GimpDrawable         *drawable);
 
89
  void          (* set_tiles)             (GimpDrawable         *drawable,
 
90
                                           gboolean              push_undo,
 
91
                                           const gchar          *undo_desc,
 
92
                                           TileManager          *tiles,
 
93
                                           GimpImageType         type,
 
94
                                           gint                  offset_x,
 
95
                                           gint                  offset_y);
94
96
 
95
 
  void   (* push_undo)             (GimpDrawable         *drawable,
96
 
                                    const gchar          *undo_desc,
97
 
                                    TileManager          *tiles,
98
 
                                    gboolean              sparse,
99
 
                                    gint                  x,
100
 
                                    gint                  y,
101
 
                                    gint                  width,
102
 
                                    gint                  height);
103
 
  void   (* swap_pixels)           (GimpDrawable         *drawable,
104
 
                                    TileManager          *tiles,
105
 
                                    gboolean              sparse,
106
 
                                    gint                  x,
107
 
                                    gint                  y,
108
 
                                    gint                  width,
109
 
                                    gint                  height);
 
97
  void          (* push_undo)             (GimpDrawable         *drawable,
 
98
                                           const gchar          *undo_desc,
 
99
                                           TileManager          *tiles,
 
100
                                           gboolean              sparse,
 
101
                                           gint                  x,
 
102
                                           gint                  y,
 
103
                                           gint                  width,
 
104
                                           gint                  height);
 
105
  void          (* swap_pixels)           (GimpDrawable         *drawable,
 
106
                                           TileManager          *tiles,
 
107
                                           gboolean              sparse,
 
108
                                           gint                  x,
 
109
                                           gint                  y,
 
110
                                           gint                  width,
 
111
                                           gint                  height);
110
112
};
111
113
 
112
114
 
154
156
                                                  gint                x,
155
157
                                                  gint                y);
156
158
 
157
 
TileManager   * gimp_drawable_get_tiles          (const GimpDrawable *drawable);
 
159
TileManager   * gimp_drawable_get_tiles          (GimpDrawable       *drawable);
158
160
void            gimp_drawable_set_tiles          (GimpDrawable       *drawable,
159
161
                                                  gboolean            push_undo,
160
162
                                                  const gchar        *undo_desc,
184
186
                                                  TileManager        *tiles,
185
187
                                                  gboolean            sparse);
186
188
 
187
 
TileManager   * gimp_drawable_get_shadow_tiles   (GimpDrawable       *drawable);
188
 
void            gimp_drawable_merge_shadow       (GimpDrawable       *drawable,
189
 
                                                  gboolean            push_undo,
190
 
                                                  const gchar        *undo_desc);
191
 
 
192
189
void            gimp_drawable_fill               (GimpDrawable       *drawable,
193
190
                                                  const GimpRGB      *color,
194
191
                                                  const GimpPattern  *pattern);