← Back to branch summary

~valavanisalex/ubuntu/oneiric/inkscape/inkscape_0.48.1-2ubuntu4

« back to all changes in this revision

Viewing changes to src/widgets/eek-preview.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook, Ted Gould, Kees Cook
  • Date: 2009-06-24 14:00:43 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20090624140043-07stp20mry48hqup
Tags: 0.47~pre0-0ubuntu1
* New upstream release

[ Ted Gould ]
* debian/control: Adding libgsl0 and removing version specifics on boost

[ Kees Cook ]
* debian/watch: updated to run uupdate and mangle pre-release versions.
* Dropped patches that have been taken upstream:
  - 01_mips
  - 02-poppler-0.8.3
  - 03-chinese-inkscape
  - 05_fix_latex_patch
  - 06_gcc-4.4
  - 07_cdr2svg
  - 08_skip-bad-utf-on-pdf-import
  - 09_gtk-clist
  - 10_belarussian
  - 11_libpng
  - 12_desktop
  - 13_slider
  - 100_svg_import_improvements
  - 102_sp_pattern_painter_free
  - 103_bitmap_type_print

Show diffs side-by-side

added added

removed removed

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