src/dialogs/eek-preview.cpp

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   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
  40 #include <gtk/gtk.h>
  41 #include "eek-preview.h"
  42
  43 #define PRIME_BUTTON_MAGIC_NUMBER 1
  44
  45 #define FOCUS_PROP_ID 1
  46
  47 /* Keep in sycn with last value in eek-preview.h */
  48 #define PREVIEW_SIZE_LAST PREVIEW_SIZE_HUGE
  49 #define PREVIEW_SIZE_NEXTFREE (PREVIEW_SIZE_HUGE + 1)
  50
  51 #define PREVIEW_MAX_RATIO 500
  52
  53 static void eek_preview_class_init( EekPreviewClass *klass );
  54 static void eek_preview_init( EekPreview *preview );
  55
  56 static GtkWidgetClass* parent_class = 0;
  57
  58 void eek_preview_set_color( EekPreview* preview, int r, int g, int b )
  59 {
  60     if ( (preview->_r = r)
  61          || (preview->_g = g)
  62          || (preview->_b = b) ) {
  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
  72 GType eek_preview_get_type(void)
  73 {
  74     static GType preview_type = 0;
  75
  76     if (!preview_type) {
  77       static const GTypeInfo preview_info = {
  78           sizeof( EekPreviewClass ),
  79           NULL, /* base_init */
  80           NULL, /* base_finalize */
  81           (GClassInitFunc)eek_preview_class_init,
  82           NULL, /* class_finalize */
  83           NULL, /* class_data */
  84           sizeof( EekPreview ),
  85           0,    /* n_preallocs */
  86           (GInstanceInitFunc)eek_preview_init,
  87           NULL /* value_table */
  88       };
  89
  90
  91       preview_type = g_type_register_static( GTK_TYPE_DRAWING_AREA, "EekPreview", &preview_info, (GTypeFlags)0 );
  92     }
  93
  94     return preview_type;
  95 }
  96
  97 static gboolean setupDone = FALSE;
  98 static GtkRequisition sizeThings[PREVIEW_SIZE_NEXTFREE];
  99
 100 void eek_preview_set_size_mappings( guint count, GtkIconSize const* sizes )
 101 {
 102     gint width = 0;
 103     gint height = 0;
 104     gint smallest = 512;
 105     gint largest = 0;
 106     guint i = 0;
 107     guint delta = 0;
 108
 109     for ( i = 0; i < count; ++i ) {
 110         gboolean worked = gtk_icon_size_lookup( sizes[i], &width, &height );
 111         if ( worked ) {
 112             if ( width < smallest ) {
 113                 smallest = width;
 114             }
 115             if ( width > largest ) {
 116                 largest = width;
 117             }
 118         }
 119     }
 120
 121     smallest = (smallest * 3) / 4;
 122
 123     delta = largest - smallest;
 124
 125     for ( i = 0; i < G_N_ELEMENTS(sizeThings); ++i ) {
 126         guint val = smallest + ( (i * delta) / (G_N_ELEMENTS(sizeThings) - 1) );
 127         sizeThings[i].width = val;
 128         sizeThings[i].height = val;
 129     }
 130
 131     setupDone = TRUE;
 132 }
 133
 134 static void eek_preview_size_request( GtkWidget* widget, GtkRequisition* req )
 135 {
 136     gint width = 0;
 137     gint height = 0;
 138     EekPreview* preview = EEK_PREVIEW(widget);
 139
 140     if ( !setupDone ) {
 141         GtkIconSize sizes[] = {
 142             GTK_ICON_SIZE_MENU,
 143             GTK_ICON_SIZE_SMALL_TOOLBAR,
 144             GTK_ICON_SIZE_LARGE_TOOLBAR,
 145             GTK_ICON_SIZE_BUTTON,
 146             GTK_ICON_SIZE_DIALOG
 147         };
 148         eek_preview_set_size_mappings( G_N_ELEMENTS(sizes), sizes );
 149     }
 150
 151     width = sizeThings[preview->_size].width;
 152     height = sizeThings[preview->_size].height;
 153
 154     if ( preview->_view == VIEW_TYPE_LIST ) {
 155         width *= 3;
 156     }
 157
 158     if ( preview->_ratio != 100 ) {
 159         width = (width * preview->_ratio) / 100;
 160         if ( width < 0 ) {
 161             width = 1;
 162         }
 163     }
 164
 165     req->width = width;
 166     req->height = height;
 167 }
 168
 169 enum {
 170   CLICKED_SIGNAL,
 171   ALTCLICKED_SIGNAL,
 172   LAST_SIGNAL
 173 };
 174
 175
 176 static guint eek_preview_signals[LAST_SIGNAL] = { 0 };
 177
 178
 179 gboolean eek_preview_expose_event( GtkWidget* widget, GdkEventExpose* event )
 180 {
 181 /*     g_message("Exposed!!!   %s", GTK_WIDGET_HAS_FOCUS(widget) ? "XXX" : "---" ); */
 182     gint insetX = 0;
 183     gint insetY = 0;
 184
 185     (void)event;
 186 /*
 187     gint lower = widget->allocation.width;
 188     lower = (widget->allocation.height < lower) ? widget->allocation.height : lower;
 189     if ( lower > 16 ) {
 190         insetX++;
 191         if ( lower > 18 ) {
 192             insetX++;
 193             if ( lower > 22 ) {
 194                 insetX++;
 195                 if ( lower > 24 ) {
 196                     insetX++;
 197                     if ( lower > 32 ) {
 198                         insetX++;
 199                     }
 200                 }
 201             }
 202         }
 203         insetY = insetX;
 204     }
 205 */
 206
 207     if ( GTK_WIDGET_DRAWABLE( widget ) ) {
 208         GtkStyle* style = gtk_widget_get_style( widget );
 209
 210         if ( insetX > 0 || insetY > 0 ) {
 211             gtk_paint_flat_box( style,
 212                                 widget->window,
 213                                 (GtkStateType)GTK_WIDGET_STATE(widget),
 214                                 GTK_SHADOW_NONE,
 215                                 NULL,
 216                                 widget,
 217                                 NULL,
 218                                 0, 0,
 219                                 widget->allocation.width, widget->allocation.height);
 220         }
 221
 222         GdkGC *gc = gdk_gc_new( widget->window );
 223         EekPreview* preview = EEK_PREVIEW(widget);
 224         GdkColor fg = {0, preview->_r, preview->_g, preview->_b};
 225         gdk_colormap_alloc_color( gdk_colormap_get_system(), &fg, FALSE, TRUE );
 226
 227         gdk_gc_set_foreground( gc, &fg );
 228
 229         gdk_draw_rectangle( widget->window,
 230                             gc,
 231                             TRUE,
 232                             insetX, insetY,
 233                             widget->allocation.width - (insetX * 2), widget->allocation.height - (insetY * 2) );
 234
 235         if ( preview->_linked ) {
 236             /* Draw arrow */
 237             GdkRectangle possible = {insetX, insetY, (widget->allocation.width - (insetX * 2)), (widget->allocation.height - (insetY * 2)) };
 238             GdkRectangle area = {possible.x, possible.y, possible.width / 2, possible.height / 2 };
 239
 240             /* Make it square */
 241             if ( area.width > area.height )
 242                 area.width = area.height;
 243             if ( area.height > area.width )
 244                 area.height = area.width;
 245
 246             /* Center it horizontally */
 247             if ( area.width < possible.width ) {
 248                 int diff = (possible.width - area.width) / 2;
 249                 area.x += diff;
 250             }
 251
 252
 253             if ( preview->_linked & PREVIEW_LINK_IN ) {
 254                 gtk_paint_arrow( style,
 255                                  widget->window,
 256                                  (GtkStateType)widget->state,
 257                                  GTK_SHADOW_ETCHED_IN,
 258                                  NULL, /* clip area.  &area, */
 259                                  widget, /* may be NULL */
 260                                  NULL, /* detail */
 261                                  GTK_ARROW_DOWN,
 262                                  FALSE,
 263                                  area.x, area.y,
 264                                  area.width, area.height
 265                                  );
 266             }
 267
 268             if ( preview->_linked & PREVIEW_LINK_OUT ) {
 269                 GdkRectangle otherArea = {area.x, area.y, area.width, area.height};
 270                 if ( otherArea.height < possible.height ) {
 271                     otherArea.y = possible.y + (possible.height - otherArea.height);
 272                 }
 273
 274                 gtk_paint_arrow( style,
 275                                  widget->window,
 276                                  (GtkStateType)widget->state,
 277                                  GTK_SHADOW_ETCHED_OUT,
 278                                  NULL, /* clip area.  &area, */
 279                                  widget, /* may be NULL */
 280                                  NULL, /* detail */
 281                                  GTK_ARROW_UP,
 282                                  FALSE,
 283                                  otherArea.x, otherArea.y,
 284                                  otherArea.width, otherArea.height
 285                                  );
 286             }
 287
 288             if ( preview->_linked & PREVIEW_LINK_OTHER ) {
 289                 GdkRectangle otherArea = {insetX, area.y, area.width, area.height};
 290                 if ( otherArea.height < possible.height ) {
 291                     otherArea.y = possible.y + (possible.height - otherArea.height) / 2;
 292                 }
 293
 294                 gtk_paint_arrow( style,
 295                                  widget->window,
 296                                  (GtkStateType)widget->state,
 297                                  GTK_SHADOW_ETCHED_OUT,
 298                                  NULL, /* clip area.  &area, */
 299                                  widget, /* may be NULL */
 300                                  NULL, /* detail */
 301                                  GTK_ARROW_LEFT,
 302                                  FALSE,
 303                                  otherArea.x, otherArea.y,
 304                                  otherArea.width, otherArea.height
 305                                  );
 306             }
 307         }
 308
 309         if ( GTK_WIDGET_HAS_FOCUS(widget) ) {
 310             gtk_paint_focus( style,
 311                              widget->window,
 312                              GTK_STATE_NORMAL,
 313                              NULL, /* GdkRectangle *area, */
 314                              widget,
 315                              NULL,
 316                              0 + 1, 0 + 1,
 317                              widget->allocation.width - 2, widget->allocation.height - 2 );
 318         }
 319     }
 320
 321
 322     return FALSE;
 323 }
 324
 325
 326 static gboolean eek_preview_enter_cb( GtkWidget* widget, GdkEventCrossing* event )
 327 {
 328     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 329         EekPreview* preview = EEK_PREVIEW(widget);
 330         preview->_within = TRUE;
 331         gtk_widget_set_state( widget, preview->_hot ? GTK_STATE_ACTIVE : GTK_STATE_PRELIGHT );
 332     }
 333     return FALSE;
 334 }
 335
 336 static gboolean eek_preview_leave_cb( GtkWidget* widget, GdkEventCrossing* event )
 337 {
 338     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 339         EekPreview* preview = EEK_PREVIEW(widget);
 340         preview->_within = FALSE;
 341         gtk_widget_set_state( widget, GTK_STATE_NORMAL );
 342     }
 343     return FALSE;
 344 }
 345
 346 /*
 347 static gboolean eek_preview_focus_in_event( GtkWidget* widget, GdkEventFocus* event )
 348 {
 349     g_message("focus IN");
 350     gboolean blip = parent_class->focus_in_event ? parent_class->focus_in_event(widget, event) : FALSE;
 351     return blip;
 352 }
 353
 354 static gboolean eek_preview_focus_out_event( GtkWidget* widget, GdkEventFocus* event )
 355 {
 356     g_message("focus OUT");
 357     gboolean blip = parent_class->focus_out_event ? parent_class->focus_out_event(widget, event) : FALSE;
 358     return blip;
 359 }
 360 */
 361
 362 static gboolean eek_preview_button_press_cb( GtkWidget* widget, GdkEventButton* event )
 363 {
 364     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 365         EekPreview* preview = EEK_PREVIEW(widget);
 366
 367         if ( preview->_takesFocus && !GTK_WIDGET_HAS_FOCUS(widget) ) {
 368             gtk_widget_grab_focus(widget);
 369         }
 370
 371         if ( event->button == PRIME_BUTTON_MAGIC_NUMBER ) {
 372             preview->_hot = TRUE;
 373             if ( preview->_within ) {
 374                 gtk_widget_set_state( widget, GTK_STATE_ACTIVE );
 375             }
 376         }
 377     }
 378
 379     return FALSE;
 380 }
 381
 382 static gboolean eek_preview_button_release_cb( GtkWidget* widget, GdkEventButton* event )
 383 {
 384     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 385         EekPreview* preview = EEK_PREVIEW(widget);
 386         preview->_hot = FALSE;
 387         gtk_widget_set_state( widget, GTK_STATE_NORMAL );
 388         if ( preview->_within && event->button == PRIME_BUTTON_MAGIC_NUMBER ) {
 389             gboolean isAlt = (event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK;
 390
 391             if ( isAlt ) {
 392                 g_signal_emit( widget, eek_preview_signals[ALTCLICKED_SIGNAL], 0, 2 );
 393             } else {
 394                 g_signal_emit( widget, eek_preview_signals[CLICKED_SIGNAL], 0 );
 395             }
 396         }
 397     }
 398     return FALSE;
 399 }
 400
 401 gboolean eek_preview_key_press_event( GtkWidget* widget, GdkEventKey* event)
 402 {
 403     (void)widget;
 404     (void)event;
 405     g_message("TICK");
 406     return FALSE;
 407 }
 408
 409 gboolean eek_preview_key_release_event( GtkWidget* widget, GdkEventKey* event)
 410 {
 411     (void)widget;
 412     (void)event;
 413     g_message("tock");
 414     return FALSE;
 415 }
 416
 417 static void eek_preview_get_property( GObject *object,
 418                                       guint property_id,
 419                                       GValue *value,
 420                                       GParamSpec *pspec)
 421 {
 422     GObjectClass* gobjClass = G_OBJECT_CLASS(parent_class);
 423     switch ( property_id ) {
 424         case FOCUS_PROP_ID:
 425         {
 426             EekPreview* preview = EEK_PREVIEW( object );
 427             g_value_set_boolean( value, preview->_takesFocus );
 428         }
 429         break;
 430         default:
 431         {
 432             if ( gobjClass->get_property ) {
 433                 gobjClass->get_property( object, property_id, value, pspec );
 434             }
 435         }
 436     }
 437 }
 438
 439 static void eek_preview_set_property( GObject *object,
 440                                       guint property_id,
 441                                       const GValue *value,
 442                                       GParamSpec *pspec)
 443 {
 444     GObjectClass* gobjClass = G_OBJECT_CLASS(parent_class);
 445     switch ( property_id ) {
 446         case FOCUS_PROP_ID:
 447         {
 448             EekPreview* preview = EEK_PREVIEW( object );
 449             gboolean val = g_value_get_boolean( value );
 450             if ( val != preview->_takesFocus ) {
 451                 preview->_takesFocus = val;
 452             }
 453         }
 454         break;
 455         default:
 456         {
 457             if ( gobjClass->set_property ) {
 458                 gobjClass->set_property( object, property_id, value, pspec );
 459             }
 460         }
 461     }
 462 }
 463
 464
 465 static gboolean eek_preview_popup_menu( GtkWidget* widget )
 466 {
 467 /*     g_message("Do the popup!"); */
 468     gboolean blip = parent_class->popup_menu ? parent_class->popup_menu(widget) : FALSE;
 469     return blip;
 470 }
 471
 472
 473 static void eek_preview_class_init( EekPreviewClass *klass )
 474 {
 475     GObjectClass* gobjClass = G_OBJECT_CLASS(klass);
 476     /*GtkObjectClass* objectClass = (GtkObjectClass*)klass;*/
 477     GtkWidgetClass* widgetClass = (GtkWidgetClass*)klass;
 478
 479     gobjClass->set_property = eek_preview_set_property;
 480     gobjClass->get_property = eek_preview_get_property;
 481
 482     /*objectClass->destroy = eek_preview_destroy;*/
 483
 484     parent_class = (GtkWidgetClass*)g_type_class_peek_parent( klass );
 485
 486     /*widgetClass->map = ;*/
 487     /*widgetClass->unmap = ;*/
 488     /*widgetClass->realize = ;*/
 489     /*widgetClass->unrealize = ;*/
 490     widgetClass->size_request = eek_preview_size_request;
 491     /*widgetClass->size_allocate = ;*/
 492     /*widgetClass->state_changed = ;*/
 493     /*widgetClass->style_set = ;*/
 494     /*widgetClass->grab_notify = ;*/
 495
 496     widgetClass->button_press_event = eek_preview_button_press_cb;
 497     widgetClass->button_release_event = eek_preview_button_release_cb;
 498     /*widgetClass->delete_event = ;*/
 499     /*widgetClass->destroy_event = ;*/
 500     widgetClass->expose_event = eek_preview_expose_event;
 501 /*     widgetClass->key_press_event = eek_preview_key_press_event; */
 502 /*     widgetClass->key_release_event = eek_preview_key_release_event; */
 503     widgetClass->enter_notify_event = eek_preview_enter_cb;
 504     widgetClass->leave_notify_event = eek_preview_leave_cb;
 505     /*widgetClass->configure_event = ;*/
 506     /*widgetClass->focus_in_event = eek_preview_focus_in_event;*/
 507     /*widgetClass->focus_out_event = eek_preview_focus_out_event;*/
 508
 509     /* selection */
 510     /*widgetClass->selection_get = ;*/
 511     /*widgetClass->selection_received = ;*/
 512
 513
 514     /* drag source: */
 515     /*widgetClass->drag_begin = ;*/
 516     /*widgetClass->drag_end = ;*/
 517     /*widgetClass->drag_data_get = ;*/
 518     /*widgetClass->drag_data_delete = ;*/
 519
 520     /* drag target: */
 521     /*widgetClass->drag_leave = ;*/
 522     /*widgetClass->drag_motion = ;*/
 523     /*widgetClass->drag_drop = ;*/
 524     /*widgetClass->drag_data_received = ;*/
 525
 526     /* For keybindings: */
 527     widgetClass->popup_menu = eek_preview_popup_menu;
 528     /*widgetClass->show_help = ;*/
 529
 530     /* Accessibility support: */
 531     /*widgetClass->get_accessible = ;*/
 532     /*widgetClass->screen_changed = ;*/
 533     /*widgetClass->can_activate_accel = ;*/
 534
 535
 536     eek_preview_signals[CLICKED_SIGNAL] =
 537         g_signal_new( "clicked",
 538                       G_TYPE_FROM_CLASS( klass ),
 539                       (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 540                       G_STRUCT_OFFSET( EekPreviewClass, clicked ),
 541                       NULL, NULL,
 542                       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0 );
 543
 544     eek_preview_signals[ALTCLICKED_SIGNAL] =
 545         g_signal_new( "alt-clicked",
 546                       G_TYPE_FROM_CLASS( klass ),
 547                       (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 548                       G_STRUCT_OFFSET( EekPreviewClass, clicked ),
 549                       NULL, NULL,
 550                       g_cclosure_marshal_VOID__INT, G_TYPE_NONE,
 551                       1, G_TYPE_INT );
 552
 553
 554     g_object_class_install_property( gobjClass,
 555                                      FOCUS_PROP_ID,
 556                                      g_param_spec_boolean(
 557                                          "focus-on-click",
 558                                          NULL,
 559                                          "flag to grab focus when clicked",
 560                                          TRUE,
 561                                          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
 562                                          )
 563         );
 564 }
 565
 566 void eek_preview_set_linked( EekPreview* splat, LinkType link )
 567 {
 568     link = (LinkType)(link & PREVIEW_LINK_ALL);
 569     if ( link != (LinkType)splat->_linked ) {
 570         splat->_linked = link;
 571
 572         gtk_widget_queue_draw( GTK_WIDGET(splat) );
 573     }
 574 }
 575
 576 LinkType eek_preview_get_linked( EekPreview* splat )
 577 {
 578     return (LinkType)splat->_linked;
 579 }
 580
 581 gboolean eek_preview_get_focus_on_click( EekPreview* preview )
 582 {
 583     return preview->_takesFocus;
 584 }
 585
 586 void eek_preview_set_focus_on_click( EekPreview* preview, gboolean focus_on_click )
 587 {
 588     if ( focus_on_click != preview->_takesFocus ) {
 589         preview->_takesFocus = focus_on_click;
 590     }
 591 }
 592
 593 void eek_preview_set_details( EekPreview* preview, PreviewStyle prevstyle, ViewType view, PreviewSize size, guint ratio )
 594 {
 595     preview->_prevstyle = prevstyle;
 596     preview->_view = view;
 597
 598     if ( size > PREVIEW_SIZE_LAST ) {
 599         size = PREVIEW_SIZE_LAST;
 600     }
 601     preview->_size = size;
 602
 603     if ( ratio > PREVIEW_MAX_RATIO ) {
 604         ratio = PREVIEW_MAX_RATIO;
 605     }
 606     preview->_ratio = ratio;
 607
 608     gtk_widget_queue_draw(GTK_WIDGET(preview));
 609 }
 610
 611 static void eek_preview_init( EekPreview *preview )
 612 {
 613     GtkWidget* widg = GTK_WIDGET(preview);
 614     GTK_WIDGET_SET_FLAGS( widg, GTK_CAN_FOCUS );
 615     GTK_WIDGET_SET_FLAGS( widg, GTK_RECEIVES_DEFAULT );
 616
 617     gtk_widget_set_sensitive( widg, TRUE );
 618
 619     gtk_widget_add_events(widg, GDK_BUTTON_PRESS_MASK
 620                           | GDK_BUTTON_RELEASE_MASK
 621                           | GDK_KEY_PRESS_MASK
 622                           | GDK_KEY_RELEASE_MASK
 623                           | GDK_FOCUS_CHANGE_MASK
 624                           | GDK_ENTER_NOTIFY_MASK
 625                           | GDK_LEAVE_NOTIFY_MASK );
 626
 627 /*    gtk_widget_add_events( widg, GDK_ALL_EVENTS_MASK );*/
 628
 629     preview->_r = 0x80;
 630     preview->_g = 0x80;
 631     preview->_b = 0xcc;
 632
 633     preview->_hot = FALSE;
 634     preview->_within = FALSE;
 635     preview->_takesFocus = FALSE;
 636
 637     preview->_prevstyle = PREVIEW_STYLE_ICON;
 638     preview->_view = VIEW_TYPE_LIST;
 639     preview->_size = PREVIEW_SIZE_SMALL;
 640     preview->_ratio = 100;
 641
 642 /*
 643     GdkColor color = {0};
 644     color.red = (255 << 8) | 255;
 645
 646     GdkColor whack = {0};
 647     whack.green = (255 << 8) | 255;
 648
 649     gtk_widget_modify_bg( widg, GTK_STATE_NORMAL, &color );
 650     gtk_widget_modify_bg( widg, GTK_STATE_PRELIGHT, &whack );
 651 */
 652
 653 /*   GTK_STATE_ACTIVE, */
 654 /*   GTK_STATE_PRELIGHT, */
 655 /*   GTK_STATE_SELECTED, */
 656 /*   GTK_STATE_INSENSITIVE */
 657
 658   if ( 0 ) {
 659     GdkColor color = {0,0,0,0};
 660
 661     color.red = 0xffff;
 662     color.green = 0;
 663     color.blue = 0xffff;
 664     gdk_colormap_alloc_color( gdk_colormap_get_system(), &color, FALSE, TRUE );
 665     gtk_widget_modify_bg(widg, GTK_STATE_ACTIVE, &color);
 666
 667     color.red = 0;
 668     color.green = 0xffff;
 669     color.blue = 0;
 670     gdk_colormap_alloc_color( gdk_colormap_get_system(), &color, FALSE, TRUE );
 671     gtk_widget_modify_bg(widg, GTK_STATE_SELECTED, &color);
 672
 673     color.red = 0xffff;
 674     color.green = 0;
 675     color.blue = 0;
 676     gdk_colormap_alloc_color( gdk_colormap_get_system(), &color, FALSE, TRUE );
 677     gtk_widget_modify_bg( widg, GTK_STATE_PRELIGHT, &color );
 678   }
 679 }
 680
 681
 682 GtkWidget* eek_preview_new(void)
 683 {
 684     return GTK_WIDGET( g_object_new( EEK_PREVIEW_TYPE, NULL ) );
 685 }
 686