Pileus Git - ~andy/gtk/blob - gtk/gtkpreview.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <math.h>
  30 #include <string.h>
  31 #include <sys/types.h>
  32 #ifdef HAVE_SYS_PARAM_H
  33 #include <sys/param.h>
  34 #endif
  35 #include "gdk/gdkx.h"
  36 #include "gdk/gdkrgb.h"
  37 #include "gtkpreview.h"
  38 #include "gtksignal.h"
  39
  40
  41 #define PREVIEW_CLASS(w)      GTK_PREVIEW_CLASS (GTK_OBJECT (w)->klass)
  42
  43
  44 static void   gtk_preview_class_init    (GtkPreviewClass  *klass);
  45 static void   gtk_preview_init          (GtkPreview       *preview);
  46 static void   gtk_preview_finalize      (GtkObject        *object);
  47 static void   gtk_preview_realize       (GtkWidget        *widget);
  48 static void   gtk_preview_size_allocate (GtkWidget        *widget,
  49                                          GtkAllocation    *allocation);
  50 static gint   gtk_preview_expose        (GtkWidget        *widget,
  51                                          GdkEventExpose   *event);
  52 static void   gtk_preview_make_buffer   (GtkPreview       *preview);
  53 static void   gtk_fill_lookup_array     (guchar           *array);
  54
  55 static GtkWidgetClass *parent_class = NULL;
  56 static GtkPreviewClass *preview_class = NULL;
  57 static gint install_cmap = FALSE;
  58
  59
  60 guint
  61 gtk_preview_get_type (void)
  62 {
  63   static guint preview_type = 0;
  64
  65   if (!preview_type)
  66     {
  67       static const GtkTypeInfo preview_info =
  68       {
  69         "GtkPreview",
  70         sizeof (GtkPreview),
  71         sizeof (GtkPreviewClass),
  72         (GtkClassInitFunc) gtk_preview_class_init,
  73         (GtkObjectInitFunc) gtk_preview_init,
  74         /* reserved_1 */ NULL,
  75         /* reserved_2 */ NULL,
  76         (GtkClassInitFunc) NULL,
  77       };
  78
  79       preview_type = gtk_type_unique (gtk_widget_get_type (), &preview_info);
  80     }
  81
  82   return preview_type;
  83 }
  84
  85 static void
  86 gtk_preview_class_init (GtkPreviewClass *klass)
  87 {
  88   GtkObjectClass *object_class;
  89   GtkWidgetClass *widget_class;
  90
  91   object_class = (GtkObjectClass*) klass;
  92   widget_class = (GtkWidgetClass*) klass;
  93
  94   parent_class = gtk_type_class (gtk_widget_get_type ());
  95   preview_class = klass;
  96
  97   object_class->finalize = gtk_preview_finalize;
  98
  99   widget_class->realize = gtk_preview_realize;
 100   widget_class->size_allocate = gtk_preview_size_allocate;
 101   widget_class->expose_event = gtk_preview_expose;
 102
 103   klass->info.visual = NULL;
 104   klass->info.cmap = NULL;
 105
 106   klass->info.lookup = NULL;
 107
 108   klass->info.gamma = 1.0;
 109
 110   gdk_rgb_init ();
 111   klass->info.cmap = gdk_rgb_get_cmap ();
 112   klass->info.visual = gdk_rgb_get_visual ();
 113 }
 114
 115 void
 116 gtk_preview_reset (void)
 117 {
 118   /* unimplemented */
 119 }
 120
 121 static void
 122 gtk_preview_init (GtkPreview *preview)
 123 {
 124   preview->buffer = NULL;
 125   preview->buffer_width = 0;
 126   preview->buffer_height = 0;
 127   preview->expand = FALSE;
 128 }
 129
 130 void
 131 gtk_preview_uninit (void)
 132 {
 133
 134   /* unimplemented */
 135 }
 136
 137 GtkWidget*
 138 gtk_preview_new (GtkPreviewType type)
 139 {
 140   GtkPreview *preview;
 141
 142   preview = gtk_type_new (gtk_preview_get_type ());
 143   preview->type = type;
 144
 145   if (type == GTK_PREVIEW_COLOR)
 146     preview->bpp = 3;
 147   else
 148     preview->bpp = 1;
 149
 150   preview->dither = GDK_RGB_DITHER_NORMAL;
 151
 152   return GTK_WIDGET (preview);
 153 }
 154
 155 void
 156 gtk_preview_size (GtkPreview *preview,
 157                   gint        width,
 158                   gint        height)
 159 {
 160   g_return_if_fail (preview != NULL);
 161   g_return_if_fail (GTK_IS_PREVIEW (preview));
 162
 163   if ((width != GTK_WIDGET (preview)->requisition.width) ||
 164       (height != GTK_WIDGET (preview)->requisition.height))
 165     {
 166       GTK_WIDGET (preview)->requisition.width = width;
 167       GTK_WIDGET (preview)->requisition.height = height;
 168
 169       if (preview->buffer)
 170         g_free (preview->buffer);
 171       preview->buffer = NULL;
 172     }
 173 }
 174
 175 void
 176 gtk_preview_put (GtkPreview   *preview,
 177                  GdkWindow    *window,
 178                  GdkGC        *gc,
 179                  gint          srcx,
 180                  gint          srcy,
 181                  gint          destx,
 182                  gint          desty,
 183                  gint          width,
 184                  gint          height)
 185 {
 186   GtkWidget *widget;
 187   GdkRectangle r1, r2, r3;
 188   guchar *src;
 189   guint bpp;
 190   guint rowstride;
 191
 192   g_return_if_fail (preview != NULL);
 193   g_return_if_fail (GTK_IS_PREVIEW (preview));
 194   g_return_if_fail (window != NULL);
 195
 196   if (!preview->buffer)
 197     return;
 198
 199   widget = GTK_WIDGET (preview);
 200
 201   r1.x = 0;
 202   r1.y = 0;
 203   r1.width = preview->buffer_width;
 204   r1.height = preview->buffer_height;
 205
 206   r2.x = srcx;
 207   r2.y = srcy;
 208   r2.width = width;
 209   r2.height = height;
 210
 211   if (!gdk_rectangle_intersect (&r1, &r2, &r3))
 212     return;
 213
 214   bpp = preview->bpp;
 215   rowstride = preview->rowstride;
 216
 217   src = preview->buffer + r3.y * rowstride + r3.x * bpp;
 218
 219   if (preview->type == GTK_PREVIEW_COLOR)
 220     gdk_draw_rgb_image (window,
 221                         gc,
 222                         destx + (r3.x - srcx),
 223                         desty + (r3.y - srcy),
 224                         r3.width,
 225                         r3.height,
 226                         preview->dither,
 227                         src,
 228                         rowstride);
 229   else
 230     gdk_draw_gray_image (window,
 231                          gc,
 232                          destx + (r3.x - srcx),
 233                          desty + (r3.y - srcy),
 234                          r3.width,
 235                          r3.height,
 236                          preview->dither,
 237                          src,
 238                          rowstride);
 239
 240 }
 241
 242 void
 243 gtk_preview_draw_row (GtkPreview *preview,
 244                       guchar     *data,
 245                       gint        x,
 246                       gint        y,
 247                       gint        w)
 248 {
 249   guint bpp;
 250   guint rowstride;
 251
 252   g_return_if_fail (preview != NULL);
 253   g_return_if_fail (GTK_IS_PREVIEW (preview));
 254   g_return_if_fail (data != NULL);
 255   g_return_if_fail (preview_class->info.visual != NULL);
 256
 257   bpp = (preview->type == GTK_PREVIEW_COLOR ? 3 : 1);
 258   rowstride = (preview->buffer_width * bpp + 3) & -4;
 259
 260   if ((w <= 0) || (y < 0))
 261     return;
 262
 263   g_return_if_fail (data != NULL);
 264
 265   gtk_preview_make_buffer (preview);
 266
 267   if (x + w > preview->buffer_width)
 268     return;
 269
 270   if (y + 1 > preview->buffer_height)
 271     return;
 272
 273   if (preview_class->info.gamma == 1.0)
 274     memcpy (preview->buffer + y * rowstride + x * bpp, data, w * bpp);
 275   else
 276     {
 277       guint i, size;
 278       guchar *src, *dst;
 279       guchar *lookup;
 280
 281       if (preview_class->info.lookup != NULL)
 282         lookup = preview_class->info.lookup;
 283       else
 284         {
 285           preview_class->info.lookup = g_new (guchar, 256);
 286           gtk_fill_lookup_array (preview_class->info.lookup);
 287           lookup = preview_class->info.lookup;
 288         }
 289       size = w * bpp;
 290       src = data;
 291       dst = preview->buffer + y * rowstride + x * bpp;
 292       for (i = 0; i < size; i++)
 293         *dst++ = lookup[*src++];
 294     }
 295 }
 296
 297 void
 298 gtk_preview_set_expand (GtkPreview *preview,
 299                         gint        expand)
 300 {
 301   g_return_if_fail (preview != NULL);
 302   g_return_if_fail (GTK_IS_PREVIEW (preview));
 303
 304   preview->expand = (expand != FALSE);
 305 }
 306
 307 void
 308 gtk_preview_set_gamma (double _gamma)
 309 {
 310   if (!preview_class)
 311     preview_class = gtk_type_class (gtk_preview_get_type ());
 312
 313   if (preview_class->info.gamma != _gamma)
 314     {
 315       preview_class->info.gamma = _gamma;
 316       if (preview_class->info.lookup != NULL)
 317         {
 318           g_free (preview_class->info.lookup);
 319           preview_class->info.lookup = NULL;
 320         }
 321     }
 322 }
 323
 324 void
 325 gtk_preview_set_color_cube (guint nred_shades,
 326                             guint ngreen_shades,
 327                             guint nblue_shades,
 328                             guint ngray_shades)
 329 {
 330   /* unimplemented */
 331 }
 332
 333 void
 334 gtk_preview_set_install_cmap (gint _install_cmap)
 335 {
 336   /* effectively unimplemented */
 337   install_cmap = _install_cmap;
 338 }
 339
 340 void
 341 gtk_preview_set_reserved (gint nreserved)
 342 {
 343
 344   /* unimplemented */
 345 }
 346
 347 void
 348 gtk_preview_set_dither (GtkPreview      *preview,
 349                         GdkRgbDither     dither)
 350 {
 351   preview->dither = dither;
 352 }
 353
 354 GdkVisual*
 355 gtk_preview_get_visual (void)
 356 {
 357   if (!preview_class)
 358     preview_class = gtk_type_class (gtk_preview_get_type ());
 359
 360   return preview_class->info.visual;
 361 }
 362
 363 GdkColormap*
 364 gtk_preview_get_cmap (void)
 365 {
 366   if (!preview_class)
 367     preview_class = gtk_type_class (gtk_preview_get_type ());
 368
 369   return preview_class->info.cmap;
 370 }
 371
 372 GtkPreviewInfo*
 373 gtk_preview_get_info (void)
 374 {
 375   if (!preview_class)
 376     preview_class = gtk_type_class (gtk_preview_get_type ());
 377
 378   return &preview_class->info;
 379 }
 380
 381
 382 static void
 383 gtk_preview_finalize (GtkObject *object)
 384 {
 385   GtkPreview *preview;
 386
 387   g_return_if_fail (object != NULL);
 388   g_return_if_fail (GTK_IS_PREVIEW (object));
 389
 390   preview = GTK_PREVIEW (object);
 391   if (preview->buffer)
 392     g_free (preview->buffer);
 393   preview->type = (GtkPreviewType) -1;
 394
 395   (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
 396 }
 397
 398 static void
 399 gtk_preview_realize (GtkWidget *widget)
 400 {
 401   GtkPreview *preview;
 402   GdkWindowAttr attributes;
 403   gint attributes_mask;
 404
 405   g_return_if_fail (widget != NULL);
 406   g_return_if_fail (GTK_IS_PREVIEW (widget));
 407
 408   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 409   preview = GTK_PREVIEW (widget);
 410
 411   attributes.window_type = GDK_WINDOW_CHILD;
 412
 413   if (preview->expand)
 414     {
 415       attributes.width = widget->allocation.width;
 416       attributes.height = widget->allocation.height;
 417     }
 418   else
 419     {
 420       attributes.width = MIN (widget->requisition.width, widget->allocation.width);
 421       attributes.height = MIN (widget->requisition.height, widget->allocation.height);
 422     }
 423
 424   attributes.x = widget->allocation.x + (widget->allocation.width - attributes.width) / 2;
 425   attributes.y = widget->allocation.y + (widget->allocation.height - attributes.height) / 2;;
 426
 427   attributes.wclass = GDK_INPUT_OUTPUT;
 428   attributes.visual = preview_class->info.visual;
 429   attributes.colormap = preview_class->info.cmap;
 430   attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
 431   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 432
 433   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
 434   gdk_window_set_user_data (widget->window, widget);
 435
 436   widget->style = gtk_style_attach (widget->style, widget->window);
 437   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 438 }
 439
 440 static void
 441 gtk_preview_size_allocate (GtkWidget        *widget,
 442                            GtkAllocation    *allocation)
 443 {
 444   GtkPreview *preview;
 445   gint width, height;
 446
 447   g_return_if_fail (widget != NULL);
 448   g_return_if_fail (GTK_IS_PREVIEW (widget));
 449
 450   preview = GTK_PREVIEW (widget);
 451   widget->allocation = *allocation;
 452
 453   if (GTK_WIDGET_REALIZED (widget))
 454     {
 455       if (preview->expand)
 456         {
 457           width = widget->allocation.width;
 458           height = widget->allocation.height;
 459         }
 460       else
 461         {
 462           width = MIN (widget->allocation.width, widget->requisition.width);
 463           height = MIN (widget->allocation.height, widget->requisition.height);
 464         }
 465
 466       gdk_window_move_resize (widget->window,
 467                               widget->allocation.x + (widget->allocation.width - width) / 2,
 468                               widget->allocation.y + (widget->allocation.height - height) / 2,
 469                               width, height);
 470     }
 471 }
 472
 473 static gint
 474 gtk_preview_expose (GtkWidget      *widget,
 475                     GdkEventExpose *event)
 476 {
 477   GtkPreview *preview;
 478   gint width, height;
 479
 480   g_return_val_if_fail (widget != NULL, FALSE);
 481   g_return_val_if_fail (GTK_IS_PREVIEW (widget), FALSE);
 482   g_return_val_if_fail (event != NULL, FALSE);
 483
 484   if (GTK_WIDGET_DRAWABLE (widget))
 485     {
 486       preview = GTK_PREVIEW (widget);
 487
 488       gdk_window_get_size (widget->window, &width, &height);
 489
 490       gtk_preview_put (GTK_PREVIEW (widget),
 491                        widget->window, widget->style->black_gc,
 492                        event->area.x - (width - preview->buffer_width)/2,
 493                        event->area.y - (height - preview->buffer_height)/2,
 494                        event->area.x, event->area.y,
 495                        event->area.width, event->area.height);
 496     }
 497
 498   return FALSE;
 499 }
 500
 501 static void
 502 gtk_preview_make_buffer (GtkPreview *preview)
 503 {
 504   GtkWidget *widget;
 505   gint width;
 506   gint height;
 507
 508   g_return_if_fail (preview != NULL);
 509   g_return_if_fail (GTK_IS_PREVIEW (preview));
 510
 511   widget = GTK_WIDGET (preview);
 512
 513   if (preview->expand &&
 514       (widget->allocation.width != 0) &&
 515       (widget->allocation.height != 0))
 516     {
 517       width = widget->allocation.width;
 518       height = widget->allocation.height;
 519     }
 520   else
 521     {
 522       width = widget->requisition.width;
 523       height = widget->requisition.height;
 524     }
 525
 526   if (!preview->buffer ||
 527       (preview->buffer_width != width) ||
 528       (preview->buffer_height != height))
 529     {
 530       if (preview->buffer)
 531         g_free (preview->buffer);
 532
 533       preview->buffer_width = width;
 534       preview->buffer_height = height;
 535
 536       preview->rowstride = (preview->buffer_width * preview->bpp + 3) & -4;
 537       preview->buffer = g_new0 (guchar,
 538                                 preview->buffer_height *
 539                                 preview->rowstride);
 540     }
 541 }
 542
 543 /* This will be useful for implementing gamma. */
 544 static void
 545 gtk_fill_lookup_array (guchar *array)
 546 {
 547   double one_over_gamma;
 548   double ind;
 549   int val;
 550   int i;
 551
 552   one_over_gamma = 1.0 / preview_class->info.gamma;
 553
 554   for (i = 0; i < 256; i++)
 555     {
 556       ind = (double) i / 255.0;
 557       val = (int) (255 * pow (ind, one_over_gamma));
 558       array[i] = val;
 559     }
 560 }