← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/tools/gimpcolorizetool.c

  • 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/tools/gimpcolorizetool.c
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
20
20
 
21
21
#include <gtk/gtk.h>
22
22
 
23
 
#include "libgimpcolor/gimpcolor.h"
24
 
#include "libgimpmath/gimpmath.h"
25
23
#include "libgimpwidgets/gimpwidgets.h"
26
24
 
27
25
#include "tools-types.h"
56
54
 
57
55
/*  local function prototypes  */
58
56
 
59
 
static void     gimp_colorize_tool_class_init  (GimpColorizeToolClass *klass);
60
 
static void     gimp_colorize_tool_init        (GimpColorizeTool      *tool);
61
 
 
62
57
static void     gimp_colorize_tool_finalize    (GObject          *object);
63
58
 
64
59
static gboolean gimp_colorize_tool_initialize  (GimpTool         *tool,
65
 
                                                GimpDisplay      *gdisp);
 
60
                                                GimpDisplay      *display,
 
61
                                                GError          **error);
66
62
 
67
 
static void     gimp_colorize_tool_map         (GimpImageMapTool *image_map_tool);
68
 
static void     gimp_colorize_tool_dialog      (GimpImageMapTool *image_map_tool);
69
 
static void     gimp_colorize_tool_reset       (GimpImageMapTool *image_map_tool);
 
63
static void     gimp_colorize_tool_map         (GimpImageMapTool *im_tool);
 
64
static void     gimp_colorize_tool_dialog      (GimpImageMapTool *im_tool);
 
65
static void     gimp_colorize_tool_reset       (GimpImageMapTool *im_tool);
70
66
 
71
67
static void     colorize_update                (GimpColorizeTool *col_tool,
72
68
                                                gint              update);
78
74
                                                GimpColorizeTool *col_tool);
79
75
 
80
76
 
81
 
/*  private variables  */
82
 
 
83
 
static GimpImageMapToolClass *parent_class = NULL;
84
 
 
85
 
 
86
 
/*  public functions  */
 
77
G_DEFINE_TYPE (GimpColorizeTool, gimp_colorize_tool, GIMP_TYPE_IMAGE_MAP_TOOL)
 
78
 
 
79
#define parent_class gimp_colorize_tool_parent_class
 
80
 
87
81
 
88
82
void
89
83
gimp_colorize_tool_register (GimpToolRegisterCallback  callback,
94
88
                0,
95
89
                "gimp-colorize-tool",
96
90
                _("Colorize"),
97
 
                _("Colorize the image"),
 
91
                _("Colorize Tool: Colorize the image"),
98
92
                N_("Colori_ze..."), NULL,
99
93
                NULL, GIMP_HELP_TOOL_COLORIZE,
100
94
                GIMP_STOCK_TOOL_COLORIZE,
101
95
                data);
102
96
}
103
97
 
104
 
GType
105
 
gimp_colorize_tool_get_type (void)
106
 
{
107
 
  static GType tool_type = 0;
108
 
 
109
 
  if (! tool_type)
110
 
    {
111
 
      static const GTypeInfo tool_info =
112
 
      {
113
 
        sizeof (GimpColorizeToolClass),
114
 
        (GBaseInitFunc) NULL,
115
 
        (GBaseFinalizeFunc) NULL,
116
 
        (GClassInitFunc) gimp_colorize_tool_class_init,
117
 
        NULL,           /* class_finalize */
118
 
        NULL,           /* class_data     */
119
 
        sizeof (GimpColorizeTool),
120
 
        0,              /* n_preallocs    */
121
 
        (GInstanceInitFunc) gimp_colorize_tool_init,
122
 
      };
123
 
 
124
 
      tool_type = g_type_register_static (GIMP_TYPE_IMAGE_MAP_TOOL,
125
 
                                          "GimpColorizeTool",
126
 
                                          &tool_info, 0);
127
 
    }
128
 
 
129
 
  return tool_type;
130
 
}
131
 
 
132
 
 
133
 
/*  private functions  */
134
 
 
135
98
static void
136
99
gimp_colorize_tool_class_init (GimpColorizeToolClass *klass)
137
100
{
138
 
  GObjectClass          *object_class;
139
 
  GimpToolClass         *tool_class;
140
 
  GimpImageMapToolClass *image_map_tool_class;
141
 
 
142
 
  object_class         = G_OBJECT_CLASS (klass);
143
 
  tool_class           = GIMP_TOOL_CLASS (klass);
144
 
  image_map_tool_class = GIMP_IMAGE_MAP_TOOL_CLASS (klass);
145
 
 
146
 
  parent_class = g_type_class_peek_parent (klass);
147
 
 
148
 
  object_class->finalize       = gimp_colorize_tool_finalize;
149
 
 
150
 
  tool_class->initialize       = gimp_colorize_tool_initialize;
151
 
 
152
 
  image_map_tool_class->shell_desc = _("Colorize the Image");
153
 
 
154
 
  image_map_tool_class->map    = gimp_colorize_tool_map;
155
 
  image_map_tool_class->dialog = gimp_colorize_tool_dialog;
156
 
  image_map_tool_class->reset  = gimp_colorize_tool_reset;
 
101
  GObjectClass          *object_class  = G_OBJECT_CLASS (klass);
 
102
  GimpToolClass         *tool_class    = GIMP_TOOL_CLASS (klass);
 
103
  GimpImageMapToolClass *im_tool_class = GIMP_IMAGE_MAP_TOOL_CLASS (klass);
 
104
 
 
105
  object_class->finalize    = gimp_colorize_tool_finalize;
 
106
 
 
107
  tool_class->initialize    = gimp_colorize_tool_initialize;
 
108
 
 
109
  im_tool_class->shell_desc = _("Colorize the Image");
 
110
 
 
111
  im_tool_class->map        = gimp_colorize_tool_map;
 
112
  im_tool_class->dialog     = gimp_colorize_tool_dialog;
 
113
  im_tool_class->reset      = gimp_colorize_tool_reset;
157
114
}
158
115
 
159
116
static void
179
136
}
180
137
 
181
138
static gboolean
182
 
gimp_colorize_tool_initialize (GimpTool    *tool,
183
 
                               GimpDisplay *gdisp)
 
139
gimp_colorize_tool_initialize (GimpTool     *tool,
 
140
                               GimpDisplay  *display,
 
141
                               GError      **error)
184
142
{
185
143
  GimpColorizeTool *col_tool = GIMP_COLORIZE_TOOL (tool);
186
144
  GimpDrawable     *drawable;
187
145
 
188
 
  drawable = gimp_image_active_drawable (gdisp->gimage);
 
146
  drawable = gimp_image_active_drawable (display->image);
189
147
 
190
148
  if (! drawable)
191
149
    return FALSE;
192
150
 
193
151
  if (! gimp_drawable_is_rgb (drawable))
194
152
    {
195
 
      g_message (_("Colorize operates only on RGB color layers."));
 
153
      g_set_error (error, 0, 0,
 
154
                   _("Colorize operates only on RGB color layers."));
196
155
      return FALSE;
197
156
    }
198
157
 
199
158
  colorize_init (col_tool->colorize);
200
159
 
201
 
  GIMP_TOOL_CLASS (parent_class)->initialize (tool, gdisp);
 
160
  GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
202
161
 
203
162
  colorize_update (col_tool, ALL);
204
163
 
256
215
                               NULL, NULL);
257
216
  col_tool->hue_data = GTK_ADJUSTMENT (data);
258
217
  slider = GIMP_SCALE_ENTRY_SCALE (data);
259
 
  gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
 
218
  gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_CONTINUOUS);
260
219
 
261
 
  g_signal_connect (data, "value_changed",
 
220
  g_signal_connect (data, "value-changed",
262
221
                    G_CALLBACK (colorize_hue_adj_update),
263
222
                    col_tool);
264
223
 
270
229
                               NULL, NULL);
271
230
  col_tool->saturation_data = GTK_ADJUSTMENT (data);
272
231
  slider = GIMP_SCALE_ENTRY_SCALE (data);
273
 
  gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
 
232
  gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_CONTINUOUS);
274
233
 
275
 
  g_signal_connect (col_tool->saturation_data, "value_changed",
 
234
  g_signal_connect (col_tool->saturation_data, "value-changed",
276
235
                    G_CALLBACK (colorize_saturation_adj_update),
277
236
                    col_tool);
278
237
 
284
243
                               NULL, NULL);
285
244
  col_tool->lightness_data = GTK_ADJUSTMENT (data);
286
245
  slider = GIMP_SCALE_ENTRY_SCALE (data);
287
 
  gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
 
246
  gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_CONTINUOUS);
288
247
 
289
 
  g_signal_connect (data, "value_changed",
 
248
  g_signal_connect (data, "value-changed",
290
249
                    G_CALLBACK (colorize_lightness_adj_update),
291
250
                    col_tool);
292
251
}