src/widgets/eek-preview.cpp

   1 /** @file
   2  * @brief EEK preview stuff
   3  */
   4 /* ***** BEGIN LICENSE BLOCK *****
   5  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version
   8  * 1.1 (the "License"); you may not use this file except in compliance with
   9  * the License. You may obtain a copy of the License at
  10  * http://www.mozilla.org/MPL/
  11  *
  12  * Software distributed under the License is distributed on an "AS IS" basis,
  13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14  * for the specific language governing rights and limitations under the
  15  * License.
  16  *
  17  * The Original Code is Eek Preview Stuffs.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Jon A. Cruz.
  21  * Portions created by the Initial Developer are Copyright (C) 2005
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39 #ifdef HAVE_CONFIG_H
  40 # include "config.h"
  41 #endif
  42
  43 #include <gtk/gtk.h>
  44 #include "eek-preview.h"
  45
  46 #define PRIME_BUTTON_MAGIC_NUMBER 1
  47
  48 #define FOCUS_PROP_ID 1
  49
  50 /* Keep in sycn with last value in eek-preview.h */
  51 #define PREVIEW_SIZE_LAST PREVIEW_SIZE_HUGE
  52 #define PREVIEW_SIZE_NEXTFREE (PREVIEW_SIZE_HUGE + 1)
  53
  54 #define PREVIEW_MAX_RATIO 500
  55
  56 static void eek_preview_class_init( EekPreviewClass *klass );
  57 static void eek_preview_init( EekPreview *preview );
  58
  59 static GtkWidgetClass* parent_class = 0;
  60
  61 void eek_preview_set_color( EekPreview* preview, int r, int g, int b )
  62 {
  63     preview->_r = r;
  64     preview->_g = g;
  65     preview->_b = b;
  66
  67     gtk_widget_queue_draw(GTK_WIDGET(preview));
  68 }
  69
  70
  71 void eek_preview_set_pixbuf( EekPreview* preview, GdkPixbuf* pixbuf )
  72 {
  73     preview->_previewPixbuf = pixbuf;
  74
  75     gtk_widget_queue_draw(GTK_WIDGET(preview));
  76
  77     if (preview->_scaled) {
  78         g_object_unref(preview->_scaled);
  79         preview->_scaled = 0;
  80     }
  81     preview->_scaledW = gdk_pixbuf_get_width(preview->_previewPixbuf);
  82     preview->_scaledH = gdk_pixbuf_get_height(preview->_previewPixbuf);
  83 }
  84
  85
  86 GType eek_preview_get_type(void)
  87 {
  88     static GType preview_type = 0;
  89
  90     if (!preview_type) {
  91       static const GTypeInfo preview_info = {
  92           sizeof( EekPreviewClass ),
  93           NULL, /* base_init */
  94           NULL, /* base_finalize */
  95           (GClassInitFunc)eek_preview_class_init,
  96           NULL, /* class_finalize */
  97           NULL, /* class_data */
  98           sizeof( EekPreview ),
  99           0,    /* n_preallocs */
 100           (GInstanceInitFunc)eek_preview_init,
 101           NULL /* value_table */
 102       };
 103
 104
 105       preview_type = g_type_register_static( GTK_TYPE_DRAWING_AREA, "EekPreview", &preview_info, (GTypeFlags)0 );
 106     }
 107
 108     return preview_type;
 109 }
 110
 111 static gboolean setupDone = FALSE;
 112 static GtkRequisition sizeThings[PREVIEW_SIZE_NEXTFREE];
 113
 114 void eek_preview_set_size_mappings( guint count, GtkIconSize const* sizes )
 115 {
 116     gint width = 0;
 117     gint height = 0;
 118     gint smallest = 512;
 119     gint largest = 0;
 120     guint i = 0;
 121     guint delta = 0;
 122
 123     for ( i = 0; i < count; ++i ) {
 124         gboolean worked = gtk_icon_size_lookup( sizes[i], &width, &height );
 125         if ( worked ) {
 126             if ( width < smallest ) {
 127                 smallest = width;
 128             }
 129             if ( width > largest ) {
 130                 largest = width;
 131             }
 132         }
 133     }
 134
 135     smallest = (smallest * 3) / 4;
 136
 137     delta = largest - smallest;
 138
 139     for ( i = 0; i < G_N_ELEMENTS(sizeThings); ++i ) {
 140         guint val = smallest + ( (i * delta) / (G_N_ELEMENTS(sizeThings) - 1) );
 141         sizeThings[i].width = val;
 142         sizeThings[i].height = val;
 143     }
 144
 145     setupDone = TRUE;
 146 }
 147
 148 static void eek_preview_size_request( GtkWidget* widget, GtkRequisition* req )
 149 {
 150     gint width = 0;
 151     gint height = 0;
 152     EekPreview* preview = EEK_PREVIEW(widget);
 153
 154     if ( !setupDone ) {
 155         GtkIconSize sizes[] = {
 156             GTK_ICON_SIZE_MENU,
 157             GTK_ICON_SIZE_SMALL_TOOLBAR,
 158             GTK_ICON_SIZE_LARGE_TOOLBAR,
 159             GTK_ICON_SIZE_BUTTON,
 160             GTK_ICON_SIZE_DIALOG
 161         };
 162         eek_preview_set_size_mappings( G_N_ELEMENTS(sizes), sizes );
 163     }
 164
 165     width = sizeThings[preview->_size].width;
 166     height = sizeThings[preview->_size].height;
 167
 168     if ( preview->_view == VIEW_TYPE_LIST ) {
 169         width *= 3;
 170     }
 171
 172     if ( preview->_ratio != 100 ) {
 173         width = (width * preview->_ratio) / 100;
 174         if ( width < 0 ) {
 175             width = 1;
 176         }
 177     }
 178
 179     req->width = width;
 180     req->height = height;
 181 }
 182
 183 enum {
 184   CLICKED_SIGNAL,
 185   ALTCLICKED_SIGNAL,
 186   LAST_SIGNAL
 187 };
 188
 189
 190 static guint eek_preview_signals[LAST_SIGNAL] = { 0 };
 191
 192
 193 gboolean eek_preview_expose_event( GtkWidget* widget, GdkEventExpose* event )
 194 {
 195 /*     g_message("Exposed!!!   %s", GTK_WIDGET_HAS_FOCUS(widget) ? "XXX" : "---" ); */
 196     gint insetX = 0;
 197     gint insetY = 0;
 198
 199     (void)event;
 200 /*
 201     gint lower = widget->allocation.width;
 202     lower = (widget->allocation.height < lower) ? widget->allocation.height : lower;
 203     if ( lower > 16 ) {
 204         insetX++;
 205         if ( lower > 18 ) {
 206             insetX++;
 207             if ( lower > 22 ) {
 208                 insetX++;
 209                 if ( lower > 24 ) {
 210                     insetX++;
 211                     if ( lower > 32 ) {
 212                         insetX++;
 213                     }
 214                 }
 215             }
 216         }
 217         insetY = insetX;
 218     }
 219 */
 220
 221     if ( GTK_WIDGET_DRAWABLE( widget ) ) {
 222         GtkStyle* style = gtk_widget_get_style( widget );
 223
 224         if ( insetX > 0 || insetY > 0 ) {
 225             gtk_paint_flat_box( style,
 226                                 widget->window,
 227                                 (GtkStateType)GTK_WIDGET_STATE(widget),
 228                                 GTK_SHADOW_NONE,
 229                                 NULL,
 230                                 widget,
 231                                 NULL,
 232                                 0, 0,
 233                                 widget->allocation.width, widget->allocation.height);
 234         }
 235
 236         GdkGC *gc = gdk_gc_new( widget->window );
 237         EekPreview* preview = EEK_PREVIEW(widget);
 238         GdkColor fg = {0, preview->_r, preview->_g, preview->_b};
 239
 240         gdk_colormap_alloc_color( gdk_colormap_get_system(), &fg, FALSE, TRUE );
 241
 242         gdk_gc_set_foreground( gc, &fg );
 243
 244         gdk_draw_rectangle( widget->window,
 245                             gc,
 246                             TRUE,
 247                             insetX, insetY,
 248                             widget->allocation.width - (insetX * 2), widget->allocation.height - (insetY * 2) );
 249
 250         if ( preview->_linked ) {
 251             /* Draw arrow */
 252             GdkRectangle possible = {insetX, insetY, (widget->allocation.width - (insetX * 2)), (widget->allocation.height - (insetY * 2)) };
 253             GdkRectangle area = {possible.x, possible.y, possible.width / 2, possible.height / 2 };
 254
 255             /* Make it square */
 256             if ( area.width > area.height )
 257                 area.width = area.height;
 258             if ( area.height > area.width )
 259                 area.height = area.width;
 260
 261             /* Center it horizontally */
 262             if ( area.width < possible.width ) {
 263                 int diff = (possible.width - area.width) / 2;
 264                 area.x += diff;
 265             }
 266
 267
 268             if ( preview->_linked & PREVIEW_LINK_IN ) {
 269                 gtk_paint_arrow( style,
 270                                  widget->window,
 271                                  (GtkStateType)widget->state,
 272                                  GTK_SHADOW_ETCHED_IN,
 273                                  NULL, /* clip area.  &area, */
 274                                  widget, /* may be NULL */
 275                                  NULL, /* detail */
 276                                  GTK_ARROW_DOWN,
 277                                  FALSE,
 278                                  area.x, area.y,
 279                                  area.width, area.height
 280                                  );
 281             }
 282
 283             if ( preview->_linked & PREVIEW_LINK_OUT ) {
 284                 GdkRectangle otherArea = {area.x, area.y, area.width, area.height};
 285                 if ( otherArea.height < possible.height ) {
 286                     otherArea.y = possible.y + (possible.height - otherArea.height);
 287                 }
 288
 289                 gtk_paint_arrow( style,
 290                                  widget->window,
 291                                  (GtkStateType)widget->state,
 292                                  GTK_SHADOW_ETCHED_OUT,
 293                                  NULL, /* clip area.  &area, */
 294                                  widget, /* may be NULL */
 295                                  NULL, /* detail */
 296                                  GTK_ARROW_UP,
 297                                  FALSE,
 298                                  otherArea.x, otherArea.y,
 299                                  otherArea.width, otherArea.height
 300                                  );
 301             }
 302
 303             if ( preview->_linked & PREVIEW_LINK_OTHER ) {
 304                 GdkRectangle otherArea = {insetX, area.y, area.width, area.height};
 305                 if ( otherArea.height < possible.height ) {
 306                     otherArea.y = possible.y + (possible.height - otherArea.height) / 2;
 307                 }
 308
 309                 gtk_paint_arrow( style,
 310                                  widget->window,
 311                                  (GtkStateType)widget->state,
 312                                  GTK_SHADOW_ETCHED_OUT,
 313                                  NULL, /* clip area.  &area, */
 314                                  widget, /* may be NULL */
 315                                  NULL, /* detail */
 316                                  GTK_ARROW_LEFT,
 317                                  FALSE,
 318                                  otherArea.x, otherArea.y,
 319                                  otherArea.width, otherArea.height
 320                                  );
 321             }
 322         }
 323
 324         if ( preview->_previewPixbuf ) {
 325             GtkDrawingArea* da = &(preview->drawing);
 326             GdkDrawable* drawable = (GdkDrawable*) (((GtkWidget*)da)->window);
 327             gint w = 0;
 328             gint h = 0;
 329             gdk_drawable_get_size(drawable, &w, &h);
 330             if ((w != preview->_scaledW) || (h != preview->_scaledH)) {
 331                 if (preview->_scaled) {
 332                     g_object_unref(preview->_scaled);
 333                 }
 334                 preview->_scaled = gdk_pixbuf_scale_simple(preview->_previewPixbuf, w, h, GDK_INTERP_BILINEAR);
 335                 preview->_scaledW = w;
 336                 preview->_scaledH = h;
 337             }
 338
 339             GdkPixbuf* pix = (preview->_scaled) ? preview->_scaled : preview->_previewPixbuf;
 340             gdk_draw_pixbuf( drawable, 0, pix, 0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0 );
 341         }
 342
 343
 344         if ( GTK_WIDGET_HAS_FOCUS(widget) ) {
 345             gtk_paint_focus( style,
 346                              widget->window,
 347                              GTK_STATE_NORMAL,
 348                              NULL, /* GdkRectangle *area, */
 349                              widget,
 350                              NULL,
 351                              0 + 1, 0 + 1,
 352                              widget->allocation.width - 2, widget->allocation.height - 2 );
 353         }
 354     }
 355
 356
 357     return FALSE;
 358 }
 359
 360
 361 static gboolean eek_preview_enter_cb( GtkWidget* widget, GdkEventCrossing* event )
 362 {
 363     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 364         EekPreview* preview = EEK_PREVIEW(widget);
 365         preview->_within = TRUE;
 366         gtk_widget_set_state( widget, preview->_hot ? GTK_STATE_ACTIVE : GTK_STATE_PRELIGHT );
 367     }
 368     return FALSE;
 369 }
 370
 371 static gboolean eek_preview_leave_cb( GtkWidget* widget, GdkEventCrossing* event )
 372 {
 373     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 374         EekPreview* preview = EEK_PREVIEW(widget);
 375         preview->_within = FALSE;
 376         gtk_widget_set_state( widget, GTK_STATE_NORMAL );
 377     }
 378     return FALSE;
 379 }
 380
 381 /*
 382 static gboolean eek_preview_focus_in_event( GtkWidget* widget, GdkEventFocus* event )
 383 {
 384     g_message("focus IN");
 385     gboolean blip = parent_class->focus_in_event ? parent_class->focus_in_event(widget, event) : FALSE;
 386     return blip;
 387 }
 388
 389 static gboolean eek_preview_focus_out_event( GtkWidget* widget, GdkEventFocus* event )
 390 {
 391     g_message("focus OUT");
 392     gboolean blip = parent_class->focus_out_event ? parent_class->focus_out_event(widget, event) : FALSE;
 393     return blip;
 394 }
 395 */
 396
 397 static gboolean eek_preview_button_press_cb( GtkWidget* widget, GdkEventButton* event )
 398 {
 399     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 400         EekPreview* preview = EEK_PREVIEW(widget);
 401
 402         if ( preview->_takesFocus && !GTK_WIDGET_HAS_FOCUS(widget) ) {
 403             gtk_widget_grab_focus(widget);
 404         }
 405
 406         if ( event->button == PRIME_BUTTON_MAGIC_NUMBER ) {
 407             preview->_hot = TRUE;
 408             if ( preview->_within ) {
 409                 gtk_widget_set_state( widget, GTK_STATE_ACTIVE );
 410             }
 411         }
 412     }
 413
 414     return FALSE;
 415 }
 416
 417 static gboolean eek_preview_button_release_cb( GtkWidget* widget, GdkEventButton* event )
 418 {
 419     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 420         EekPreview* preview = EEK_PREVIEW(widget);
 421         preview->_hot = FALSE;
 422         gtk_widget_set_state( widget, GTK_STATE_NORMAL );
 423         if ( preview->_within && event->button == PRIME_BUTTON_MAGIC_NUMBER ) {
 424             gboolean isAlt = (event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK;
 425
 426             if ( isAlt ) {
 427                 g_signal_emit( widget, eek_preview_signals[ALTCLICKED_SIGNAL], 0, 2 );
 428             } else {
 429                 g_signal_emit( widget, eek_preview_signals[CLICKED_SIGNAL], 0 );
 430             }
 431         }
 432     }
 433     return FALSE;
 434 }
 435
 436 gboolean eek_preview_key_press_event( GtkWidget* widget, GdkEventKey* event)
 437 {
 438     (void)widget;
 439     (void)event;
 440     g_message("TICK");
 441     return FALSE;
 442 }
 443
 444 gboolean eek_preview_key_release_event( GtkWidget* widget, GdkEventKey* event)
 445 {
 446     (void)widget;
 447     (void)event;
 448     g_message("tock");
 449     return FALSE;
 450 }
 451
 452 static void eek_preview_get_property( GObject *object,
 453                                       guint property_id,
 454                                       GValue *value,
 455                                       GParamSpec *pspec)
 456 {
 457     GObjectClass* gobjClass = G_OBJECT_CLASS(parent_class);
 458     switch ( property_id ) {
 459         case FOCUS_PROP_ID:
 460         {
 461             EekPreview* preview = EEK_PREVIEW( object );
 462             g_value_set_boolean( value, preview->_takesFocus );
 463         }
 464         break;
 465         default:
 466         {
 467             if ( gobjClass->get_property ) {
 468                 gobjClass->get_property( object, property_id, value, pspec );
 469             }
 470         }
 471     }
 472 }
 473
 474 static void eek_preview_set_property( GObject *object,
 475                                       guint property_id,
 476                                       const GValue *value,
 477                                       GParamSpec *pspec)
 478 {
 479     GObjectClass* gobjClass = G_OBJECT_CLASS(parent_class);
 480     switch ( property_id ) {
 481         case FOCUS_PROP_ID:
 482         {
 483             EekPreview* preview = EEK_PREVIEW( object );
 484             gboolean val = g_value_get_boolean( value );
 485             if ( val != preview->_takesFocus ) {
 486                 preview->_takesFocus = val;
 487             }
 488         }
 489         break;
 490         default:
 491         {
 492             if ( gobjClass->set_property ) {
 493                 gobjClass->set_property( object, property_id, value, pspec );
 494             }
 495         }
 496     }
 497 }
 498
 499
 500 static gboolean eek_preview_popup_menu( GtkWidget* widget )
 501 {
 502 /*     g_message("Do the popup!"); */
 503     gboolean blip = parent_class->popup_menu ? parent_class->popup_menu(widget) : FALSE;
 504     return blip;
 505 }
 506
 507
 508 static void eek_preview_class_init( EekPreviewClass *klass )
 509 {
 510     GObjectClass* gobjClass = G_OBJECT_CLASS(klass);
 511     /*GtkObjectClass* objectClass = (GtkObjectClass*)klass;*/
 512     GtkWidgetClass* widgetClass = (GtkWidgetClass*)klass;
 513
 514     gobjClass->set_property = eek_preview_set_property;
 515     gobjClass->get_property = eek_preview_get_property;
 516
 517     /*objectClass->destroy = eek_preview_destroy;*/
 518
 519     parent_class = (GtkWidgetClass*)g_type_class_peek_parent( klass );
 520
 521     /*widgetClass->map = ;*/
 522     /*widgetClass->unmap = ;*/
 523     /*widgetClass->realize = ;*/
 524     /*widgetClass->unrealize = ;*/
 525     widgetClass->size_request = eek_preview_size_request;
 526     /*widgetClass->size_allocate = ;*/
 527     /*widgetClass->state_changed = ;*/
 528     /*widgetClass->style_set = ;*/
 529     /*widgetClass->grab_notify = ;*/
 530
 531     widgetClass->button_press_event = eek_preview_button_press_cb;
 532     widgetClass->button_release_event = eek_preview_button_release_cb;
 533     /*widgetClass->delete_event = ;*/
 534     /*widgetClass->destroy_event = ;*/
 535     widgetClass->expose_event = eek_preview_expose_event;
 536 /*     widgetClass->key_press_event = eek_preview_key_press_event; */
 537 /*     widgetClass->key_release_event = eek_preview_key_release_event; */
 538     widgetClass->enter_notify_event = eek_preview_enter_cb;
 539     widgetClass->leave_notify_event = eek_preview_leave_cb;
 540     /*widgetClass->configure_event = ;*/
 541     /*widgetClass->focus_in_event = eek_preview_focus_in_event;*/
 542     /*widgetClass->focus_out_event = eek_preview_focus_out_event;*/
 543
 544     /* selection */
 545     /*widgetClass->selection_get = ;*/
 546     /*widgetClass->selection_received = ;*/
 547
 548
 549     /* drag source: */
 550     /*widgetClass->drag_begin = ;*/
 551     /*widgetClass->drag_end = ;*/
 552     /*widgetClass->drag_data_get = ;*/
 553     /*widgetClass->drag_data_delete = ;*/
 554
 555     /* drag target: */
 556     /*widgetClass->drag_leave = ;*/
 557     /*widgetClass->drag_motion = ;*/
 558     /*widgetClass->drag_drop = ;*/
 559     /*widgetClass->drag_data_received = ;*/
 560
 561     /* For keybindings: */
 562     widgetClass->popup_menu = eek_preview_popup_menu;
 563     /*widgetClass->show_help = ;*/
 564
 565     /* Accessibility support: */
 566     /*widgetClass->get_accessible = ;*/
 567     /*widgetClass->screen_changed = ;*/
 568     /*widgetClass->can_activate_accel = ;*/
 569
 570
 571     eek_preview_signals[CLICKED_SIGNAL] =
 572         g_signal_new( "clicked",
 573                       G_TYPE_FROM_CLASS( klass ),
 574                       (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 575                       G_STRUCT_OFFSET( EekPreviewClass, clicked ),
 576                       NULL, NULL,
 577                       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0 );
 578
 579     eek_preview_signals[ALTCLICKED_SIGNAL] =
 580         g_signal_new( "alt-clicked",
 581                       G_TYPE_FROM_CLASS( klass ),
 582                       (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 583                       G_STRUCT_OFFSET( EekPreviewClass, clicked ),
 584                       NULL, NULL,
 585                       g_cclosure_marshal_VOID__INT, G_TYPE_NONE,
 586                       1, G_TYPE_INT );
 587
 588
 589     g_object_class_install_property( gobjClass,
 590                                      FOCUS_PROP_ID,
 591                                      g_param_spec_boolean(
 592                                          "focus-on-click",
 593                                          NULL,
 594                                          "flag to grab focus when clicked",
 595                                          TRUE,
 596                                          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
 597                                          )
 598         );
 599 }
 600
 601 void eek_preview_set_linked( EekPreview* splat, LinkType link )
 602 {
 603     link = (LinkType)(link & PREVIEW_LINK_ALL);
 604     if ( link != (LinkType)splat->_linked ) {
 605         splat->_linked = link;
 606
 607         gtk_widget_queue_draw( GTK_WIDGET(splat) );
 608     }
 609 }
 610
 611 LinkType eek_preview_get_linked( EekPreview* splat )
 612 {
 613     return (LinkType)splat->_linked;
 614 }
 615
 616 gboolean eek_preview_get_focus_on_click( EekPreview* preview )
 617 {
 618     return preview->_takesFocus;
 619 }
 620
 621 void eek_preview_set_focus_on_click( EekPreview* preview, gboolean focus_on_click )
 622 {
 623     if ( focus_on_click != preview->_takesFocus ) {
 624         preview->_takesFocus = focus_on_click;
 625     }
 626 }
 627
 628 void eek_preview_set_details( EekPreview* preview, PreviewStyle prevstyle, ViewType view, PreviewSize size, guint ratio )
 629 {
 630     preview->_prevstyle = prevstyle;
 631     preview->_view = view;
 632
 633     if ( size > PREVIEW_SIZE_LAST ) {
 634         size = PREVIEW_SIZE_LAST;
 635     }
 636     preview->_size = size;
 637
 638     if ( ratio > PREVIEW_MAX_RATIO ) {
 639         ratio = PREVIEW_MAX_RATIO;
 640     }
 641     preview->_ratio = ratio;
 642
 643     gtk_widget_queue_draw(GTK_WIDGET(preview));
 644 }
 645
 646 static void eek_preview_init( EekPreview *preview )
 647 {
 648     GtkWidget* widg = GTK_WIDGET(preview);
 649     GTK_WIDGET_SET_FLAGS( widg, GTK_CAN_FOCUS );
 650     GTK_WIDGET_SET_FLAGS( widg, GTK_RECEIVES_DEFAULT );
 651
 652     gtk_widget_set_sensitive( widg, TRUE );
 653
 654     gtk_widget_add_events(widg, GDK_BUTTON_PRESS_MASK
 655                           | GDK_BUTTON_RELEASE_MASK
 656                           | GDK_KEY_PRESS_MASK
 657                           | GDK_KEY_RELEASE_MASK
 658                           | GDK_FOCUS_CHANGE_MASK
 659                           | GDK_ENTER_NOTIFY_MASK
 660                           | GDK_LEAVE_NOTIFY_MASK );
 661
 662 /*    gtk_widget_add_events( widg, GDK_ALL_EVENTS_MASK );*/
 663
 664     preview->_r = 0x80;
 665     preview->_g = 0x80;
 666     preview->_b = 0xcc;
 667     preview->_scaledW = 0;
 668     preview->_scaledH = 0;
 669
 670     preview->_hot = FALSE;
 671     preview->_within = FALSE;
 672     preview->_takesFocus = FALSE;
 673
 674     preview->_prevstyle = PREVIEW_STYLE_ICON;
 675     preview->_view = VIEW_TYPE_LIST;
 676     preview->_size = PREVIEW_SIZE_SMALL;
 677     preview->_ratio = 100;
 678
 679     preview->_previewPixbuf = 0;
 680     preview->_scaled = 0;
 681
 682 /*
 683     GdkColor color = {0};
 684     color.red = (255 << 8) | 255;
 685
 686     GdkColor whack = {0};
 687     whack.green = (255 << 8) | 255;
 688
 689     gtk_widget_modify_bg( widg, GTK_STATE_NORMAL, &color );
 690     gtk_widget_modify_bg( widg, GTK_STATE_PRELIGHT, &whack );
 691 */
 692
 693 /*   GTK_STATE_ACTIVE, */
 694 /*   GTK_STATE_PRELIGHT, */
 695 /*   GTK_STATE_SELECTED, */
 696 /*   GTK_STATE_INSENSITIVE */
 697
 698     if ( 0 ) {
 699         GdkColor color = {0,0,0,0};
 700
 701         color.red = 0xffff;
 702         color.green = 0;
 703         color.blue = 0xffff;
 704         gdk_colormap_alloc_color( gdk_colormap_get_system(), &color, FALSE, TRUE );
 705         gtk_widget_modify_bg(widg, GTK_STATE_ACTIVE, &color);
 706
 707         color.red = 0;
 708         color.green = 0xffff;
 709         color.blue = 0;
 710         gdk_colormap_alloc_color( gdk_colormap_get_system(), &color, FALSE, TRUE );
 711         gtk_widget_modify_bg(widg, GTK_STATE_SELECTED, &color);
 712
 713         color.red = 0xffff;
 714         color.green = 0;
 715         color.blue = 0;
 716         gdk_colormap_alloc_color( gdk_colormap_get_system(), &color, FALSE, TRUE );
 717         gtk_widget_modify_bg( widg, GTK_STATE_PRELIGHT, &color );
 718     }
 719 }
 720
 721
 722 GtkWidget* eek_preview_new(void)
 723 {
 724     return GTK_WIDGET( g_object_new( EEK_PREVIEW_TYPE, NULL ) );
 725 }
 726
 727 /*
 728   Local Variables:
 729   mode:c++
 730   c-file-style:"stroustrup"
 731   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 732   indent-tabs-mode:nil
 733   fill-column:99
 734   End:
 735 */
 736 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :