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 #include "path-prefix.h"
  46
  47 #define PRIME_BUTTON_MAGIC_NUMBER 1
  48
  49 #define FOCUS_PROP_ID 1
  50
  51 /* Keep in sycn with last value in eek-preview.h */
  52 #define PREVIEW_SIZE_LAST PREVIEW_SIZE_HUGE
  53 #define PREVIEW_SIZE_NEXTFREE (PREVIEW_SIZE_HUGE + 1)
  54
  55 #define PREVIEW_MAX_RATIO 500
  56
  57 static void eek_preview_class_init( EekPreviewClass *klass );
  58 static void eek_preview_init( EekPreview *preview );
  59
  60 static GtkWidgetClass* parent_class = 0;
  61
  62 void eek_preview_set_color( EekPreview* preview, int r, int g, int b )
  63 {
  64     preview->_r = r;
  65     preview->_g = g;
  66     preview->_b = b;
  67
  68     gtk_widget_queue_draw(GTK_WIDGET(preview));
  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
 226         gdk_colormap_alloc_color( gdk_colormap_get_system(), &fg, FALSE, TRUE );
 227
 228         gdk_gc_set_foreground( gc, &fg );
 229
 230         gdk_draw_rectangle( widget->window,
 231                             gc,
 232                             TRUE,
 233                             insetX, insetY,
 234                             widget->allocation.width - (insetX * 2), widget->allocation.height - (insetY * 2) );
 235
 236         if ( preview->_linked ) {
 237             /* Draw arrow */
 238             GdkRectangle possible = {insetX, insetY, (widget->allocation.width - (insetX * 2)), (widget->allocation.height - (insetY * 2)) };
 239             GdkRectangle area = {possible.x, possible.y, possible.width / 2, possible.height / 2 };
 240
 241             /* Make it square */
 242             if ( area.width > area.height )
 243                 area.width = area.height;
 244             if ( area.height > area.width )
 245                 area.height = area.width;
 246
 247             /* Center it horizontally */
 248             if ( area.width < possible.width ) {
 249                 int diff = (possible.width - area.width) / 2;
 250                 area.x += diff;
 251             }
 252
 253
 254             if ( preview->_linked & PREVIEW_LINK_IN ) {
 255                 gtk_paint_arrow( style,
 256                                  widget->window,
 257                                  (GtkStateType)widget->state,
 258                                  GTK_SHADOW_ETCHED_IN,
 259                                  NULL, /* clip area.  &area, */
 260                                  widget, /* may be NULL */
 261                                  NULL, /* detail */
 262                                  GTK_ARROW_DOWN,
 263                                  FALSE,
 264                                  area.x, area.y,
 265                                  area.width, area.height
 266                                  );
 267             }
 268
 269             if ( preview->_linked & PREVIEW_LINK_OUT ) {
 270                 GdkRectangle otherArea = {area.x, area.y, area.width, area.height};
 271                 if ( otherArea.height < possible.height ) {
 272                     otherArea.y = possible.y + (possible.height - otherArea.height);
 273                 }
 274
 275                 gtk_paint_arrow( style,
 276                                  widget->window,
 277                                  (GtkStateType)widget->state,
 278                                  GTK_SHADOW_ETCHED_OUT,
 279                                  NULL, /* clip area.  &area, */
 280                                  widget, /* may be NULL */
 281                                  NULL, /* detail */
 282                                  GTK_ARROW_UP,
 283                                  FALSE,
 284                                  otherArea.x, otherArea.y,
 285                                  otherArea.width, otherArea.height
 286                                  );
 287             }
 288
 289             if ( preview->_linked & PREVIEW_LINK_OTHER ) {
 290                 GdkRectangle otherArea = {insetX, area.y, area.width, area.height};
 291                 if ( otherArea.height < possible.height ) {
 292                     otherArea.y = possible.y + (possible.height - otherArea.height) / 2;
 293                 }
 294
 295                 gtk_paint_arrow( style,
 296                                  widget->window,
 297                                  (GtkStateType)widget->state,
 298                                  GTK_SHADOW_ETCHED_OUT,
 299                                  NULL, /* clip area.  &area, */
 300                                  widget, /* may be NULL */
 301                                  NULL, /* detail */
 302                                  GTK_ARROW_LEFT,
 303                                  FALSE,
 304                                  otherArea.x, otherArea.y,
 305                                  otherArea.width, otherArea.height
 306                                  );
 307             }
 308         }
 309
 310         if (preview->_isRemove){
 311             GtkDrawingArea* da = &(preview->drawing);
 312             GdkDrawable* drawable = (GdkDrawable*) (((GtkWidget*)da)->window);
 313             gint w,h;
 314             gdk_drawable_get_size(drawable, &w, &h);
 315             GError *error = NULL;
 316             gchar *filepath = (gchar *) g_strdup_printf("%s/remove-color.png", INKSCAPE_PIXMAPDIR);
 317             gsize bytesRead = 0;
 318             gsize bytesWritten = 0;
 319             gchar *localFilename = g_filename_from_utf8( filepath,
 320                                                  -1,
 321                                                  &bytesRead,
 322                                                  &bytesWritten,
 323                                                  &error);
 324             GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file_at_scale(localFilename, w, h, FALSE, &error);
 325             gdk_draw_pixbuf(drawable, 0, pixbuf, 0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0);
 326             g_free(localFilename);
 327             g_free(filepath);
 328         }
 329
 330
 331         if ( GTK_WIDGET_HAS_FOCUS(widget) ) {
 332             gtk_paint_focus( style,
 333                              widget->window,
 334                              GTK_STATE_NORMAL,
 335                              NULL, /* GdkRectangle *area, */
 336                              widget,
 337                              NULL,
 338                              0 + 1, 0 + 1,
 339                              widget->allocation.width - 2, widget->allocation.height - 2 );
 340         }
 341     }
 342
 343
 344     return FALSE;
 345 }
 346
 347
 348 static gboolean eek_preview_enter_cb( GtkWidget* widget, GdkEventCrossing* event )
 349 {
 350     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 351         EekPreview* preview = EEK_PREVIEW(widget);
 352         preview->_within = TRUE;
 353         gtk_widget_set_state( widget, preview->_hot ? GTK_STATE_ACTIVE : GTK_STATE_PRELIGHT );
 354     }
 355     return FALSE;
 356 }
 357
 358 static gboolean eek_preview_leave_cb( GtkWidget* widget, GdkEventCrossing* event )
 359 {
 360     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 361         EekPreview* preview = EEK_PREVIEW(widget);
 362         preview->_within = FALSE;
 363         gtk_widget_set_state( widget, GTK_STATE_NORMAL );
 364     }
 365     return FALSE;
 366 }
 367
 368 /*
 369 static gboolean eek_preview_focus_in_event( GtkWidget* widget, GdkEventFocus* event )
 370 {
 371     g_message("focus IN");
 372     gboolean blip = parent_class->focus_in_event ? parent_class->focus_in_event(widget, event) : FALSE;
 373     return blip;
 374 }
 375
 376 static gboolean eek_preview_focus_out_event( GtkWidget* widget, GdkEventFocus* event )
 377 {
 378     g_message("focus OUT");
 379     gboolean blip = parent_class->focus_out_event ? parent_class->focus_out_event(widget, event) : FALSE;
 380     return blip;
 381 }
 382 */
 383
 384 static gboolean eek_preview_button_press_cb( GtkWidget* widget, GdkEventButton* event )
 385 {
 386     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 387         EekPreview* preview = EEK_PREVIEW(widget);
 388
 389         if ( preview->_takesFocus && !GTK_WIDGET_HAS_FOCUS(widget) ) {
 390             gtk_widget_grab_focus(widget);
 391         }
 392
 393         if ( event->button == PRIME_BUTTON_MAGIC_NUMBER ) {
 394             preview->_hot = TRUE;
 395             if ( preview->_within ) {
 396                 gtk_widget_set_state( widget, GTK_STATE_ACTIVE );
 397             }
 398         }
 399     }
 400
 401     return FALSE;
 402 }
 403
 404 static gboolean eek_preview_button_release_cb( GtkWidget* widget, GdkEventButton* event )
 405 {
 406     if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
 407         EekPreview* preview = EEK_PREVIEW(widget);
 408         preview->_hot = FALSE;
 409         gtk_widget_set_state( widget, GTK_STATE_NORMAL );
 410         if ( preview->_within && event->button == PRIME_BUTTON_MAGIC_NUMBER ) {
 411             gboolean isAlt = (event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK;
 412
 413             if ( isAlt ) {
 414                 g_signal_emit( widget, eek_preview_signals[ALTCLICKED_SIGNAL], 0, 2 );
 415             } else {
 416                 g_signal_emit( widget, eek_preview_signals[CLICKED_SIGNAL], 0 );
 417             }
 418         }
 419     }
 420     return FALSE;
 421 }
 422
 423 gboolean eek_preview_key_press_event( GtkWidget* widget, GdkEventKey* event)
 424 {
 425     (void)widget;
 426     (void)event;
 427     g_message("TICK");
 428     return FALSE;
 429 }
 430
 431 gboolean eek_preview_key_release_event( GtkWidget* widget, GdkEventKey* event)
 432 {
 433     (void)widget;
 434     (void)event;
 435     g_message("tock");
 436     return FALSE;
 437 }
 438
 439 static void eek_preview_get_property( GObject *object,
 440                                       guint property_id,
 441                                       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             g_value_set_boolean( value, preview->_takesFocus );
 450         }
 451         break;
 452         default:
 453         {
 454             if ( gobjClass->get_property ) {
 455                 gobjClass->get_property( object, property_id, value, pspec );
 456             }
 457         }
 458     }
 459 }
 460
 461 static void eek_preview_set_property( GObject *object,
 462                                       guint property_id,
 463                                       const GValue *value,
 464                                       GParamSpec *pspec)
 465 {
 466     GObjectClass* gobjClass = G_OBJECT_CLASS(parent_class);
 467     switch ( property_id ) {
 468         case FOCUS_PROP_ID:
 469         {
 470             EekPreview* preview = EEK_PREVIEW( object );
 471             gboolean val = g_value_get_boolean( value );
 472             if ( val != preview->_takesFocus ) {
 473                 preview->_takesFocus = val;
 474             }
 475         }
 476         break;
 477         default:
 478         {
 479             if ( gobjClass->set_property ) {
 480                 gobjClass->set_property( object, property_id, value, pspec );
 481             }
 482         }
 483     }
 484 }
 485
 486
 487 static gboolean eek_preview_popup_menu( GtkWidget* widget )
 488 {
 489 /*     g_message("Do the popup!"); */
 490     gboolean blip = parent_class->popup_menu ? parent_class->popup_menu(widget) : FALSE;
 491     return blip;
 492 }
 493
 494
 495 static void eek_preview_class_init( EekPreviewClass *klass )
 496 {
 497     GObjectClass* gobjClass = G_OBJECT_CLASS(klass);
 498     /*GtkObjectClass* objectClass = (GtkObjectClass*)klass;*/
 499     GtkWidgetClass* widgetClass = (GtkWidgetClass*)klass;
 500
 501     gobjClass->set_property = eek_preview_set_property;
 502     gobjClass->get_property = eek_preview_get_property;
 503
 504     /*objectClass->destroy = eek_preview_destroy;*/
 505
 506     parent_class = (GtkWidgetClass*)g_type_class_peek_parent( klass );
 507
 508     /*widgetClass->map = ;*/
 509     /*widgetClass->unmap = ;*/
 510     /*widgetClass->realize = ;*/
 511     /*widgetClass->unrealize = ;*/
 512     widgetClass->size_request = eek_preview_size_request;
 513     /*widgetClass->size_allocate = ;*/
 514     /*widgetClass->state_changed = ;*/
 515     /*widgetClass->style_set = ;*/
 516     /*widgetClass->grab_notify = ;*/
 517
 518     widgetClass->button_press_event = eek_preview_button_press_cb;
 519     widgetClass->button_release_event = eek_preview_button_release_cb;
 520     /*widgetClass->delete_event = ;*/
 521     /*widgetClass->destroy_event = ;*/
 522     widgetClass->expose_event = eek_preview_expose_event;
 523 /*     widgetClass->key_press_event = eek_preview_key_press_event; */
 524 /*     widgetClass->key_release_event = eek_preview_key_release_event; */
 525     widgetClass->enter_notify_event = eek_preview_enter_cb;
 526     widgetClass->leave_notify_event = eek_preview_leave_cb;
 527     /*widgetClass->configure_event = ;*/
 528     /*widgetClass->focus_in_event = eek_preview_focus_in_event;*/
 529     /*widgetClass->focus_out_event = eek_preview_focus_out_event;*/
 530
 531     /* selection */
 532     /*widgetClass->selection_get = ;*/
 533     /*widgetClass->selection_received = ;*/
 534
 535
 536     /* drag source: */
 537     /*widgetClass->drag_begin = ;*/
 538     /*widgetClass->drag_end = ;*/
 539     /*widgetClass->drag_data_get = ;*/
 540     /*widgetClass->drag_data_delete = ;*/
 541
 542     /* drag target: */
 543     /*widgetClass->drag_leave = ;*/
 544     /*widgetClass->drag_motion = ;*/
 545     /*widgetClass->drag_drop = ;*/
 546     /*widgetClass->drag_data_received = ;*/
 547
 548     /* For keybindings: */
 549     widgetClass->popup_menu = eek_preview_popup_menu;
 550     /*widgetClass->show_help = ;*/
 551
 552     /* Accessibility support: */
 553     /*widgetClass->get_accessible = ;*/
 554     /*widgetClass->screen_changed = ;*/
 555     /*widgetClass->can_activate_accel = ;*/
 556
 557
 558     eek_preview_signals[CLICKED_SIGNAL] =
 559         g_signal_new( "clicked",
 560                       G_TYPE_FROM_CLASS( klass ),
 561                       (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 562                       G_STRUCT_OFFSET( EekPreviewClass, clicked ),
 563                       NULL, NULL,
 564                       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0 );
 565
 566     eek_preview_signals[ALTCLICKED_SIGNAL] =
 567         g_signal_new( "alt-clicked",
 568                       G_TYPE_FROM_CLASS( klass ),
 569                       (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 570                       G_STRUCT_OFFSET( EekPreviewClass, clicked ),
 571                       NULL, NULL,
 572                       g_cclosure_marshal_VOID__INT, G_TYPE_NONE,
 573                       1, G_TYPE_INT );
 574
 575
 576     g_object_class_install_property( gobjClass,
 577                                      FOCUS_PROP_ID,
 578                                      g_param_spec_boolean(
 579                                          "focus-on-click",
 580                                          NULL,
 581                                          "flag to grab focus when clicked",
 582                                          TRUE,
 583                                          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
 584                                          )
 585         );
 586 }
 587
 588 void eek_preview_set_linked( EekPreview* splat, LinkType link )
 589 {
 590     link = (LinkType)(link & PREVIEW_LINK_ALL);
 591     if ( link != (LinkType)splat->_linked ) {
 592         splat->_linked = link;
 593
 594         gtk_widget_queue_draw( GTK_WIDGET(splat) );
 595     }
 596 }
 597
 598 LinkType eek_preview_get_linked( EekPreview* splat )
 599 {
 600     return (LinkType)splat->_linked;
 601 }
 602
 603 gboolean eek_preview_get_focus_on_click( EekPreview* preview )
 604 {
 605     return preview->_takesFocus;
 606 }
 607
 608 void eek_preview_set_focus_on_click( EekPreview* preview, gboolean focus_on_click )
 609 {
 610     if ( focus_on_click != preview->_takesFocus ) {
 611         preview->_takesFocus = focus_on_click;
 612     }
 613 }
 614
 615 void eek_preview_set_details( EekPreview* preview, PreviewStyle prevstyle, ViewType view, PreviewSize size, guint ratio )
 616 {
 617     preview->_prevstyle = prevstyle;
 618     preview->_view = view;
 619
 620     if ( size > PREVIEW_SIZE_LAST ) {
 621         size = PREVIEW_SIZE_LAST;
 622     }
 623     preview->_size = size;
 624
 625     if ( ratio > PREVIEW_MAX_RATIO ) {
 626         ratio = PREVIEW_MAX_RATIO;
 627     }
 628     preview->_ratio = ratio;
 629
 630     gtk_widget_queue_draw(GTK_WIDGET(preview));
 631 }
 632
 633 static void eek_preview_init( EekPreview *preview )
 634 {
 635     GtkWidget* widg = GTK_WIDGET(preview);
 636     GTK_WIDGET_SET_FLAGS( widg, GTK_CAN_FOCUS );
 637     GTK_WIDGET_SET_FLAGS( widg, GTK_RECEIVES_DEFAULT );
 638
 639     gtk_widget_set_sensitive( widg, TRUE );
 640
 641     gtk_widget_add_events(widg, GDK_BUTTON_PRESS_MASK
 642                           | GDK_BUTTON_RELEASE_MASK
 643                           | GDK_KEY_PRESS_MASK
 644                           | GDK_KEY_RELEASE_MASK
 645                           | GDK_FOCUS_CHANGE_MASK
 646                           | GDK_ENTER_NOTIFY_MASK
 647                           | GDK_LEAVE_NOTIFY_MASK );
 648
 649 /*    gtk_widget_add_events( widg, GDK_ALL_EVENTS_MASK );*/
 650
 651     preview->_r = 0x80;
 652     preview->_g = 0x80;
 653     preview->_b = 0xcc;
 654
 655     preview->_hot = FALSE;
 656     preview->_within = FALSE;
 657     preview->_takesFocus = FALSE;
 658     preview->_isRemove = FALSE;
 659
 660     preview->_prevstyle = PREVIEW_STYLE_ICON;
 661     preview->_view = VIEW_TYPE_LIST;
 662     preview->_size = PREVIEW_SIZE_SMALL;
 663     preview->_ratio = 100;
 664
 665 /*
 666     GdkColor color = {0};
 667     color.red = (255 << 8) | 255;
 668
 669     GdkColor whack = {0};
 670     whack.green = (255 << 8) | 255;
 671
 672     gtk_widget_modify_bg( widg, GTK_STATE_NORMAL, &color );
 673     gtk_widget_modify_bg( widg, GTK_STATE_PRELIGHT, &whack );
 674 */
 675
 676 /*   GTK_STATE_ACTIVE, */
 677 /*   GTK_STATE_PRELIGHT, */
 678 /*   GTK_STATE_SELECTED, */
 679 /*   GTK_STATE_INSENSITIVE */
 680
 681     if ( 0 ) {
 682         GdkColor color = {0,0,0,0};
 683
 684         color.red = 0xffff;
 685         color.green = 0;
 686         color.blue = 0xffff;
 687         gdk_colormap_alloc_color( gdk_colormap_get_system(), &color, FALSE, TRUE );
 688         gtk_widget_modify_bg(widg, GTK_STATE_ACTIVE, &color);
 689
 690         color.red = 0;
 691         color.green = 0xffff;
 692         color.blue = 0;
 693         gdk_colormap_alloc_color( gdk_colormap_get_system(), &color, FALSE, TRUE );
 694         gtk_widget_modify_bg(widg, GTK_STATE_SELECTED, &color);
 695
 696         color.red = 0xffff;
 697         color.green = 0;
 698         color.blue = 0;
 699         gdk_colormap_alloc_color( gdk_colormap_get_system(), &color, FALSE, TRUE );
 700         gtk_widget_modify_bg( widg, GTK_STATE_PRELIGHT, &color );
 701     }
 702 }
 703
 704
 705 GtkWidget* eek_preview_new(void)
 706 {
 707     return GTK_WIDGET( g_object_new( EEK_PREVIEW_TYPE, NULL ) );
 708 }
 709
 710 /*
 711   Local Variables:
 712   mode:c++
 713   c-file-style:"stroustrup"
 714   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 715   indent-tabs-mode:nil
 716   fill-column:99
 717   End:
 718 */
 719 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :