← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/display/gimpdisplayshell-layer-select.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/display/gimpdisplayshell-layer-select.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
44
44
struct _LayerSelect
45
45
{
46
46
  GtkWidget *shell;
47
 
  GtkWidget *preview;
 
47
  GtkWidget *view;
48
48
  GtkWidget *label;
49
49
 
50
 
  GimpImage *gimage;
 
50
  GimpImage *image;
51
51
  GimpLayer *orig_layer;
52
52
};
53
53
 
54
54
 
55
55
/*  local function prototypes  */
56
56
 
57
 
static LayerSelect * layer_select_new       (GimpImage   *gimage,
 
57
static LayerSelect * layer_select_new       (GimpImage   *image,
58
58
                                             GimpLayer   *layer,
59
 
                                             gint         preview_size);
 
59
                                             gint         view_size);
60
60
static void          layer_select_destroy   (LayerSelect *layer_select,
61
61
                                             guint32      time);
62
62
static void          layer_select_advance   (LayerSelect *layer_select,
74
74
                                      guint32           time)
75
75
{
76
76
  LayerSelect *layer_select;
77
 
  GimpImage   *gimage;
 
77
  GimpImage   *image;
78
78
  GimpLayer   *layer;
79
79
 
80
80
  g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
81
81
 
82
 
  gimage = shell->gdisp->gimage;
 
82
  image = shell->display->image;
83
83
 
84
 
  layer = gimp_image_get_active_layer (gimage);
 
84
  layer = gimp_image_get_active_layer (image);
85
85
 
86
86
  if (! layer)
87
87
    return;
88
88
 
89
 
  layer_select = layer_select_new (gimage, layer,
90
 
                                   gimage->gimp->config->layer_preview_size);
 
89
  layer_select = layer_select_new (image, layer,
 
90
                                   image->gimp->config->layer_preview_size);
91
91
  layer_select_advance (layer_select, move);
92
92
 
93
93
  gtk_window_set_screen (GTK_WINDOW (layer_select->shell),
102
102
/*  private functions  */
103
103
 
104
104
static LayerSelect *
105
 
layer_select_new (GimpImage *gimage,
 
105
layer_select_new (GimpImage *image,
106
106
                  GimpLayer *layer,
107
 
                  gint       preview_size)
 
107
                  gint       view_size)
108
108
{
109
109
  LayerSelect *layer_select;
110
110
  GtkWidget   *frame1;
114
114
 
115
115
  layer_select = g_new0 (LayerSelect, 1);
116
116
 
117
 
  layer_select->gimage     = gimage;
 
117
  layer_select->image      = image;
118
118
  layer_select->orig_layer = layer;
119
119
 
120
120
  layer_select->shell = gtk_window_new (GTK_WINDOW_POPUP);
144
144
  gtk_container_add (GTK_CONTAINER (frame2), hbox);
145
145
  gtk_widget_show (hbox);
146
146
 
147
 
  /*  The preview  */
 
147
  /*  The view  */
148
148
  alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
149
149
  gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, FALSE, 0);
150
150
  gtk_widget_show (alignment);
151
151
 
152
 
  layer_select->preview = gimp_view_new_by_types (GIMP_TYPE_VIEW,
153
 
                                                  GIMP_TYPE_LAYER,
154
 
                                                  preview_size, 1, FALSE);
155
 
  gimp_view_set_viewable (GIMP_VIEW (layer_select->preview),
 
152
  layer_select->view =
 
153
    gimp_view_new_by_types (gimp_get_user_context (image->gimp),
 
154
                            GIMP_TYPE_VIEW,
 
155
                            GIMP_TYPE_LAYER,
 
156
                            view_size, 1, FALSE);
 
157
  gimp_view_set_viewable (GIMP_VIEW (layer_select->view),
156
158
                          GIMP_VIEWABLE (layer));
157
 
  gtk_container_add (GTK_CONTAINER (alignment), layer_select->preview);
158
 
  gtk_widget_show (layer_select->preview);
 
159
  gtk_container_add (GTK_CONTAINER (alignment), layer_select->view);
 
160
  gtk_widget_show (layer_select->view);
159
161
  gtk_widget_show (alignment);
160
162
 
161
163
  /*  the layer name label */
176
178
  gtk_widget_destroy (layer_select->shell);
177
179
 
178
180
  if (layer_select->orig_layer !=
179
 
      gimp_image_get_active_layer (layer_select->gimage))
 
181
      gimp_image_get_active_layer (layer_select->image))
180
182
    {
181
 
      gimp_image_flush (layer_select->gimage);
 
183
      gimp_image_flush (layer_select->image);
182
184
    }
183
185
 
184
186
  g_free (layer_select);
186
188
 
187
189
static void
188
190
layer_select_advance (LayerSelect *layer_select,
189
 
                      gint         move)
 
191
                      gint         move)
190
192
{
191
193
  GimpLayer *current_layer;
192
194
  GimpLayer *next_layer;
196
198
    return;
197
199
 
198
200
  /*  If there is a floating selection, allow no advancement  */
199
 
  if (gimp_image_floating_sel (layer_select->gimage))
 
201
  if (gimp_image_floating_sel (layer_select->image))
200
202
    return;
201
203
 
202
 
  current_layer = gimp_image_get_active_layer (layer_select->gimage);
 
204
  current_layer = gimp_image_get_active_layer (layer_select->image);
203
205
 
204
 
  index = gimp_container_get_child_index (layer_select->gimage->layers,
 
206
  index = gimp_container_get_child_index (layer_select->image->layers,
205
207
                                          GIMP_OBJECT (current_layer));
206
208
 
207
209
  index += move;
208
210
 
209
211
  if (index < 0)
210
 
    index = gimp_container_num_children (layer_select->gimage->layers) - 1;
211
 
  else if (index >= gimp_container_num_children (layer_select->gimage->layers))
 
212
    index = gimp_container_num_children (layer_select->image->layers) - 1;
 
213
  else if (index >= gimp_container_num_children (layer_select->image->layers))
212
214
    index = 0;
213
215
 
214
216
  next_layer = (GimpLayer *)
215
 
    gimp_container_get_child_by_index (layer_select->gimage->layers, index);
 
217
    gimp_container_get_child_by_index (layer_select->image->layers, index);
216
218
 
217
219
  if (next_layer && next_layer != current_layer)
218
220
    {
219
 
      current_layer = gimp_image_set_active_layer (layer_select->gimage,
 
221
      current_layer = gimp_image_set_active_layer (layer_select->image,
220
222
                                                   next_layer);
221
223
 
222
224
      if (current_layer)
223
225
        {
224
 
          gimp_view_set_viewable (GIMP_VIEW (layer_select->preview),
 
226
          gimp_view_set_viewable (GIMP_VIEW (layer_select->view),
225
227
                                  GIMP_VIEWABLE (current_layer));
226
228
          gtk_label_set_text (GTK_LABEL (layer_select->label),
227
229
                              GIMP_OBJECT (current_layer)->name);
231
233
 
232
234
static gboolean
233
235
layer_select_events (GtkWidget   *widget,
234
 
                     GdkEvent    *event,
 
236
                     GdkEvent    *event,
235
237
                     LayerSelect *layer_select)
236
238
{
237
239
  GdkEventKey    *kevent;
249
251
      kevent = (GdkEventKey *) event;
250
252
 
251
253
      switch (kevent->keyval)
252
 
        {
253
 
        case GDK_Tab:
 
254
        {
 
255
        case GDK_Tab:
254
256
          layer_select_advance (layer_select, 1);
255
257
          break;
256
 
        case GDK_ISO_Left_Tab:
 
258
        case GDK_ISO_Left_Tab:
257
259
          layer_select_advance (layer_select, -1);
258
 
          break;
259
 
        }
 
260
          break;
 
261
        }
260
262
      return TRUE;
261
263
      break;
262
264
 
264
266
      kevent = (GdkEventKey *) event;
265
267
 
266
268
      switch (kevent->keyval)
267
 
        {
268
 
        case GDK_Alt_L: case GDK_Alt_R:
269
 
          kevent->state &= ~GDK_MOD1_MASK;
270
 
          break;
271
 
        case GDK_Control_L: case GDK_Control_R:
272
 
          kevent->state &= ~GDK_CONTROL_MASK;
273
 
          break;
274
 
        case GDK_Shift_L: case GDK_Shift_R:
275
 
          kevent->state &= ~GDK_SHIFT_MASK;
276
 
          break;
277
 
        }
 
269
        {
 
270
        case GDK_Alt_L: case GDK_Alt_R:
 
271
          kevent->state &= ~GDK_MOD1_MASK;
 
272
          break;
 
273
        case GDK_Control_L: case GDK_Control_R:
 
274
          kevent->state &= ~GDK_CONTROL_MASK;
 
275
          break;
 
276
        case GDK_Shift_L: case GDK_Shift_R:
 
277
          kevent->state &= ~GDK_SHIFT_MASK;
 
278
          break;
 
279
        }
278
280
 
279
281
      if (! (kevent->state & GDK_CONTROL_MASK))
280
 
        layer_select_destroy (layer_select, kevent->time);
 
282
        layer_select_destroy (layer_select, kevent->time);
281
283
 
282
284
      return TRUE;
283
285
      break;