gimpdrawable.c 17.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/* The GIMP -- an image manipulation program
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
18
19
#include <stdlib.h>
#include <math.h>
20
#include <string.h>
21
22
23
24
#include "gimpdrawableP.h"
#include "gimpsignal.h"
#include "gimage.h"
#include "gimage_mask.h"
Manish Singh's avatar
Manish Singh committed
25
#include "gimpparasite.h"
26
#include "parasitelist.h"
27
#include "undo.h"
28

29
#include "libgimp/parasite.h"
30
#include "libgimp/gimpintl.h"
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

enum {
  INVALIDATE_PREVIEW,
  LAST_SIGNAL
};

static void gimp_drawable_class_init (GimpDrawableClass *klass);
static void gimp_drawable_init	     (GimpDrawable      *drawable);
static void gimp_drawable_destroy    (GtkObject		*object);

static guint gimp_drawable_signals[LAST_SIGNAL] = { 0 };

static GimpDrawableClass *parent_class = NULL;


GtkType
Manish Singh's avatar
Manish Singh committed
47
gimp_drawable_get_type (void)
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
{
  static GtkType type;
  GIMP_TYPE_INIT(type,
		 GimpDrawable,
		 GimpDrawableClass,
		 gimp_drawable_init,
		 gimp_drawable_class_init,
		 GIMP_TYPE_OBJECT);
  return type;
}

static void
gimp_drawable_class_init (GimpDrawableClass *class)
{
  GtkObjectClass *object_class;
63
64
  GtkType type = GIMP_TYPE_DRAWABLE;

65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
  object_class = GTK_OBJECT_CLASS(class);
  parent_class = gtk_type_class (GIMP_TYPE_OBJECT);
  
  gimp_drawable_signals[INVALIDATE_PREVIEW] =
	  gimp_signal_new ("invalidate_pr", GTK_RUN_LAST, type,
			   GTK_SIGNAL_OFFSET(GimpDrawableClass,
					     invalidate_preview),
			   gimp_sigtype_void);

  gtk_object_class_add_signals (object_class, gimp_drawable_signals, LAST_SIGNAL);

  object_class->destroy = gimp_drawable_destroy;
}


/*
 *  Static variables
 */
83
static gint        global_drawable_ID  = 1;
84
85
86
87
88
89
static GHashTable *gimp_drawable_table = NULL;

/**************************/
/*  Function definitions  */

GimpDrawable*
90
gimp_drawable_get_ID (gint drawable_id)
91
92
93
94
95
96
97
98
99
{
  if (gimp_drawable_table == NULL)
    return NULL;

  return (GimpDrawable*) g_hash_table_lookup (gimp_drawable_table, 
					      (gpointer) drawable_id);
}

void
100
101
gimp_drawable_merge_shadow (GimpDrawable *drawable,
			    gint          undo)
102
103
104
105
106
107
108
109
110
111
112
{
  GImage *gimage;
  PixelRegion shadowPR;
  int x1, y1, x2, y2;

  if (! drawable) 
    return;

  if (! (gimage = gimp_drawable_gimage (drawable)))
    return;

113
114
115
  if (! gimage->shadow)
    return;

116
117
118
119
120
121
122
123
124
125
126
127
  /*  A useful optimization here is to limit the update to the
   *  extents of the selection mask, as it cannot extend beyond
   *  them.
   */
  gimp_drawable_mask_bounds (drawable, &x1, &y1, &x2, &y2);
  pixel_region_init (&shadowPR, gimage->shadow, x1, y1,
		     (x2 - x1), (y2 - y1), FALSE);
  gimage_apply_image (gimage, drawable, &shadowPR, undo, OPAQUE_OPACITY,
		      REPLACE_MODE, NULL, x1, y1);
}

void
128
129
130
131
132
gimp_drawable_fill (GimpDrawable *drawable,
		    guchar        r,
		    guchar        g,
		    guchar        b,
		    guchar        a)
133
134
135
136
137
138
{
  GImage *gimage;
  PixelRegion destPR;
  guchar c[MAX_CHANNELS];
  guchar i;

139
140
141
  g_assert (GIMP_IS_DRAWABLE (drawable));
  gimage = gimp_drawable_gimage (drawable);
  g_assert (gimage);
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

  switch (gimp_drawable_type (drawable))
    {
    case RGB_GIMAGE: case RGBA_GIMAGE:
      c[RED_PIX] = r;
      c[GREEN_PIX] = g;
      c[BLUE_PIX] = b;
      if (gimp_drawable_type (drawable) == RGBA_GIMAGE)
	c[ALPHA_PIX] = a;
      break;
    case GRAY_GIMAGE: case GRAYA_GIMAGE:
      c[GRAY_PIX] = r;
      if (gimp_drawable_type (drawable) == GRAYA_GIMAGE)
	c[ALPHA_G_PIX] = a;
      break;
    case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
      c[RED_PIX] = r;
      c[GREEN_PIX] = g;
      c[BLUE_PIX] = b;
      gimage_transform_color (gimage, drawable, c, &i, RGB);
      c[INDEXED_PIX] = i;
      if (gimp_drawable_type (drawable) == INDEXEDA_GIMAGE)
	  c[ALPHA_I_PIX] = a;
      break;
    default:
167
      g_message (_("Can't fill unknown image type."));
168
169
170
171
172
173
      break;
    }

  pixel_region_init (&destPR,
		     gimp_drawable_data (drawable),
		     0, 0,
174
		     gimp_drawable_width  (drawable),
175
176
177
178
179
180
		     gimp_drawable_height (drawable),
		     TRUE);
  color_region (&destPR, c);

}

181
gboolean
182
gimp_drawable_mask_bounds (GimpDrawable *drawable, 
183
184
185
186
			   gint         *x1,
			   gint         *y1,
			   gint         *x2,
			   gint         *y2)
187
188
{
  GImage *gimage;
189
  gint off_x, off_y;
190
191
192
193
194
195
196
197
198
199

  if (! drawable)
    return FALSE;

  if (! (gimage = gimp_drawable_gimage (drawable)))
    return FALSE;

  if (gimage_mask_bounds (gimage, x1, y1, x2, y2))
    {
      gimp_drawable_offsets (drawable, &off_x, &off_y);
200
      *x1 = CLAMP (*x1 - off_x, 0, gimp_drawable_width  (drawable));
201
      *y1 = CLAMP (*y1 - off_y, 0, gimp_drawable_height (drawable));
202
      *x2 = CLAMP (*x2 - off_x, 0, gimp_drawable_width  (drawable));
203
204
205
206
207
      *y2 = CLAMP (*y2 - off_y, 0, gimp_drawable_height (drawable));
      return TRUE;
    }
  else
    {
208
      *x2 = gimp_drawable_width  (drawable);
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
      *y2 = gimp_drawable_height (drawable);
      return FALSE;
    }
}

void
gimp_drawable_invalidate_preview (GimpDrawable *drawable)
{
  GImage *gimage;

  if (! drawable)
    return;

  drawable->preview_valid = FALSE;
#if 0
224
225
  gtk_signal_emit (GTK_OBJECT (drawable),
		   gimp_drawable_signals[INVALIDATE_PREVIEW]);
226
227
228
229
230
231
232
233
234
235
236
237
238
239
#endif
  gimage = gimp_drawable_gimage (drawable);
  if (gimage)
    {
      gimage->comp_preview_valid[0] = FALSE;
      gimage->comp_preview_valid[1] = FALSE;
      gimage->comp_preview_valid[2] = FALSE;
    }
}


GimpImage *
gimp_drawable_gimage (GimpDrawable *drawable)
{
240
  g_assert (GIMP_IS_DRAWABLE (drawable));
241
242
243
244
	
  return drawable->gimage;
}

245
void
246
247
gimp_drawable_set_gimage (GimpDrawable *drawable,
			  GimpImage    *gimage)
248
{
249
250
  g_assert (GIMP_IS_DRAWABLE (drawable));

251
252
  if (gimage == NULL)
    drawable->tattoo = 0;
253
  else if (drawable->tattoo == 0 || drawable->gimage != gimage )
254
255
    drawable->tattoo = gimp_image_get_new_tattoo (gimage);

256
  drawable->gimage = gimage;
257
258
}

259
260
261
262
263
264
265
266
gboolean
gimp_drawable_has_alpha (GimpDrawable *drawable)
{
  if (drawable)
    return drawable->has_alpha;
  else
    return FALSE;
}
267

268
GimpImageType
269
270
271
272
273
274
275
276
gimp_drawable_type (GimpDrawable *drawable)
{
  if (drawable)
    return drawable->type;
  else
    return -1;
}

277
278
GimpImageType
gimp_drawable_type_with_alpha (GimpDrawable *drawable)
279
{
280
281
282
283
284
285
  GimpImageType type = gimp_drawable_type (drawable);

  gboolean has_alpha = gimp_drawable_has_alpha (drawable);

  if (has_alpha)
    return type;
286
  else
287
288
289
290
291
292
293
294
    switch (type)
      {
      case RGB_GIMAGE:
	return RGBA_GIMAGE; break;
      case GRAY_GIMAGE:
	return GRAYA_GIMAGE; break;
      case INDEXED_GIMAGE:
	return INDEXEDA_GIMAGE; break;
295
296
297
      default:
	  g_assert_not_reached ();
	  break;
298
299
      }
  return 0;
300
301
}

302
gboolean
303
304
305
306
307
gimp_drawable_visible (GimpDrawable *drawable)
{
  return drawable->visible;
}

308
gchar *
309
gimp_drawable_get_name (GimpDrawable *drawable)
310
311
312
313
{
  return drawable->name;
}

314
void
315
316
gimp_drawable_set_name (GimpDrawable *drawable,
			gchar        *name)
317
318
319
{
  GSList *list, *listb, *base_list;
  GimpDrawable *drawableb;
320
321
322
323
324
325
  gint number = 1;
  gchar *newname;
  gchar *ext;
  gchar numberbuf[20];

  g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
326
327

  if (drawable->name)
328
329
330
331
332
    {
      g_free (drawable->name);
      drawable->name = NULL;
    }

333
  if (drawable->gimage == 0 || drawable->gimage->layers == 0)
334
335
336
337
338
339
340
    {
      /* no other layers to check name against */
      drawable->name = g_strdup (name);
      return;
    }

  if (GIMP_IS_LAYER (drawable))
341
    base_list = drawable->gimage->layers;
342
  else if (GIMP_IS_CHANNEL (drawable))
343
344
345
346
347
348
    base_list = drawable->gimage->channels;
  else
    base_list = NULL;

  list = base_list;
  while (list)
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
    {
      drawableb = GIMP_DRAWABLE (list->data);
      if (drawable != drawableb &&
	  strcmp (name, gimp_drawable_get_name (drawableb)) == 0)
	{ /* names conflict */
	  newname = g_malloc (strlen (name) + 10); /* if this aint enough 
						      yer screwed */
	  strcpy (newname, name);
	  if ((ext = strrchr (newname, '#')))
	    {
	      number = atoi(ext+1);
	      /* Check if there really was the number we think after the # */
	      sprintf (numberbuf, "#%d", number);
	      if (strcmp (ext, numberbuf) != 0)
		{
		  /* No, so just ignore the # */
		  number = 1;
		  ext = &newname[strlen (newname)];
		}
	    }
	  else
	    {
	      number = 1;
	      ext = &newname[strlen (newname)];
	    }
	  sprintf (ext, "#%d", number+1);
375
	  listb = base_list;
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
	  while (listb) /* make sure the new name is unique */
	    {
	      drawableb = GIMP_DRAWABLE (listb->data);
	      if (drawable !=
		  drawableb && strcmp (newname,
				       gimp_drawable_get_name(drawableb)) == 0)
		{
		  number++;
		  sprintf (ext, "#%d", number+1);
		  /* Rescan from beginning */
		  listb = base_list;
		  continue;
		}
	      listb = listb->next;
	    }
	  drawable->name = g_strdup (newname);
	  g_free (newname);
	  return;
394
	}
395
      list = list->next;
396
    }
397
  drawable->name = g_strdup (name);
398
399
}

400
401
402
403
guchar *
gimp_drawable_get_color_at (GimpDrawable *drawable,
			    gint          x,
			    gint          y)
404
405
{
  Tile *tile;
406
407
  guchar *src;
  guchar *dest;
408
409

  if (!drawable ||
410
      (!gimp_drawable_gimage (drawable) && gimp_drawable_indexed (drawable)) 
411
412
      || x < 0 || y < 0 ||
      x >= drawable->width || y >= drawable->height)
413
414
415
416
    {
      return NULL;
    }
  dest = g_new (guchar, 5);
417
418
419
  tile = tile_manager_get_tile (gimp_drawable_data (drawable), x, y,
				TRUE, FALSE);
  src = tile_data_pointer (tile, x % TILE_WIDTH, y % TILE_HEIGHT);
420
  gimp_image_get_color (gimp_drawable_gimage (drawable),
421
422
423
424
425
			gimp_drawable_type (drawable), dest, src);
  if(TYPE_HAS_ALPHA(gimp_drawable_type (drawable)))
    dest[3] = src[gimp_drawable_bytes (drawable) - 1];
  else
    dest[3] = 255;
426
  if (gimp_drawable_indexed (drawable))
427
428
429
430
431
432
433
    dest[4] = src[0];
  else
    dest[4] = 0;
  tile_release (tile, FALSE);
  return dest;
}

434
Parasite *
435
436
gimp_drawable_find_parasite (const GimpDrawable *drawable,
			     const gchar        *name)
437
{
438
  return parasite_list_find (drawable->parasites, name);
439
440
}

441
442
443
444
static void
list_func (gchar      *key,
	   Parasite   *p,
	   gchar    ***cur)
Marc Lehmann's avatar
Marc Lehmann committed
445
{
446
  *(*cur)++ = (gchar *) g_strdup (key);
Marc Lehmann's avatar
Marc Lehmann committed
447
448
}

449
450
451
gchar **
gimp_drawable_parasite_list (GimpDrawable *drawable,
			     gint         *count)
Marc Lehmann's avatar
Marc Lehmann committed
452
{
453
  gchar **list, **cur;
Marc Lehmann's avatar
Marc Lehmann committed
454
455

  *count = parasite_list_length (drawable->parasites);
456
  cur = list = (gchar **) g_malloc (sizeof (gchar *) * *count);
Marc Lehmann's avatar
Marc Lehmann committed
457

458
  parasite_list_foreach (drawable->parasites, (GHFunc) list_func, &cur);
Marc Lehmann's avatar
Marc Lehmann committed
459
460
461
462
  
  return list;
}

463
void
464
465
gimp_drawable_attach_parasite (GimpDrawable *drawable,
			       Parasite     *parasite)
466
{
jaycox's avatar
jaycox committed
467
468
  /* only set the dirty bit manually if we can be saved and the new
     parasite differs from the current one and we arn't undoable */
469
470
  if (parasite_is_undoable (parasite))
    {
471
472
473
      /* do a group in case we have attach_parent set */
      undo_push_group_start (drawable->gimage, PARASITE_ATTACH_UNDO);

474
475
      undo_push_drawable_parasite (drawable->gimage, drawable, parasite);
    }
jaycox's avatar
jaycox committed
476
  else if (parasite_is_persistent(parasite) &&
477
478
479
	   !parasite_compare( parasite,
			      gimp_drawable_find_parasite
			      (drawable, parasite_name (parasite))))
480
    undo_push_cantundo (drawable->gimage, _("parasite attach to drawable"));
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497

  parasite_list_add (drawable->parasites, parasite);
  if (parasite_has_flag (parasite, PARASITE_ATTACH_PARENT))
    {
      parasite_shift_parent (parasite);
      gimp_image_attach_parasite (drawable->gimage, parasite);
    }
  else if (parasite_has_flag (parasite, PARASITE_ATTACH_GRANDPARENT))
    {
      parasite_shift_parent (parasite);
      parasite_shift_parent (parasite);
      gimp_attach_parasite (parasite);
    }
  if (parasite_is_undoable (parasite))
    {
      undo_push_group_end (drawable->gimage);
    }
498
499
500
}

void
501
502
gimp_drawable_detach_parasite (GimpDrawable *drawable,
			       const gchar  *parasite)
503
{
504
  Parasite *p;
505
506

  if (!(p = parasite_list_find (drawable->parasites, parasite)))
507
    return;
508
509

  if (parasite_is_undoable (p))
jaycox's avatar
jaycox committed
510
    undo_push_drawable_parasite_remove (drawable->gimage, drawable,
511
512
					parasite_name (p));
  else if (parasite_is_persistent (p))
513
    undo_push_cantundo (drawable->gimage, _("detach parasite from drawable"));
514
515

  parasite_list_remove (drawable->parasites, parasite);
516
517
}

518
Tattoo
519
gimp_drawable_get_tattoo (const GimpDrawable *drawable)
520
521
522
{
  return drawable->tattoo;
}
523

524
gboolean
525
526
527
528
gimp_drawable_color (GimpDrawable *drawable)
{
  if (gimp_drawable_type (drawable) == RGBA_GIMAGE ||
      gimp_drawable_type (drawable) == RGB_GIMAGE)
529
    return TRUE;
530
  else
531
    return FALSE;
532
533
}

534
gboolean
535
536
537
538
gimp_drawable_gray (GimpDrawable *drawable)
{
  if (gimp_drawable_type (drawable) == GRAYA_GIMAGE ||
      gimp_drawable_type (drawable) == GRAY_GIMAGE)
539
    return TRUE;
540
  else
541
    return FALSE;
542
543
}

544
gboolean
545
546
547
548
gimp_drawable_indexed (GimpDrawable *drawable)
{
  if (gimp_drawable_type (drawable) == INDEXEDA_GIMAGE ||
      gimp_drawable_type (drawable) == INDEXED_GIMAGE)
549
    return TRUE;
550
  else
551
    return FALSE;
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
}

TileManager *
gimp_drawable_data (GimpDrawable *drawable)
{
  if (drawable) 
    return drawable->tiles;
  else
    return NULL;
}

TileManager *
gimp_drawable_shadow (GimpDrawable *drawable)
{
  GImage *gimage;

  if (! (gimage = gimp_drawable_gimage (drawable)))
    return NULL;

  if (drawable) 
    return gimage_shadow (gimage, drawable->width, drawable->height, 
			  drawable->bytes);
  else
    return NULL;
}

int
gimp_drawable_bytes (GimpDrawable *drawable)
{
  if (drawable) 
    return drawable->bytes;
  else
    return -1;
}

587
gint
588
589
590
591
592
593
594
595
gimp_drawable_width (GimpDrawable *drawable)
{
  if (drawable) 
    return drawable->width;
  else
    return -1;
}

596
gint
597
598
599
600
601
602
603
604
605
gimp_drawable_height (GimpDrawable *drawable)
{
  if (drawable) 
    return drawable->height;
  else
    return -1;
}

void
606
607
608
gimp_drawable_offsets (GimpDrawable *drawable,
		       gint         *off_x,
		       gint         *off_y)
609
610
611
612
613
614
615
616
617
618
{
  if (drawable) 
    {
      *off_x = drawable->offset_x;
      *off_y = drawable->offset_y;
    }
  else
    *off_x = *off_y = 0;
}

619
guchar *
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
gimp_drawable_cmap (GimpDrawable *drawable)
{
  GImage *gimage;

  if ((gimage = gimp_drawable_gimage (drawable)))
    return gimage->cmap;
  else
    return NULL;
}

void
gimp_drawable_deallocate (GimpDrawable *drawable)
{
  if (drawable->tiles)
    tile_manager_destroy (drawable->tiles);
}

static void
gimp_drawable_init (GimpDrawable *drawable)
{
640
641
642
643
644
645
646
647
648
649
650
  drawable->name          = NULL;
  drawable->tiles         = NULL;
  drawable->visible       = FALSE;
  drawable->width         = 0;
  drawable->height        = 0;
  drawable->offset_x      = 0;
  drawable->offset_y      = 0;
  drawable->bytes         = 0;
  drawable->gimage        = NULL;
  drawable->type          = -1;
  drawable->has_alpha     = FALSE;
651
  drawable->preview_cache = NULL;
652
  drawable->preview_valid = FALSE;
653
654
  drawable->parasites     = parasite_list_new ();
  drawable->tattoo        = 0;
655
656

  drawable->ID = global_drawable_ID++;
657

658
659
  if (gimp_drawable_table == NULL)
    gimp_drawable_table = g_hash_table_new (g_direct_hash, NULL);
660

661
662
663
664
665
666
667
668
  g_hash_table_insert (gimp_drawable_table, (gpointer) drawable->ID,
		       (gpointer) drawable);
}

static void
gimp_drawable_destroy (GtkObject *object)
{
  GimpDrawable *drawable;
669

670
671
672
673
674
675
676
677
678
679
680
681
682
  g_return_if_fail (object != NULL);
  g_return_if_fail (GIMP_IS_DRAWABLE (object));

  drawable = GIMP_DRAWABLE (object);

  g_hash_table_remove (gimp_drawable_table, (gpointer) drawable->ID);
  
  if (drawable->name)
    g_free (drawable->name);

  if (drawable->tiles)
    tile_manager_destroy (drawable->tiles);

683
  if (drawable->preview_cache)
684
    gimp_preview_cache_invalidate (&drawable->preview_cache);
685

686
  if (drawable->parasites)
687
    gtk_object_unref (GTK_OBJECT (drawable->parasites));
688

689
  if (GTK_OBJECT_CLASS (parent_class)->destroy)
690
    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
691
692
693
}

void
694
695
696
697
698
699
gimp_drawable_configure (GimpDrawable  *drawable,
			 GimpImage     *gimage,
			 gint           width,
			 gint           height, 
			 GimpImageType  type,
			 gchar         *name)
700
{
701
702
  gint bpp;
  gboolean alpha;
703
704

  if (!name)
705
    name = _("unnamed");
706
707
708
709

  switch (type)
    {
    case RGB_GIMAGE:
710
      bpp = 3; alpha = FALSE; break;
711
    case GRAY_GIMAGE:
712
      bpp = 1; alpha = FALSE; break;
713
    case RGBA_GIMAGE:
714
      bpp = 4; alpha = TRUE; break;
715
    case GRAYA_GIMAGE:
716
      bpp = 2; alpha = TRUE; break;
717
    case INDEXED_GIMAGE:
718
      bpp = 1; alpha = FALSE; break;
719
    case INDEXEDA_GIMAGE:
720
      bpp = 2; alpha = TRUE; break;
721
    default:
722
      g_message (_("Layer type %d not supported."), type);
723
724
725
      return;
    }

726
727
728
729
730
  drawable->name      = NULL;
  drawable->width     = width;
  drawable->height    = height;
  drawable->bytes     = bpp;
  drawable->type      = type;
731
  drawable->has_alpha = alpha;
732
733
  drawable->offset_x  = 0;
  drawable->offset_y  = 0;
734
735
736
737
738
739

  if (drawable->tiles)
    tile_manager_destroy (drawable->tiles);
  drawable->tiles = tile_manager_new (width, height, bpp);
  drawable->visible = TRUE;

740
  if (gimage)
741
    gimp_drawable_set_gimage (drawable, gimage);
742

743
  gimp_drawable_set_name (drawable, name);
744

745
  /*  preview variables  */
746
  drawable->preview_cache = NULL;
747
748
  drawable->preview_valid = FALSE;
}