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