gtkimage.c 27.5 KB
Newer Older
Elliot Lee's avatar
Elliot Lee committed
1 2 3 4
/* GTK - The GIMP Toolkit
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
Elliot Lee's avatar
Elliot Lee committed
6 7 8 9 10 11
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
12
 * Lesser General Public License for more details.
Elliot Lee's avatar
Elliot Lee committed
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15 16 17
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
Elliot Lee's avatar
Elliot Lee committed
18
 */
19 20

/*
21
 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
22 23 24 25 26
 * file for a list of people on the GTK+ Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
 */

Elliot Lee's avatar
Elliot Lee committed
27 28
#include "gtkcontainer.h"
#include "gtkimage.h"
29
#include "gtkiconfactory.h"
Elliot Lee's avatar
Elliot Lee committed
30

31 32 33 34 35 36
static void gtk_image_class_init   (GtkImageClass  *klass);
static void gtk_image_init         (GtkImage       *image);
static gint gtk_image_expose       (GtkWidget      *widget,
                                    GdkEventExpose *event);
static void gtk_image_size_request (GtkWidget      *widget,
                                    GtkRequisition *requisition);
37
static void gtk_image_destroy      (GtkObject      *object);
38
static void gtk_image_clear        (GtkImage       *image);
39
static void gtk_image_reset        (GtkImage       *image);
40 41 42
static void gtk_image_update_size  (GtkImage       *image,
                                    gint            image_width,
                                    gint            image_height);
Elliot Lee's avatar
Elliot Lee committed
43

44
static gpointer parent_class;
Elliot Lee's avatar
Elliot Lee committed
45

46
GtkType
47
gtk_image_get_type (void)
Elliot Lee's avatar
Elliot Lee committed
48
{
49
  static GtkType image_type = 0;
Elliot Lee's avatar
Elliot Lee committed
50 51 52

  if (!image_type)
    {
53
      static const GtkTypeInfo image_info =
Elliot Lee's avatar
Elliot Lee committed
54 55 56 57 58 59
      {
	"GtkImage",
	sizeof (GtkImage),
	sizeof (GtkImageClass),
	(GtkClassInitFunc) gtk_image_class_init,
	(GtkObjectInitFunc) gtk_image_init,
60 61
	/* reserved_1 */ NULL,
        /* reserved_2 */ NULL,
62
        (GtkClassInitFunc) NULL,
Elliot Lee's avatar
Elliot Lee committed
63 64
      };

65
      image_type = gtk_type_unique (GTK_TYPE_MISC, &image_info);
Elliot Lee's avatar
Elliot Lee committed
66 67 68 69 70 71 72 73
    }

  return image_type;
}

static void
gtk_image_class_init (GtkImageClass *class)
{
74
  GtkObjectClass *object_class;
Elliot Lee's avatar
Elliot Lee committed
75 76
  GtkWidgetClass *widget_class;

77
  parent_class = g_type_class_peek_parent (class);
78 79

  object_class = (GtkObjectClass *) class;
80
  
81 82
  object_class->destroy = gtk_image_destroy;

Elliot Lee's avatar
Elliot Lee committed
83 84 85
  widget_class = (GtkWidgetClass*) class;

  widget_class->expose_event = gtk_image_expose;
86
  widget_class->size_request = gtk_image_size_request;
Elliot Lee's avatar
Elliot Lee committed
87 88 89 90 91 92 93
}

static void
gtk_image_init (GtkImage *image)
{
  GTK_WIDGET_SET_FLAGS (image, GTK_NO_WINDOW);

94
  image->storage_type = GTK_IMAGE_EMPTY;
Elliot Lee's avatar
Elliot Lee committed
95 96
}

97 98 99 100 101 102 103 104 105 106 107
static void
gtk_image_destroy (GtkObject *object)
{
  GtkImage *image = GTK_IMAGE (object);

  gtk_image_clear (image);
  
  GTK_OBJECT_CLASS (parent_class)->destroy (object);
}


108 109 110 111 112 113 114 115 116 117 118 119 120
/**
 * gtk_image_new_from_pixmap:
 * @pixmap: a #GdkPixmap, or %NULL
 * @mask: a #GdkBitmap, or %NULL
 * 
 * Creates a #GtkImage widget displaying @pixmap with a @mask.
 * A #GdkImage is a server-side image buffer in the pixel format of the
 * current display. The #GtkImage does not assume a reference to the
 * pixmap or mask; you still need to unref them if you own references.
 * #GtkImage will add its own reference rather than adopting yours.
 * 
 * Return value: a new #GtkImage
 **/
Elliot Lee's avatar
Elliot Lee committed
121
GtkWidget*
122 123
gtk_image_new_from_pixmap (GdkPixmap *pixmap,
                           GdkBitmap *mask)
Elliot Lee's avatar
Elliot Lee committed
124 125 126
{
  GtkImage *image;

127 128 129 130 131 132 133
  image = gtk_type_new (GTK_TYPE_IMAGE);

  gtk_image_set_from_pixmap (image, pixmap, mask);

  return GTK_WIDGET (image);
}

134 135 136 137 138 139 140 141 142 143 144 145 146 147
/**
 * gtk_image_new_from_image:
 * @image: a #GdkImage, or %NULL
 * @mask: a #GdkBitmap, or %NULL 
 * 
 * Creates a #GtkImage widget displaying a @image with a @mask.
 * A #GdkImage is a client-side image buffer in the pixel format of the
 * current display.
 * The #GtkImage does not assume a reference to the
 * image or mask; you still need to unref them if you own references.
 * #GtkImage will add its own reference rather than adopting yours.
 * 
 * Return value: a new #GtkImage
 **/
148 149 150 151 152
GtkWidget*
gtk_image_new_from_image  (GdkImage  *gdk_image,
                           GdkBitmap *mask)
{
  GtkImage *image;
Elliot Lee's avatar
Elliot Lee committed
153

154
  image = gtk_type_new (GTK_TYPE_IMAGE);
Elliot Lee's avatar
Elliot Lee committed
155

156 157 158 159 160
  gtk_image_set_from_image (image, gdk_image, mask);

  return GTK_WIDGET (image);
}

161 162 163 164 165 166 167 168 169 170 171 172
/**
 * gtk_image_new_from_file:
 * @filename: a filename
 * 
 * Creates a new #GtkImage displaying the file @filename. If the
 * file isn't found or can't be loaded, the #GtkImage will display
 * a "broken image" icon. If you need to detect failures to load
 * the file, use gdk_pixbuf_new_from_file() to load the file yourself,
 * then create the #GtkImage from the pixbuf.
 * 
 * Return value: a new #GtkImage
 **/
173 174 175 176 177 178 179 180 181 182 183 184
GtkWidget*
gtk_image_new_from_file   (const gchar *filename)
{
  GtkImage *image;

  image = gtk_type_new (GTK_TYPE_IMAGE);

  gtk_image_set_from_file (image, filename);

  return GTK_WIDGET (image);
}

185 186 187 188 189 190 191 192 193
/**
 * gtk_image_new_from_pixbuf:
 * @pixbuf: a #GdkPixbuf, or %NULL
 * 
 * Creates a new #GtkImage displaying @pixbuf.
 * The #GtkImage does not assume a reference to the
 * pixbuf; you still need to unref it if you own references.
 * #GtkImage will add its own reference rather than adopting yours.
 * 
194 195 196 197
 * Note that this function just creates an #GtkImage from the pixbuf.  The
 * #GtkImage created will not react to state changes.  Should you want that, you
 * should use @gtk_image_new_from_icon_set.
 * 
198 199
 * Return value: a new #GtkImage
 **/
200 201 202 203 204 205 206 207 208 209 210 211
GtkWidget*
gtk_image_new_from_pixbuf (GdkPixbuf *pixbuf)
{
  GtkImage *image;

  image = gtk_type_new (GTK_TYPE_IMAGE);

  gtk_image_set_from_pixbuf (image, pixbuf);

  return GTK_WIDGET (image);  
}

212 213 214 215 216 217 218 219 220 221 222 223
/**
 * gtk_image_new_from_stock:
 * @stock_id: a stock icon name
 * @size: a stock icon size
 * 
 * Creates a #GtkImage displaying a stock icon. Sample stock icon
 * names are #GTK_STOCK_ICON_OPEN, #GTK_STOCK_ICON_EXIT. Sample stock sizes
 * are #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock
 * icon name isn't known, a "broken image" icon will be displayed instead.
 * 
 * Return value: a new #GtkImage displaying the stock icon
 **/
224 225 226 227 228 229 230 231 232 233 234 235 236
GtkWidget*
gtk_image_new_from_stock (const gchar    *stock_id,
                          const gchar    *size)
{
  GtkImage *image;

  image = gtk_type_new (GTK_TYPE_IMAGE);

  gtk_image_set_from_stock (image, stock_id, size);

  return GTK_WIDGET (image);
}

237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
/**
 * gtk_image_new_from_icon_set:
 * @icon_set: a #GtkIconSet
 * @size: a stock icon size
 *
 * Creates a #GtkImage displaying an icon set. Sample stock sizes are
 * #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. Instead of using
 * this function, usually it's better to create a #GtkIconFactory, put
 * your icon sets in the icon factory, add the icon factory to the
 * list of default factories with gtk_icon_factory_add_default(), and
 * then use gtk_image_new_from_stock(). This will allow themes to
 * override the icon you ship with your application.
 *
 * The #GtkImage does not assume a reference to the
 * icon set; you still need to unref it if you own references.
 * #GtkImage will add its own reference rather than adopting yours.
 * 
 * 
 * Return value: a new #GtkImage
 **/
257 258 259 260 261 262 263 264 265
GtkWidget*
gtk_image_new_from_icon_set (GtkIconSet     *icon_set,
                             const gchar    *size)
{
  GtkImage *image;

  image = gtk_type_new (GTK_TYPE_IMAGE);

  gtk_image_set_from_icon_set (image, icon_set, size);
Elliot Lee's avatar
Elliot Lee committed
266 267 268 269

  return GTK_WIDGET (image);
}

270 271 272 273 274 275 276 277 278
/**
 * gtk_image_set_from_pixmap:
 * @image: a #GtkImage
 * @pixmap: a #GdkPixmap or %NULL
 * @mask: a #GdkBitmap or %NULL
 *
 * See gtk_image_new_from_pixmap() for details.
 * 
 **/
Elliot Lee's avatar
Elliot Lee committed
279
void
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
gtk_image_set_from_pixmap (GtkImage  *image,
                           GdkPixmap *pixmap,
                           GdkBitmap *mask)
{
  g_return_if_fail (GTK_IS_IMAGE (image));
  g_return_if_fail (pixmap == NULL ||
                    GDK_IS_PIXMAP (pixmap));
  g_return_if_fail (mask == NULL ||
                    GDK_IS_PIXMAP (mask));
  
  if (pixmap)
    g_object_ref (G_OBJECT (pixmap));

  if (mask)
    g_object_ref (G_OBJECT (mask));

296
  gtk_image_reset (image);
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319

  if (pixmap)
    {
      int width;
      int height;
      
      image->storage_type = GTK_IMAGE_PIXMAP;

      image->data.pixmap.pixmap = pixmap;
      image->data.pixmap.mask = mask;

      gdk_drawable_get_size (GDK_DRAWABLE (pixmap), &width, &height);

      gtk_image_update_size (image, width, height);
    }
  else
    {
      /* Clean up the mask if pixmap was NULL */
      if (mask)
        g_object_unref (G_OBJECT (mask));
    }
}

320 321 322 323 324 325 326 327 328
/**
 * gtk_image_set_from_image:
 * @image: a #GtkImage
 * @gdk_image: a #GdkImage or %NULL
 * @mask: a #GdkBitmap or %NULL
 *
 * See gtk_image_new_from_image() for details.
 * 
 **/
329 330 331 332
void
gtk_image_set_from_image  (GtkImage  *image,
                           GdkImage  *gdk_image,
                           GdkBitmap *mask)
Elliot Lee's avatar
Elliot Lee committed
333 334
{
  g_return_if_fail (GTK_IS_IMAGE (image));
335 336 337 338 339 340 341 342 343 344 345
  g_return_if_fail (gdk_image == NULL ||
                    GDK_IS_IMAGE (gdk_image));
  g_return_if_fail (mask == NULL ||
                    GDK_IS_PIXMAP (mask));

  
  if (gdk_image)
    g_object_ref (G_OBJECT (gdk_image));

  if (mask)
    g_object_ref (G_OBJECT (mask));
Elliot Lee's avatar
Elliot Lee committed
346

347
  gtk_image_reset (image);
Elliot Lee's avatar
Elliot Lee committed
348

349
  if (gdk_image)
Elliot Lee's avatar
Elliot Lee committed
350
    {
351 352 353 354 355 356
      image->storage_type = GTK_IMAGE_IMAGE;

      image->data.image.image = gdk_image;
      image->data.image.mask = mask;

      gtk_image_update_size (image, gdk_image->width, gdk_image->height);
Elliot Lee's avatar
Elliot Lee committed
357 358 359
    }
  else
    {
360 361 362
      /* Clean up the mask if gdk_image was NULL */
      if (mask)
        g_object_unref (G_OBJECT (mask));
Elliot Lee's avatar
Elliot Lee committed
363
    }
364
}
Elliot Lee's avatar
Elliot Lee committed
365

366 367 368 369 370 371 372 373
/**
 * gtk_image_set_from_file:
 * @image: a #GtkImage
 * @filename: a filename or %NULL
 *
 * See gtk_image_new_from_file() for details.
 * 
 **/
374 375 376 377 378 379 380 381 382
void
gtk_image_set_from_file   (GtkImage    *image,
                           const gchar *filename)
{
  GdkPixbuf *pixbuf;
  
  g_return_if_fail (GTK_IS_IMAGE (image));
  g_return_if_fail (filename != NULL);
  
383
  gtk_image_reset (image);
384 385 386 387

  if (filename == NULL)
    return;
  
Havoc Pennington's avatar
Havoc Pennington committed
388
  pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
389 390 391 392 393 394 395 396 397

  if (pixbuf == NULL)
    return;

  gtk_image_set_from_pixbuf (image, pixbuf);

  g_object_unref (G_OBJECT (pixbuf));
}

398 399 400 401 402 403 404 405
/**
 * gtk_image_set_from_pixbuf:
 * @image: a #GtkImage
 * @pixbuf: a #GdkPixbuf or %NULL
 *
 * See gtk_image_new_from_pixbuf() for details. 
 * 
 **/
406 407 408 409 410 411 412 413 414 415 416
void
gtk_image_set_from_pixbuf (GtkImage  *image,
                           GdkPixbuf *pixbuf)
{
  g_return_if_fail (GTK_IS_IMAGE (image));
  g_return_if_fail (pixbuf == NULL ||
                    GDK_IS_PIXBUF (pixbuf));
  
  if (pixbuf)
    g_object_ref (G_OBJECT (pixbuf));

417
  gtk_image_reset (image);
418 419 420 421 422 423 424 425 426 427 428 429 430

  if (pixbuf != NULL)
    {
      image->storage_type = GTK_IMAGE_PIXBUF;

      image->data.pixbuf.pixbuf = pixbuf;

      gtk_image_update_size (image,
                             gdk_pixbuf_get_width (pixbuf),
                             gdk_pixbuf_get_height (pixbuf));
    }
}

431 432 433 434 435 436 437 438 439
/**
 * gtk_image_set_from_stock:
 * @image: a #GtkImage
 * @stock_id: a stock icon name
 * @size: a stock icon size
 *
 * See gtk_image_new_from_stock for details.
 * 
 **/
440 441 442 443 444 445 446
void
gtk_image_set_from_stock  (GtkImage       *image,
                           const gchar    *stock_id,
                           const gchar    *size)
{
  g_return_if_fail (GTK_IS_IMAGE (image));
  
447
  gtk_image_reset (image);
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462

  if (stock_id)
    {      
      image->storage_type = GTK_IMAGE_STOCK;
      
      image->data.stock.stock_id = g_strdup (stock_id);
      image->data.stock.size = g_strdup (size);

      /* Size is demand-computed in size request method
       * if we're a stock image, since changing the
       * style impacts the size request
       */
    }
}

463 464 465 466 467 468 469 470 471
/**
 * gtk_image_set_from_icon_set:
 * @image: a #GtkImage
 * @icon_set: a #GtkIconSet
 * @size: a stock icon size
 *
 * See gtk_image_new_from_icon_set() for details.
 * 
 **/
472 473 474 475 476 477 478 479 480 481
void
gtk_image_set_from_icon_set  (GtkImage       *image,
                              GtkIconSet     *icon_set,
                              const gchar    *size)
{
  g_return_if_fail (GTK_IS_IMAGE (image));

  if (icon_set)
    gtk_icon_set_ref (icon_set);
  
482
  gtk_image_reset (image);
483 484 485 486 487 488 489 490 491 492 493 494 495 496

  if (icon_set)
    {      
      image->storage_type = GTK_IMAGE_ICON_SET;
      
      image->data.icon_set.icon_set = icon_set;
      image->data.icon_set.size = g_strdup (size);

      /* Size is demand-computed in size request method
       * if we're an icon set
       */
    }
}

497 498 499 500 501 502 503 504 505 506
/**
 * gtk_image_get_storage_type:
 * @image: a #GtkImage
 * 
 * Gets the type of representation being used by the #GtkImage
 * to store image data. If the #GtkImage has no image data,
 * the return value will be %GTK_IMAGE_EMPTY.
 * 
 * Return value: image representation being used
 **/
507 508 509 510 511 512 513 514
GtkImageType
gtk_image_get_storage_type (GtkImage *image)
{
  g_return_val_if_fail (GTK_IS_IMAGE (image), GTK_IMAGE_EMPTY);

  return image->storage_type;
}

515 516 517 518 519 520 521 522 523 524 525 526 527
/**
 * gtk_image_get_pixmap:
 * @image: a #GtkImage
 * @pixmap: location to store the pixmap, or %NULL
 * @mask: location to store the mask, or %NULL
 *
 * Gets the pixmap and mask being displayed by the #GtkImage.
 * The storage type of the image must be %GTK_IMAGE_EMPTY or
 * %GTK_IMAGE_PIXMAP (see gtk_image_get_storage_type()).
 * The caller of this function does not own a reference to the
 * returned pixmap and mask.
 * 
 **/
528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
void
gtk_image_get_pixmap (GtkImage   *image,
                      GdkPixmap **pixmap,
                      GdkBitmap **mask)
{
  g_return_if_fail (GTK_IS_IMAGE (image)); 
  g_return_if_fail (image->storage_type == GTK_IMAGE_PIXMAP ||
                    image->storage_type == GTK_IMAGE_EMPTY);
  
  if (pixmap)
    *pixmap = image->data.pixmap.pixmap;
  
  if (mask)
    *mask = image->data.pixmap.mask;
}

544 545 546 547 548 549 550 551 552 553 554 555
/**
 * gtk_image_get_image:
 * @image: a #GtkImage
 * @gdk_image: return location for a #GtkImage
 * @mask: return location for a #GdkBitmap
 * 
 * Gets the #GdkImage and mask being displayed by the #GtkImage.
 * The storage type of the image must be %GTK_IMAGE_EMPTY or
 * %GTK_IMAGE_IMAGE (see gtk_image_get_storage_type()).
 * The caller of this function does not own a reference to the
 * returned image and mask.
 **/
556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
void
gtk_image_get_image  (GtkImage   *image,
                      GdkImage  **gdk_image,
                      GdkBitmap **mask)
{
  g_return_if_fail (GTK_IS_IMAGE (image));
  g_return_if_fail (image->storage_type == GTK_IMAGE_IMAGE ||
                    image->storage_type == GTK_IMAGE_EMPTY);

  if (gdk_image)
    *gdk_image = image->data.image.image;
  
  if (mask)
    *mask = image->data.image.mask;
}

572 573 574 575 576 577 578 579 580 581 582 583 584
/**
 * gtk_image_get_pixbuf:
 * @image: a #GtkImage
 *
 *
 * Gets the #GdkPixbuf being displayed by the #GtkImage.
 * The storage type of the image must be %GTK_IMAGE_EMPTY or
 * %GTK_IMAGE_PIXBUF (see gtk_image_get_storage_type()).
 * The caller of this function does not own a reference to the
 * returned pixbuf.
 * 
 * Return value: the displayed pixbuf, or %NULL if the image is empty
 **/
585 586 587 588 589 590 591 592 593 594 595 596 597
GdkPixbuf*
gtk_image_get_pixbuf (GtkImage *image)
{
  g_return_val_if_fail (GTK_IS_IMAGE (image), NULL);
  g_return_val_if_fail (image->storage_type == GTK_IMAGE_PIXBUF ||
                        image->storage_type == GTK_IMAGE_EMPTY, NULL);

  if (image->storage_type == GTK_IMAGE_EMPTY)
    image->data.pixbuf.pixbuf = NULL;
  
  return image->data.pixbuf.pixbuf;
}

598 599 600 601 602 603 604 605 606 607 608 609 610
/**
 * gtk_image_get_stock:
 * @image: a #GtkImage
 * @stock_id: place to store a stock icon name
 * @size: place to store a stock icon size
 *
 * Gets the stock icon name and size being displayed by the #GtkImage.
 * The storage type of the image must be %GTK_IMAGE_EMPTY or
 * %GTK_IMAGE_STOCK (see gtk_image_get_storage_type()).
 * The returned strings are owned by the #GtkImage and should not
 * be freed.
 * 
 **/
611 612 613 614 615 616 617 618 619 620 621 622 623
void
gtk_image_get_stock  (GtkImage        *image,
                      gchar          **stock_id,
                      gchar          **size)
{
  g_return_if_fail (GTK_IS_IMAGE (image));
  g_return_if_fail (image->storage_type == GTK_IMAGE_STOCK ||
                    image->storage_type == GTK_IMAGE_EMPTY);

  if (image->storage_type == GTK_IMAGE_EMPTY)
    image->data.stock.stock_id = NULL;
  
  if (stock_id)
624
    *stock_id = image->data.stock.stock_id;
625 626 627 628 629

  if (size)
    *size = image->data.stock.size;
}

630 631 632 633 634 635 636 637 638 639 640 641 642
/**
 * gtk_image_get_icon_set:
 * @image: a #GtkImage
 * @icon_set: location to store a #GtkIconSet
 * @size: location to store a stock icon size
 *
 * Gets the icon set and size being displayed by the #GtkImage.
 * The storage type of the image must be %GTK_IMAGE_EMPTY or
 * %GTK_IMAGE_ICON_SET (see gtk_image_get_storage_type()).
 * The returned size string is owned by the #GtkImage and should not
 * be freed.
 * 
 **/
643 644 645 646 647 648 649 650 651 652 653 654 655
void
gtk_image_get_icon_set  (GtkImage        *image,
                         GtkIconSet     **icon_set,
                         gchar          **size)
{
  g_return_if_fail (GTK_IS_IMAGE (image));
  g_return_if_fail (image->storage_type == GTK_IMAGE_ICON_SET ||
                    image->storage_type == GTK_IMAGE_EMPTY);
      
  if (icon_set)    
    *icon_set = image->data.icon_set.icon_set;

  if (size)
656
    *size = image->data.icon_set.size;
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
}

GtkWidget*
gtk_image_new (GdkImage  *val,
	       GdkBitmap *mask)
{
  GtkImage *image;

  g_return_val_if_fail (val != NULL, NULL);

  image = gtk_type_new (GTK_TYPE_IMAGE);

  gtk_image_set (image, val, mask);

  return GTK_WIDGET (image);
}

void
gtk_image_set (GtkImage  *image,
	       GdkImage  *val,
	       GdkBitmap *mask)
{
  g_return_if_fail (GTK_IS_IMAGE (image));

  gtk_image_set_from_image (image, val, mask);
Elliot Lee's avatar
Elliot Lee committed
682 683 684 685 686 687 688 689 690
}

void
gtk_image_get (GtkImage   *image,
	       GdkImage  **val,
	       GdkBitmap **mask)
{
  g_return_if_fail (GTK_IS_IMAGE (image));

691
  gtk_image_get_image (image, val, mask);
Elliot Lee's avatar
Elliot Lee committed
692 693 694 695 696 697 698 699 700 701
}


static gint
gtk_image_expose (GtkWidget      *widget,
		  GdkEventExpose *event)
{
  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_IMAGE (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);
702 703 704
  
  if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget) &&
      GTK_IMAGE (widget)->storage_type != GTK_IMAGE_EMPTY)
Elliot Lee's avatar
Elliot Lee committed
705
    {
706 707 708 709
      GtkImage *image;
      GtkMisc *misc;
      GdkRectangle area, image_bound, intersection;
      gint x, y;
710 711
      GdkBitmap *mask = NULL;
      GdkPixbuf *stock_pixbuf = NULL;
712
      
Elliot Lee's avatar
Elliot Lee committed
713 714 715 716 717 718 719 720 721 722 723 724
      image = GTK_IMAGE (widget);
      misc = GTK_MISC (widget);

      x = (widget->allocation.x * (1.0 - misc->xalign) +
	   (widget->allocation.x + widget->allocation.width
	    - (widget->requisition.width - misc->xpad * 2)) *
	   misc->xalign) + 0.5;
      y = (widget->allocation.y * (1.0 - misc->yalign) +
	   (widget->allocation.y + widget->allocation.height
	    - (widget->requisition.height - misc->ypad * 2)) *
	   misc->yalign) + 0.5;

725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
      image_bound.x = x;
      image_bound.y = y;      

      switch (image->storage_type)
        {
        case GTK_IMAGE_PIXMAP:
          mask = image->data.pixmap.mask;
          gdk_drawable_get_size (image->data.pixmap.pixmap,
                                 &image_bound.width,
                                 &image_bound.height);
          break;

        case GTK_IMAGE_IMAGE:
          mask = image->data.image.mask;
          image_bound.width = image->data.image.image->width;
          image_bound.height = image->data.image.image->height;
          break;

        case GTK_IMAGE_PIXBUF:
          image_bound.width = gdk_pixbuf_get_width (image->data.pixbuf.pixbuf);
          image_bound.height = gdk_pixbuf_get_height (image->data.pixbuf.pixbuf);
          break;

        case GTK_IMAGE_STOCK:
749 750 751 752
          stock_pixbuf = gtk_widget_render_icon (widget,
                                                 image->data.stock.stock_id,
                                                 image->data.stock.size,
                                                 NULL);
753
          if (stock_pixbuf)
754
            {              
755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
              image_bound.width = gdk_pixbuf_get_width (stock_pixbuf);
              image_bound.height = gdk_pixbuf_get_height (stock_pixbuf);
            }
          break;

        case GTK_IMAGE_ICON_SET:
          stock_pixbuf =
            gtk_icon_set_render_icon (image->data.icon_set.icon_set,
                                      widget->style,
                                      gtk_widget_get_direction (widget),
                                      GTK_WIDGET_STATE (widget),
                                      image->data.icon_set.size,
                                      widget,
                                      NULL);

          if (stock_pixbuf)
            {
              image_bound.width = gdk_pixbuf_get_width (stock_pixbuf);
              image_bound.height = gdk_pixbuf_get_height (stock_pixbuf);
            }
          break;
          
        default:
          break;
        }

      if (mask)
Elliot Lee's avatar
Elliot Lee committed
782
	{
783
	  gdk_gc_set_clip_mask (widget->style->black_gc, mask);
Elliot Lee's avatar
Elliot Lee committed
784 785 786
	  gdk_gc_set_clip_origin (widget->style->black_gc, x, y);
	}

787 788
      area = event->area;
      
789
      if (gdk_rectangle_intersect (&image_bound, &area, &intersection))
790
        {
791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814

          switch (image->storage_type)
            {
            case GTK_IMAGE_PIXMAP:
              gdk_draw_drawable (widget->window,
                                 widget->style->black_gc,
                                 image->data.pixmap.pixmap,
                                 image_bound.x - x, image_bound.y - y,
                                 image_bound.x, image_bound.y,
                                 image_bound.width, image_bound.height);
              break;
              
            case GTK_IMAGE_IMAGE:
              gdk_draw_image (widget->window,
                              widget->style->black_gc,
                              image->data.image.image,
                              image_bound.x - x, image_bound.y - y,
                              image_bound.x, image_bound.y,
                              image_bound.width, image_bound.height);
              break;

            case GTK_IMAGE_PIXBUF:
              gdk_pixbuf_render_to_drawable_alpha (image->data.pixbuf.pixbuf,
                                                   widget->window,
815 816 817 818
                                                   image_bound.x - x,
                                                   image_bound.y - y,
                                                   image_bound.x,
                                                   image_bound.y,
819 820
                                                   image_bound.width,
                                                   image_bound.height,
821 822 823 824 825 826 827 828 829 830 831 832
                                                   GDK_PIXBUF_ALPHA_FULL,
                                                   128,
                                                   GDK_RGB_DITHER_NORMAL,
                                                   0, 0);
              break;

            case GTK_IMAGE_STOCK: /* fall thru */
            case GTK_IMAGE_ICON_SET:
              if (stock_pixbuf)
                {
                  gdk_pixbuf_render_to_drawable_alpha (stock_pixbuf,
                                                       widget->window,
833 834
                                                       image_bound.x - x,
                                                       image_bound.y - y,
835 836 837 838
                                                       image_bound.x,
                                                       image_bound.y,
                                                       image_bound.width,
                                                       image_bound.height,
839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
                                                       GDK_PIXBUF_ALPHA_FULL,
                                                       128,
                                                       GDK_RGB_DITHER_NORMAL,
                                                       0, 0);
                  
                  g_object_unref (G_OBJECT (stock_pixbuf));
                }
              break;

            default:
              break;
            }
        } /* if rectangle intersects */      
      if (mask)
        {
          gdk_gc_set_clip_mask (widget->style->black_gc, NULL);
          gdk_gc_set_clip_origin (widget->style->black_gc, 0, 0);
856
        }
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
    } /* if widget is drawable */

  return FALSE;
}

static void
gtk_image_clear (GtkImage *image)
{
  switch (image->storage_type)
    {
    case GTK_IMAGE_PIXMAP:

      if (image->data.pixmap.pixmap)
        g_object_unref (G_OBJECT (image->data.pixmap.pixmap));

      if (image->data.pixmap.mask)
        g_object_unref (G_OBJECT (image->data.pixmap.mask));

      image->data.pixmap.pixmap = NULL;
      image->data.pixmap.mask = NULL;

      break;

    case GTK_IMAGE_IMAGE:

      if (image->data.image.image)
        g_object_unref (G_OBJECT (image->data.image.image));

      if (image->data.image.mask)
        g_object_unref (G_OBJECT (image->data.image.mask));

      image->data.image.image = NULL;
      image->data.image.mask = NULL;

      break;

    case GTK_IMAGE_PIXBUF:

      if (image->data.pixbuf.pixbuf)
        g_object_unref (G_OBJECT (image->data.pixbuf.pixbuf));

      image->data.pixbuf.pixbuf = NULL;

      break;

    case GTK_IMAGE_STOCK:

      g_free (image->data.stock.size);
      g_free (image->data.stock.stock_id);

      image->data.stock.stock_id = NULL;
      image->data.stock.size = NULL;
      
      break;

    case GTK_IMAGE_ICON_SET:
      if (image->data.icon_set.icon_set)
        gtk_icon_set_unref (image->data.icon_set.icon_set);

      g_free (image->data.icon_set.size);

      image->data.icon_set.size = NULL;
      image->data.icon_set.icon_set = NULL;
      
      break;
      
    case GTK_IMAGE_EMPTY:
    default:
      break;
926
      
Elliot Lee's avatar
Elliot Lee committed
927 928
    }

929
  image->storage_type = GTK_IMAGE_EMPTY;
930
}
931

932 933 934 935 936
static void
gtk_image_reset (GtkImage *image)
{
  gtk_image_clear (image);
  
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
  GTK_WIDGET (image)->requisition.width = 0;
  GTK_WIDGET (image)->requisition.height = 0;
  
  if (GTK_WIDGET_VISIBLE (image))
    gtk_widget_queue_resize (GTK_WIDGET (image));
}

static void
gtk_image_size_request (GtkWidget      *widget,
                        GtkRequisition *requisition)
{
  GtkImage *image;
  GdkPixbuf *pixbuf = NULL;
  
  image = GTK_IMAGE (widget);

  switch (image->storage_type)
    {
    case GTK_IMAGE_STOCK:
956 957 958 959
      pixbuf = gtk_widget_render_icon (GTK_WIDGET (image),
                                       image->data.stock.stock_id,
                                       image->data.stock.size,
                                       NULL);
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
      break;

    case GTK_IMAGE_ICON_SET:
      pixbuf = gtk_icon_set_render_icon (image->data.icon_set.icon_set,
                                         widget->style,
                                         gtk_widget_get_direction (widget),
                                         GTK_WIDGET_STATE (widget),
                                         image->data.icon_set.size,
                                         widget,
                                         NULL);
      break;
      
    default:
      break;
    }

  if (pixbuf)
    {
      gtk_image_update_size (image,
                             gdk_pixbuf_get_width (pixbuf),
                             gdk_pixbuf_get_height (pixbuf));
      g_object_unref (G_OBJECT (pixbuf));
    }

  /* Chain up to default that simply reads current requisition */
  GTK_WIDGET_CLASS (parent_class)->size_request (widget, requisition);
Elliot Lee's avatar
Elliot Lee committed
986
}
987 988 989 990 991 992 993 994 995 996 997

static void
gtk_image_update_size (GtkImage *image,
                       gint      image_width,
                       gint      image_height)
{
  GTK_WIDGET (image)->requisition.width = image_width + GTK_MISC (image)->xpad * 2;
  GTK_WIDGET (image)->requisition.height = image_height + GTK_MISC (image)->ypad * 2;
}