← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/widgets/gimphistogramview.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2008-10-06 13:30:41 UTC
  • mto: This revision was merged to the branch mainline in revision 35.
  • Revision ID: james.westby@ubuntu.com-20081006133041-3panbkcanaymfsmp
Tags: upstream-2.6.0
Import upstream version 2.6.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/widgets/gimphistogramview.c
50
50
};
51
51
 
52
52
 
 
53
static void  gimp_histogram_view_finalize          (GObject        *object);
53
54
static void  gimp_histogram_view_set_property      (GObject        *object,
54
55
                                                    guint           property_id,
55
56
                                                    const GValue   *value,
58
59
                                                    guint           property_id,
59
60
                                                    GValue         *value,
60
61
                                                    GParamSpec     *pspec);
 
62
 
61
63
static void  gimp_histogram_view_size_request      (GtkWidget      *widget,
62
64
                                                    GtkRequisition *requisition);
63
65
static gboolean gimp_histogram_view_expose         (GtkWidget      *widget,
72
74
static void     gimp_histogram_view_draw_spike (GimpHistogramView    *view,
73
75
                                                GimpHistogramChannel  channel,
74
76
                                                GdkGC                *gc,
 
77
                                                GdkGC                *bg_gc,
75
78
                                                gint                  x,
76
79
                                                gint                  i,
77
80
                                                gint                  j,
78
81
                                                gdouble               max,
 
82
                                                gdouble               bg_max,
79
83
                                                gint                  height,
80
84
                                                gint                  border);
81
85
 
105
109
                  G_TYPE_INT,
106
110
                  G_TYPE_INT);
107
111
 
108
 
  object_class->get_property = gimp_histogram_view_get_property;
109
 
  object_class->set_property = gimp_histogram_view_set_property;
 
112
  object_class->finalize             = gimp_histogram_view_finalize;
 
113
  object_class->get_property         = gimp_histogram_view_get_property;
 
114
  object_class->set_property         = gimp_histogram_view_set_property;
110
115
 
111
116
  widget_class->size_request         = gimp_histogram_view_size_request;
112
117
  widget_class->expose_event         = gimp_histogram_view_expose;
114
119
  widget_class->button_release_event = gimp_histogram_view_button_release;
115
120
  widget_class->motion_notify_event  = gimp_histogram_view_motion_notify;
116
121
 
117
 
  klass->range_changed = NULL;
 
122
  klass->range_changed               = NULL;
118
123
 
119
124
  g_object_class_install_property (object_class, PROP_CHANNEL,
120
125
                                   g_param_spec_enum ("histogram-channel",
149
154
static void
150
155
gimp_histogram_view_init (GimpHistogramView *view)
151
156
{
152
 
  view->histogram = NULL;
153
 
  view->start     = 0;
154
 
  view->end       = 255;
 
157
  view->histogram    = NULL;
 
158
  view->bg_histogram = NULL;
 
159
  view->start        = 0;
 
160
  view->end          = 255;
 
161
}
 
162
 
 
163
static void
 
164
gimp_histogram_view_finalize (GObject *object)
 
165
{
 
166
  GimpHistogramView *view = GIMP_HISTOGRAM_VIEW (object);
 
167
 
 
168
  if (view->histogram)
 
169
    {
 
170
      gimp_histogram_unref (view->histogram);
 
171
      view->histogram = NULL;
 
172
    }
 
173
 
 
174
  if (view->bg_histogram)
 
175
    {
 
176
      gimp_histogram_unref (view->bg_histogram);
 
177
      view->bg_histogram = NULL;
 
178
    }
 
179
 
 
180
  G_OBJECT_CLASS (parent_class)->finalize (object);
155
181
}
156
182
 
157
183
static void
180
206
      view->subdivisions = g_value_get_int (value);
181
207
      gtk_widget_queue_draw (GTK_WIDGET (view));
182
208
      break;
 
209
 
183
210
   default:
184
211
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
185
212
      break;
208
235
    case PROP_SUBDIVISIONS:
209
236
      g_value_set_int (value, view->subdivisions);
210
237
      break;
 
238
 
211
239
   default:
212
240
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
213
241
      break;
226
254
 
227
255
static gdouble
228
256
gimp_histogram_view_get_maximum (GimpHistogramView    *view,
 
257
                                 GimpHistogram        *histogram,
229
258
                                 GimpHistogramChannel  channel)
230
259
{
231
 
  gdouble max = gimp_histogram_get_maximum (view->histogram, channel);
 
260
  gdouble max = gimp_histogram_get_maximum (histogram, channel);
232
261
 
233
262
  switch (view->scale)
234
263
    {
250
279
gimp_histogram_view_expose (GtkWidget      *widget,
251
280
                            GdkEventExpose *event)
252
281
{
253
 
  GimpHistogramView *view = GIMP_HISTOGRAM_VIEW (widget);
 
282
  GimpHistogramView *view  = GIMP_HISTOGRAM_VIEW (widget);
 
283
  GtkStyle          *style = gtk_widget_get_style (widget);
254
284
  gint               x;
255
285
  gint               x1, x2;
256
286
  gint               border;
257
287
  gint               width, height;
258
 
  gdouble            max;
 
288
  gdouble            max    = 0.0;
 
289
  gdouble            bg_max = 0.0;
259
290
  gint               xstop;
260
291
  GdkGC             *gc_in;
261
292
  GdkGC             *gc_out;
 
293
  GdkGC             *bg_gc_in;
 
294
  GdkGC             *bg_gc_out;
262
295
  GdkGC             *rgb_gc[3]  = { NULL, NULL, NULL };
263
296
 
264
 
  if (! view->histogram)
 
297
  if (! view->histogram && ! view->bg_histogram)
265
298
    return FALSE;
266
299
 
267
300
  border = view->border_width;
272
305
  x2 = CLAMP (MAX (view->start, view->end), 0, 255);
273
306
 
274
307
  gdk_draw_rectangle (widget->window,
275
 
                      widget->style->base_gc[GTK_STATE_NORMAL], TRUE,
 
308
                      style->base_gc[GTK_STATE_NORMAL], TRUE,
276
309
                      0, 0,
277
310
                      widget->allocation.width,
278
311
                      widget->allocation.height);
279
312
 
280
313
  /*  Draw the outer border  */
281
314
  gdk_draw_rectangle (widget->window,
282
 
                      widget->style->dark_gc[GTK_STATE_NORMAL], FALSE,
 
315
                      style->dark_gc[GTK_STATE_NORMAL], FALSE,
283
316
                      border, border,
284
317
                      width - 1, height - 1);
285
318
 
286
 
  max = gimp_histogram_view_get_maximum (view, view->channel);
287
 
 
288
 
  gc_in  = (view->light_histogram ?
289
 
            widget->style->mid_gc[GTK_STATE_SELECTED] :
290
 
            widget->style->text_gc[GTK_STATE_SELECTED]);
291
 
 
292
 
  gc_out = (view->light_histogram ?
293
 
            widget->style->mid_gc[GTK_STATE_NORMAL] :
294
 
            widget->style->text_gc[GTK_STATE_NORMAL]);
 
319
  if (view->histogram)
 
320
    max = gimp_histogram_view_get_maximum (view, view->histogram,
 
321
                                           view->channel);
 
322
 
 
323
  if (view->bg_histogram)
 
324
    bg_max = gimp_histogram_view_get_maximum (view, view->bg_histogram,
 
325
                                              view->channel);
 
326
 
 
327
  gc_in  = style->text_gc[GTK_STATE_SELECTED];
 
328
  gc_out = style->text_gc[GTK_STATE_NORMAL];
 
329
 
 
330
  bg_gc_in  = style->mid_gc[GTK_STATE_SELECTED];
 
331
  bg_gc_out = style->mid_gc[GTK_STATE_NORMAL];
295
332
 
296
333
  if (view->channel == GIMP_HISTOGRAM_RGB)
297
334
    {
333
370
      if (view->subdivisions > 1 && x >= (xstop * width / view->subdivisions))
334
371
        {
335
372
          gdk_draw_line (widget->window,
336
 
                         widget->style->dark_gc[GTK_STATE_NORMAL],
 
373
                         style->dark_gc[GTK_STATE_NORMAL],
337
374
                         x + border, border,
338
375
                         x + border, border + height - 1);
339
376
          xstop++;
341
378
      else if (in_selection)
342
379
        {
343
380
          gdk_draw_line (widget->window,
344
 
                         widget->style->base_gc[GTK_STATE_SELECTED],
 
381
                         style->base_gc[GTK_STATE_SELECTED],
345
382
                         x + border, border,
346
383
                         x + border, border + height - 1);
347
384
        }
352
389
 
353
390
          for (c = 0; c < 3; c++)
354
391
            gimp_histogram_view_draw_spike (view, GIMP_HISTOGRAM_RED + c,
355
 
                                            widget->style->black_gc,
356
 
                                            x, i, j, max, height, border);
 
392
                                            style->black_gc,
 
393
                                            NULL,
 
394
                                            x, i, j, max, bg_max, height, border);
357
395
 
358
396
          for (c = 0; c < 3; c++)
359
397
            gimp_histogram_view_draw_spike (view, GIMP_HISTOGRAM_RED + c,
360
398
                                            rgb_gc[c],
361
 
                                            x, i, j, max, height, border);
362
 
        }
 
399
                                            NULL,
 
400
                                            x, i, j, max, bg_max, height, border);
363
401
 
364
 
      gimp_histogram_view_draw_spike (view, view->channel,
365
 
                                      in_selection ? gc_in : gc_out,
366
 
                                      x, i, j, max, height, border);
 
402
          gimp_histogram_view_draw_spike (view, view->channel,
 
403
                                          in_selection ? gc_in : gc_out,
 
404
                                          NULL,
 
405
                                          x, i, j, max, bg_max, height, border);
 
406
        }
 
407
      else
 
408
        {
 
409
          gimp_histogram_view_draw_spike (view, view->channel,
 
410
                                          in_selection ? gc_in : gc_out,
 
411
                                          in_selection ? bg_gc_in  : bg_gc_out,
 
412
                                          x, i, j, max, bg_max, height, border);
 
413
        }
367
414
    }
368
415
 
369
416
  if (view->channel == GIMP_HISTOGRAM_RGB)
379
426
gimp_histogram_view_draw_spike (GimpHistogramView    *view,
380
427
                                GimpHistogramChannel  channel,
381
428
                                GdkGC                *gc,
 
429
                                GdkGC                *bg_gc,
382
430
                                gint                  x,
383
431
                                gint                  i,
384
432
                                gint                  j,
385
433
                                gdouble               max,
 
434
                                gdouble               bg_max,
386
435
                                gint                  height,
387
436
                                gint                  border)
388
437
{
389
 
  gdouble  value = 0.0;
 
438
  gdouble  value    = 0.0;
 
439
  gdouble  bg_value = 0.0;
390
440
  gint     y;
391
 
 
392
 
  do
393
 
    {
394
 
      gdouble v = gimp_histogram_get_value (view->histogram, channel, i++);
395
 
 
396
 
      if (v > value)
397
 
        value = v;
398
 
    }
399
 
  while (i < j);
400
 
 
401
 
  if (value <= 0.0)
 
441
  gint     bg_y;
 
442
 
 
443
  if (view->histogram)
 
444
    {
 
445
      do
 
446
        {
 
447
          gdouble v = gimp_histogram_get_value (view->histogram, channel, i++);
 
448
 
 
449
          if (v > value)
 
450
            value = v;
 
451
        }
 
452
      while (i < j);
 
453
    }
 
454
 
 
455
  if (bg_gc && view->bg_histogram)
 
456
    {
 
457
      do
 
458
        {
 
459
          gdouble v = gimp_histogram_get_value (view->bg_histogram, channel, i++);
 
460
 
 
461
          if (v > bg_value)
 
462
            bg_value = v;
 
463
        }
 
464
      while (i < j);
 
465
    }
 
466
 
 
467
  if (value <= 0.0 && bg_value <= 0.0)
402
468
    return;
403
469
 
404
470
  switch (view->scale)
405
471
    {
406
472
    case GIMP_HISTOGRAM_SCALE_LINEAR:
407
 
      y = (gint) (((height - 2) * value) / max);
 
473
      y    = (gint) (((height - 2) * value)    / max);
 
474
      bg_y = (gint) (((height - 2) * bg_value) / bg_max);
408
475
      break;
409
476
 
410
477
    case GIMP_HISTOGRAM_SCALE_LOGARITHMIC:
411
 
      y = (gint) (((height - 2) * log (value)) / max);
 
478
      y    = (gint) (((height - 2) * log (value))    / max);
 
479
      bg_y = (gint) (((height - 2) * log (bg_value)) / bg_max);
412
480
      break;
413
481
 
414
482
    default:
415
 
      y = 0;
 
483
      y    = 0;
 
484
      bg_y = 0;
416
485
      break;
417
486
    }
418
487
 
 
488
  if (bg_gc)
 
489
    gdk_draw_line (GTK_WIDGET (view)->window, bg_gc,
 
490
                   x + border, height + border - 1,
 
491
                   x + border, height + border - bg_y - 1);
 
492
 
419
493
  gdk_draw_line (GTK_WIDGET (view)->window, gc,
420
494
                 x + border, height + border - 1,
421
495
                 x + border, height + border - y - 1);
509
583
                                   GimpHistogram     *histogram)
510
584
{
511
585
  g_return_if_fail (GIMP_IS_HISTOGRAM_VIEW (view));
 
586
#if 0
 
587
  g_return_if_fail (histogram == NULL ||
 
588
                    view->bg_histogram == NULL ||
 
589
                    gimp_histogram_n_channels (view->bg_histogram) ==
 
590
                    gimp_histogram_n_channels (histogram));
 
591
#endif
512
592
 
513
593
  if (view->histogram != histogram)
514
594
    {
 
595
      if (view->histogram)
 
596
        gimp_histogram_unref (view->histogram);
 
597
 
515
598
      view->histogram = histogram;
516
599
 
517
 
      if (histogram && view->channel >= gimp_histogram_n_channels (histogram))
518
 
        gimp_histogram_view_set_channel (view, GIMP_HISTOGRAM_VALUE);
 
600
      if (histogram)
 
601
        {
 
602
          gimp_histogram_ref (histogram);
 
603
 
 
604
          if (view->channel >= gimp_histogram_n_channels (histogram))
 
605
            gimp_histogram_view_set_channel (view, GIMP_HISTOGRAM_VALUE);
 
606
        }
519
607
    }
520
608
 
521
609
  gtk_widget_queue_draw (GTK_WIDGET (view));
530
618
}
531
619
 
532
620
void
 
621
gimp_histogram_view_set_background (GimpHistogramView *view,
 
622
                                    GimpHistogram     *histogram)
 
623
{
 
624
  g_return_if_fail (GIMP_IS_HISTOGRAM_VIEW (view));
 
625
#if 0
 
626
  g_return_if_fail (histogram == NULL ||
 
627
                    view->histogram == NULL ||
 
628
                    gimp_histogram_n_channels (view->histogram) ==
 
629
                    gimp_histogram_n_channels (histogram));
 
630
#endif
 
631
 
 
632
  if (view->bg_histogram != histogram)
 
633
    {
 
634
      if (view->bg_histogram)
 
635
        gimp_histogram_unref (view->bg_histogram);
 
636
 
 
637
      view->bg_histogram = histogram;
 
638
 
 
639
      if (histogram)
 
640
        {
 
641
          gimp_histogram_ref (histogram);
 
642
 
 
643
          if (view->channel >= gimp_histogram_n_channels (histogram))
 
644
            gimp_histogram_view_set_channel (view, GIMP_HISTOGRAM_VALUE);
 
645
        }
 
646
    }
 
647
 
 
648
  gtk_widget_queue_draw (GTK_WIDGET (view));
 
649
}
 
650
 
 
651
GimpHistogram *
 
652
gimp_histogram_view_get_background (GimpHistogramView *view)
 
653
{
 
654
  g_return_val_if_fail (GIMP_IS_HISTOGRAM_VIEW (view), NULL);
 
655
 
 
656
  return view->bg_histogram;
 
657
}
 
658
 
 
659
void
533
660
gimp_histogram_view_set_channel (GimpHistogramView    *view,
534
661
                                 GimpHistogramChannel  channel)
535
662
{
536
663
  g_return_if_fail (GIMP_IS_HISTOGRAM_VIEW (view));
537
664
 
538
 
  g_object_set (view, "histogram-channel", channel, NULL);
 
665
  if (channel != view->channel)
 
666
    g_object_set (view, "histogram-channel", channel, NULL);
539
667
}
540
668
 
541
669
GimpHistogramChannel
552
680
{
553
681
  g_return_if_fail (GIMP_IS_HISTOGRAM_VIEW (view));
554
682
 
555
 
  g_object_set (view, "histogram-scale", scale, NULL);
 
683
  if (scale != view->scale)
 
684
    g_object_set (view, "histogram-scale", scale, NULL);
556
685
}
557
686
 
558
687
GimpHistogramScale
570
699
{
571
700
  g_return_if_fail (GIMP_IS_HISTOGRAM_VIEW (view));
572
701
 
573
 
  view->start = MIN (start, end);
574
 
  view->end   = MAX (start, end);
575
 
 
576
 
  gtk_widget_queue_draw (GTK_WIDGET (view));
577
 
 
578
 
  g_signal_emit (view, histogram_view_signals[RANGE_CHANGED], 0,
579
 
                 view->start, view->end);
 
702
  if (view->start != MIN (start, end) ||
 
703
      view->end   != MAX (start, end))
 
704
    {
 
705
      view->start = MIN (start, end);
 
706
      view->end   = MAX (start, end);
 
707
 
 
708
      gtk_widget_queue_draw (GTK_WIDGET (view));
 
709
 
 
710
      g_signal_emit (view, histogram_view_signals[RANGE_CHANGED], 0,
 
711
                     view->start, view->end);
 
712
    }
580
713
}
581
714
 
582
715
void