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