igor ru.po
[goodguy/history.git] / cinelerra-5.1 / plugins / histogram / histogramwindow.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 1997-2011 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "bcdisplayinfo.h"
23 #include "bcsignals.h"
24 #include "cursors.h"
25 #include "histogram.h"
26 #include "histogramconfig.h"
27 #include "histogramwindow.h"
28 #include "keys.h"
29 #include "language.h"
30 #include "theme.h"
31
32 #include <unistd.h>
33
34
35
36
37 HistogramWindow::HistogramWindow(HistogramMain *plugin)
38  : PluginClientWindow(plugin,
39         plugin->w,
40         plugin->h,
41         440,
42         500,
43         1)
44 {
45         this->plugin = plugin;
46         active_value = 0;
47 }
48
49 HistogramWindow::~HistogramWindow()
50 {
51 }
52
53
54 void HistogramWindow::create_objects()
55 {
56         int margin = plugin->get_theme()->widget_border;
57         int x = margin, y = margin, x1 = margin;
58
59         add_subwindow(mode_v = new HistogramMode(plugin,
60                 x,
61                 y,
62                 HISTOGRAM_VALUE,
63                 _("Value")));
64         x += mode_v->get_w() + margin;
65         add_subwindow(mode_r = new HistogramMode(plugin,
66                 x,
67                 y,
68                 HISTOGRAM_RED,
69                 _("Red")));
70         x += mode_r->get_w() + margin;
71         add_subwindow(mode_g = new HistogramMode(plugin,
72                 x,
73                 y,
74                 HISTOGRAM_GREEN,
75                 _("Green")));
76         x += mode_g->get_w() + margin;
77         add_subwindow(mode_b = new HistogramMode(plugin,
78                 x,
79                 y,
80                 HISTOGRAM_BLUE,
81                 _("Blue")));
82
83
84         x = get_w() - margin - plugin->get_theme()->get_image_set("histogram_rgb_toggle")[0]->get_w();
85         add_subwindow(parade_on = new HistogramParade(plugin,
86                 this,
87                 x,
88                 y,
89                 1));
90         x -= parade_on->get_w() + margin;
91         add_subwindow(parade_off = new HistogramParade(plugin,
92                 this,
93                 x,
94                 y,
95                 0));
96
97
98         x = x1;
99         y += parade_on->get_h() + margin;
100         add_subwindow(canvas_title1 = new BC_Title(margin,
101                 y,
102                 "-10%"));
103         add_subwindow(canvas_title2 = new BC_Title(get_w() - get_text_width(MEDIUMFONT, "110%") - margin,
104                 y,
105                 "110%"));
106
107         y += canvas_title2->get_h() + margin;
108         x = x1;
109         canvas_h = get_h() - y - 210;
110
111
112         add_subwindow(low_input_carrot = new HistogramCarrot(plugin,
113                 this,
114                 x,
115                 y + canvas_h));
116
117         x = low_input_carrot->get_w() / 2 + x;
118         canvas_w = get_w() - x - x;
119
120         title1_x = x;
121         title2_x = x + (int)(canvas_w * -HIST_MIN_INPUT / FLOAT_RANGE);
122         title3_x = x + (int)(canvas_w * (1.0 - HIST_MIN_INPUT) / FLOAT_RANGE);
123         title4_x = x + (int)(canvas_w);
124
125
126
127
128
129         add_subwindow(canvas = new HistogramCanvas(plugin,
130                 this,
131                 x,
132                 y,
133                 canvas_w,
134                 canvas_h));
135
136 // Canvas border
137         draw_3d_border(x - 2,
138                 y - 2,
139                 canvas_w + 4,
140                 canvas_h + 4,
141                 get_bg_color(),
142                 BLACK,
143                 MDGREY,
144                 get_bg_color());
145
146 // Calculate output curve with no value function
147         plugin->tabulate_curve(plugin->mode, 0);
148
149         y += canvas->get_h();
150         x = margin;
151
152         add_subwindow(gamma_carrot = new HistogramCarrot(plugin,
153                 this,
154                 canvas->get_x() +
155                         canvas->get_w() / 2 -
156                         low_input_carrot->get_w() / 2 ,
157                 y));
158
159         add_subwindow(high_input_carrot = new HistogramCarrot(plugin,
160                 this,
161                 canvas->get_x() +
162                         canvas->get_w() -
163                         low_input_carrot->get_w() / 2,
164                 y));
165         y += low_input_carrot->get_h() + margin;
166
167
168 //      add_subwindow(title = new BC_Title(x, y, _("Input:")));
169 //      x += title->get_w() + margin;
170         low_input = new HistogramText(plugin,
171                 this,
172                 x,
173                 y);
174         low_input->create_objects();
175
176         x = get_w() / 2 - low_input->get_w() / 2;
177         gamma = new HistogramText(plugin,
178                 this,
179                 x,
180                 y);
181         gamma->create_objects();
182
183
184         x = get_w() - low_input->get_w() - margin;
185         high_input = new HistogramText(plugin,
186                 this,
187                 x,
188                 y);
189         high_input->create_objects();
190
191
192         y += high_input->get_h() + margin;
193         x = x1;
194
195
196
197         add_subwindow(output = new HistogramSlider(plugin,
198                 this,
199                 canvas->get_x(),
200                 y,
201                 canvas->get_w(),
202                 20,
203                 0));
204         output->update();
205
206 // Output border
207         draw_3d_border(output->get_x() - 2,
208                 output->get_y() - 2,
209                 output->get_w() + 4,
210                 output->get_h() + 4,
211                 get_bg_color(),
212                 BLACK,
213                 MDGREY,
214                 get_bg_color());
215
216
217         y += output->get_h();
218
219
220
221         add_subwindow(low_output_carrot = new HistogramCarrot(plugin,
222                 this,
223                 margin,
224                 y));
225
226         add_subwindow(high_output_carrot = new HistogramCarrot(plugin,
227                 this,
228                 canvas->get_x() +
229                         canvas->get_w() -
230                         low_output_carrot->get_w() / 2,
231                 y));
232         y += high_output_carrot->get_h() + margin;
233
234
235 //      add_subwindow(title = new BC_Title(x, y, _("Output:")));
236 //      x += title->get_w() + margin;
237         low_output = new HistogramText(plugin,
238                 this,
239                 x,
240                 y);
241         low_output->create_objects();
242         high_output = new HistogramText(plugin,
243                 this,
244                 get_w() - low_output->get_w() - margin,
245                 y);
246         high_output->create_objects();
247
248         x = x1;
249         y += high_output->get_h() + margin;
250
251         add_subwindow(bar = new BC_Bar(x, y, get_w() - margin * 2));
252         y += bar->get_h() + margin;
253
254         add_subwindow(automatic = new HistogramAuto(plugin,
255                 x,
256                 y));
257
258         //int y1 = y;
259         x = 200;
260         add_subwindow(threshold_title = new BC_Title(x, y, _("Threshold:")));
261         x += threshold_title->get_w() + margin;
262         threshold = new HistogramText(plugin,
263                 this,
264                 x,
265                 y);
266         threshold->create_objects();
267
268         x = get_w() / 2;
269         add_subwindow(reset = new HistogramReset(plugin,
270                 x,
271                 y + threshold->get_h() + margin));
272
273         x = x1;
274         y += automatic->get_h() + margin;
275         add_subwindow(plot = new HistogramPlot(plugin,
276                 x,
277                 y));
278
279         y += plot->get_h() + 5;
280         add_subwindow(split = new HistogramSplit(plugin,
281                 x,
282                 y));
283
284         update(1, 1, 1, 1);
285
286         flash(0);
287         show_window();
288 }
289
290
291
292 int HistogramWindow::resize_event(int w, int h)
293 {
294         int xdiff = w - get_w();
295         int ydiff = h - get_h();
296
297         parade_on->reposition_window(parade_on->get_x() + xdiff,
298                 parade_on->get_y());
299         parade_off->reposition_window(parade_off->get_x() + xdiff,
300                 parade_on->get_y());
301         canvas_title2->reposition_window(canvas_title2->get_x() + xdiff,
302                 canvas_title2->get_y());
303
304 // Canvas follows window size
305         canvas_w = canvas_w + xdiff;
306         canvas_h = canvas_h + ydiff;
307         canvas->reposition_window(canvas->get_x(),
308                 canvas->get_y(),
309                 canvas_w,
310                 canvas_h);
311
312 // Canvas border
313         draw_3d_border(canvas->get_x() - 2,
314                 canvas->get_y() - 2,
315                 canvas_w + 4,
316                 canvas_h + 4,
317                 get_bg_color(),
318                 BLACK,
319                 MDGREY,
320                 get_bg_color());
321
322         low_input_carrot->reposition_window(low_input_carrot->get_x(),
323                 low_input_carrot->get_y() + ydiff);
324         gamma_carrot->reposition_window(gamma_carrot->get_x(),
325                 gamma_carrot->get_y() + ydiff);
326         high_input_carrot->reposition_window(high_input_carrot->get_x(),
327                 high_input_carrot->get_y() + ydiff);
328
329         low_input->reposition_window(low_input->get_x(),
330                 low_input->get_y() + ydiff);
331         gamma->reposition_window(w / 2 - gamma->get_w() / 2,
332                 gamma->get_y() + ydiff);
333         high_input->reposition_window(high_input->get_x() + xdiff,
334                 low_input->get_y() + ydiff);
335
336         output->reposition_window(output->get_x(),
337                 output->get_y() + ydiff,
338                 output->get_w() + xdiff,
339                 output->get_h());
340         output->update();
341
342 // Output border
343         draw_3d_border(output->get_x() - 2,
344                 output->get_y() - 2,
345                 output->get_w() + 4,
346                 output->get_h() + 4,
347                 get_bg_color(),
348                 BLACK,
349                 MDGREY,
350                 get_bg_color());
351
352         low_output_carrot->reposition_window(low_output_carrot->get_x(),
353                 low_output_carrot->get_y() + ydiff);
354         high_output_carrot->reposition_window(high_output_carrot->get_x(),
355                 high_output_carrot->get_y() + ydiff);
356
357         low_output->reposition_window(low_output->get_x(),
358                 low_output->get_y() + ydiff);
359         high_output->reposition_window(high_output->get_x() + xdiff,
360                 high_output->get_y() + ydiff);
361
362         bar->reposition_window(bar->get_x(),
363                 bar->get_y() + ydiff,
364                 bar->get_w() + xdiff);
365
366         automatic->reposition_window(automatic->get_x(),
367                 automatic->get_y() + ydiff);
368         threshold_title->reposition_window(threshold_title->get_x(),
369                 threshold_title->get_y() + ydiff);
370         threshold->reposition_window(threshold->get_x(),
371                 threshold->get_y() + ydiff);
372         reset->reposition_window(reset->get_x(),
373                 reset->get_y() + ydiff);
374
375         plot->reposition_window(plot->get_x(),
376                 plot->get_y() + ydiff);
377         split->reposition_window(split->get_x(),
378                 split->get_y() + ydiff);
379
380         update(1, 1, 1, 1);
381
382         plugin->w = w;
383         plugin->h = h;
384         flash();
385         return 1;
386 }
387
388
389
390 int HistogramWindow::keypress_event()
391 {
392         int result = 0;
393
394         if(active_value)
395         {
396                 float sign = 1;
397                 for(int i = 0; i < HISTOGRAM_MODES; i++)
398                 {
399                         if(active_value == &plugin->config.gamma[i])
400                                 sign = -1;
401                 }
402
403                 if(get_keypress() == RIGHT || get_keypress() == UP)
404                 {
405                         *active_value += sign * PRECISION;
406                         plugin->config.boundaries();
407                         update(1, 1, 1, 0);
408                         plugin->send_configure_change();
409                         return 1;
410                 }
411                 else
412                 if(get_keypress() == LEFT || get_keypress() == DOWN)
413                 {
414                         *active_value -= sign * PRECISION;
415                         plugin->config.boundaries();
416                         update(1, 1, 1, 0);
417                         plugin->send_configure_change();
418                         return 1;
419                 }
420         }
421
422         return result;
423 }
424
425 void HistogramWindow::update(int do_canvases,
426         int do_carrots,
427         int do_text,
428         int do_toggles)
429 {
430         if(do_toggles)
431         {
432                 automatic->update(plugin->config.automatic);
433                 mode_v->update(plugin->mode == HISTOGRAM_VALUE ? 1 : 0);
434                 mode_r->update(plugin->mode == HISTOGRAM_RED ? 1 : 0);
435                 mode_g->update(plugin->mode == HISTOGRAM_GREEN ? 1 : 0);
436                 mode_b->update(plugin->mode == HISTOGRAM_BLUE ? 1 : 0);
437                 plot->update(plugin->config.plot);
438                 split->update(plugin->config.split);
439                 parade_on->update(plugin->parade ? 1 : 0);
440                 parade_off->update(plugin->parade ? 0 : 1);
441                 output->update();
442         }
443
444         if(do_canvases)
445         {
446                 update_canvas();
447         }
448
449         if(do_carrots)
450         {
451                 low_input_carrot->update();
452                 high_input_carrot->update();
453                 gamma_carrot->update();
454                 low_output_carrot->update();
455                 high_output_carrot->update();
456         }
457
458         if(do_text)
459         {
460                 low_input->update();
461                 gamma->update();
462                 high_input->update();
463                 low_output->update();
464                 high_output->update();
465                 threshold->update();
466         }
467
468
469 }
470
471
472 void HistogramWindow::draw_canvas_mode(int mode, int color, int y, int h)
473 {
474         int *accum = plugin->accum[mode];
475         int accum_per_canvas_i = HISTOGRAM_SLOTS / canvas_w + 1;
476         float accum_per_canvas_f = (float)HISTOGRAM_SLOTS / canvas_w;
477         int normalize = 0;
478         int max = 0;
479
480
481 // Draw histogram
482         for(int i = 0; i < HISTOGRAM_SLOTS; i++)
483         {
484                 if(accum && accum[i] > normalize) normalize = accum[i];
485         }
486
487
488         if(normalize)
489         {
490                 for(int i = 0; i < canvas_w; i++)
491                 {
492                         int accum_start = (int)(accum_per_canvas_f * i);
493                         int accum_end = accum_start + accum_per_canvas_i;
494                         max = 0;
495                         for(int j = accum_start; j < accum_end; j++)
496                         {
497                                 max = MAX(accum[j], max);
498                         }
499
500 //                      max = max * h / normalize;
501                         max = (int)(log(max) / log(normalize) * h);
502
503                         canvas->set_color(BLACK);
504                         canvas->draw_line(i, y, i, y + h - max);
505                         canvas->set_color(color);
506                         canvas->draw_line(i, y + h - max, i, y + h);
507                 }
508         }
509         else
510         {
511                 canvas->set_color(BLACK);
512                 canvas->draw_box(0, y, canvas_w, h);
513         }
514
515 // Draw overlays
516         canvas->set_color(WHITE);
517         canvas->set_line_width(2);
518         int y1 = 0;
519
520 // Draw output line
521         for(int i = 0; i < canvas_w; i++)
522         {
523                 float input = (float)i /
524                                 canvas_w *
525                                 FLOAT_RANGE +
526                                 HIST_MIN_INPUT;
527                 float output = plugin->calculate_level(input,
528                         mode,
529                         0);
530
531                 int y2 = h - (int)(output * h);
532                 if(i > 0)
533                 {
534                         canvas->draw_line(i - 1, y + y1, i, y + y2);
535                 }
536                 y1 = y2;
537         }
538
539         canvas->set_line_width(1);
540
541 }
542
543
544 void HistogramWindow::update_canvas()
545 {
546         if(plugin->parade)
547         {
548                 draw_canvas_mode(HISTOGRAM_RED, RED, 0, canvas_h / 3);
549                 draw_canvas_mode(HISTOGRAM_GREEN, GREEN, canvas_h / 3, canvas_h / 3);
550                 draw_canvas_mode(HISTOGRAM_BLUE, BLUE, canvas_h * 2 / 3, canvas_h - canvas_h * 2 / 3);
551         }
552         else
553         {
554                 draw_canvas_mode(plugin->mode, MEGREY, 0, canvas_h);
555         }
556
557
558 // Draw 0 and 100% lines.
559         canvas->set_color(RED);
560         int x = (int)(canvas_w * -HIST_MIN_INPUT / FLOAT_RANGE);
561         canvas->draw_line(x,
562                 0,
563                 x,
564                 canvas_h);
565         x = (int)(canvas_w * (1.0 - HIST_MIN_INPUT) / FLOAT_RANGE);
566         canvas->draw_line(x,
567                 0,
568                 x,
569                 canvas_h);
570         canvas->flash();
571 }
572
573
574
575
576 HistogramParade::HistogramParade(HistogramMain *plugin,
577         HistogramWindow *gui,
578         int x,
579         int y,
580         int value)
581  : BC_Toggle(x,
582         y,
583         value ? plugin->get_theme()->get_image_set("histogram_rgb_toggle") :
584                 plugin->get_theme()->get_image_set("histogram_toggle"),
585         0)
586 {
587         this->plugin = plugin;
588         this->gui = gui;
589         this->value = value;
590         if(value)
591                 set_tooltip(_("RGB Parade on"));
592         else
593                 set_tooltip(_("RGB Parade off"));
594 }
595
596 int HistogramParade::handle_event()
597 {
598         update(1);
599         plugin->parade = value;
600         gui->update(1,
601                 0,
602                 0,
603                 1);
604         return 1;
605 }
606
607
608
609
610
611
612
613 HistogramCanvas::HistogramCanvas(HistogramMain *plugin,
614         HistogramWindow *gui,
615         int x,
616         int y,
617         int w,
618         int h)
619  : BC_SubWindow(x,
620         y,
621         w,
622         h,
623         BLACK)
624 {
625         this->plugin = plugin;
626         this->gui = gui;
627 }
628
629 int HistogramCanvas::button_press_event()
630 {
631         int result = 0;
632         if(is_event_win() && cursor_inside())
633         {
634                 if(!plugin->dragging_point &&
635                         (!plugin->config.automatic || plugin->mode == HISTOGRAM_VALUE))
636                 {
637                         gui->deactivate();
638                 }
639         }
640         return result;
641 }
642
643 int HistogramCanvas::cursor_motion_event()
644 {
645         if(is_event_win() && cursor_inside())
646         {
647         }
648         return 0;
649 }
650
651 int HistogramCanvas::button_release_event()
652 {
653         return 0;
654 }
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669 HistogramReset::HistogramReset(HistogramMain *plugin,
670         int x,
671         int y)
672  : BC_GenericButton(x, y, _("Reset"))
673 {
674         this->plugin = plugin;
675 }
676 int HistogramReset::handle_event()
677 {
678         plugin->config.reset(0);
679         ((HistogramWindow*)plugin->thread->window)->update(1, 1, 1, 1);
680         plugin->send_configure_change();
681         return 1;
682 }
683
684
685
686
687
688
689
690 HistogramCarrot::HistogramCarrot(HistogramMain *plugin,
691         HistogramWindow *gui,
692         int x,
693         int y)
694  : BC_Toggle(x,
695         y,
696         plugin->get_theme()->get_image_set("histogram_carrot"),
697         0)
698 {
699         this->plugin = plugin;
700         this->gui = gui;
701         drag_operation = 0;
702 }
703
704 HistogramCarrot::~HistogramCarrot()
705 {
706 }
707
708 float* HistogramCarrot::get_value()
709 {
710         if(this == gui->low_input_carrot)
711         {
712                 return &plugin->config.low_input[plugin->mode];
713         }
714         else
715         if(this == gui->high_input_carrot)
716         {
717                 return &plugin->config.high_input[plugin->mode];
718         }
719         else
720         if(this == gui->gamma_carrot)
721         {
722                 return &plugin->config.gamma[plugin->mode];
723         }
724         else
725         if(this == gui->low_output_carrot)
726         {
727                 return &plugin->config.low_output[plugin->mode];
728         }
729         else
730         if(this == gui->high_output_carrot)
731         {
732                 return &plugin->config.high_output[plugin->mode];
733         }
734         return 0;
735 }
736
737 void HistogramCarrot::update()
738 {
739         int new_x = 0;
740         float *value = get_value();
741
742         if(this != gui->gamma_carrot)
743         {
744                 new_x = (int)(gui->canvas->get_x() +
745                         (*value - HIST_MIN_INPUT) *
746                         gui->canvas->get_w() /
747                         (HIST_MAX_INPUT - HIST_MIN_INPUT) -
748                         get_w() / 2);
749         }
750         else
751         {
752                 float min = plugin->config.low_input[plugin->mode];
753                 float max = plugin->config.high_input[plugin->mode];
754                 float delta = (max - min) / 2.0;
755                 float mid = min + delta;
756                 float tmp = log10(1.0 / *value);
757                 tmp = mid + delta * tmp;
758
759 //printf("HistogramCarrot::update %d %f %f\n", __LINE__, *value, tmp);
760
761                         new_x = gui->canvas->get_x() -
762                                 get_w() / 2 +
763                                 (int)(gui->canvas->get_w() *
764                                 (tmp - HIST_MIN_INPUT) /
765                                 (HIST_MAX_INPUT - HIST_MIN_INPUT));
766         }
767
768         reposition_window(new_x, get_y());
769 }
770
771 int HistogramCarrot::button_press_event()
772 {
773         if(is_event_win() && get_buttonpress() == 1)
774         {
775                 //int w = get_w();
776                 gui->deactivate();
777                 set_status(BC_Toggle::TOGGLE_DOWN);
778
779                 BC_Toggle::update(0);
780                 gui->active_value = get_value();
781 // Disable the other toggles
782                 if(this != gui->low_input_carrot) gui->low_input_carrot->BC_Toggle::update(0);
783                 if(this != gui->high_input_carrot) gui->high_input_carrot->BC_Toggle::update(0);
784                 if(this != gui->gamma_carrot) gui->gamma_carrot->BC_Toggle::update(0);
785                 if(this != gui->low_output_carrot) gui->low_output_carrot->BC_Toggle::update(0);
786                 if(this != gui->high_output_carrot) gui->high_output_carrot->BC_Toggle::update(0);
787                 starting_x = get_x();
788                 offset_x = gui->get_relative_cursor_x();
789                 offset_y = gui->get_relative_cursor_y();
790 //printf("HistogramCarrot::button_press_event %d %d %d\n", __LINE__, starting_x, offset_x);
791                 drag_operation = 1;
792                 draw_face(1, 1);
793                 return 1;
794         }
795         return 0;
796 }
797
798 int HistogramCarrot::button_release_event()
799 {
800         int result = BC_Toggle::button_release_event();
801         handle_event();
802         drag_operation = 0;
803         return result;
804 }
805
806 int HistogramCarrot::cursor_motion_event()
807 {
808         int cursor_x = gui->get_relative_cursor_x();
809
810         if(drag_operation)
811         {
812 //printf("HistogramCarrot::cursor_motion_event %d %d\n", __LINE__, cursor_x);
813                 int new_x = starting_x + cursor_x - offset_x;
814
815 // Clamp x
816 // Get level from x
817                 float *value = get_value();
818                 if(this == gui->gamma_carrot)
819                 {
820                         float min = gui->low_input_carrot->get_x();
821                         float max = gui->high_input_carrot->get_x();
822                         float delta = (max - min) / 2.0;
823                         if(delta >= 0.5)
824                         {
825                                 float mid = min + delta;
826                                 float tmp = (float)(new_x - mid) /
827                                         delta;
828                                 tmp = 1.0 / pow(10, tmp);
829                                 CLAMP(tmp, MIN_GAMMA, MAX_GAMMA);
830                                 *value = tmp;
831 //printf("HistogramCarrot::update %d %f\n", __LINE__, tmp);
832                         }
833                 }
834                 else
835                 {
836                         int min_x = gui->canvas->get_x() - get_w() / 2;
837                         int max_x = gui->canvas->get_x() + gui->canvas->get_w() - get_w() / 2;
838                         CLAMP(new_x, min_x, max_x);
839                         *value = HIST_MIN_INPUT +
840                                 (HIST_MAX_INPUT - HIST_MIN_INPUT) *
841                                 (new_x - min_x) /
842                                 (max_x - min_x);
843                 }
844
845                 reposition_window(new_x, get_y());
846                 flush();
847
848                 gui->update(1,
849                         (this == gui->low_input_carrot || this == gui->high_input_carrot),
850                         1,
851                         0);
852                 plugin->send_configure_change();
853
854                 return 1;
855         }
856         return 0;
857 }
858
859
860
861
862
863
864
865
866 HistogramSlider::HistogramSlider(HistogramMain *plugin,
867         HistogramWindow *gui,
868         int x,
869         int y,
870         int w,
871         int h,
872         int is_input)
873  : BC_SubWindow(x, y, w, h)
874 {
875         this->plugin = plugin;
876         this->gui = gui;
877         this->is_input = is_input;
878         operation = NONE;
879 }
880
881 int HistogramSlider::input_to_pixel(float input)
882 {
883         return (int)((input - HIST_MIN_INPUT) / FLOAT_RANGE * get_w());
884 }
885
886 void HistogramSlider::update()
887 {
888         int w = get_w();
889         int h = get_h();
890         //int half_h = get_h() / 2;
891         //int quarter_h = get_h() / 4;
892         int mode = plugin->mode;
893         int r = 0xff;
894         int g = 0xff;
895         int b = 0xff;
896
897         clear_box(0, 0, w, h);
898
899         switch(mode)
900         {
901                 case HISTOGRAM_RED:
902                         g = b = 0x00;
903                         break;
904                 case HISTOGRAM_GREEN:
905                         r = b = 0x00;
906                         break;
907                 case HISTOGRAM_BLUE:
908                         r = g = 0x00;
909                         break;
910         }
911
912         for(int i = 0; i < w; i++)
913         {
914                 int color = (int)(i * 0xff / w);
915                 set_color(((r * color / 0xff) << 16) |
916                         ((g * color / 0xff) << 8) |
917                         (b * color / 0xff));
918
919                 draw_line(i, 0, i, h);
920         }
921
922
923         flash();
924 }
925
926
927
928
929
930
931
932
933
934 HistogramAuto::HistogramAuto(HistogramMain *plugin,
935         int x,
936         int y)
937  : BC_CheckBox(x, y, plugin->config.automatic, _("Automatic"))
938 {
939         this->plugin = plugin;
940 }
941
942 int HistogramAuto::handle_event()
943 {
944         plugin->config.automatic = get_value();
945         plugin->send_configure_change();
946         return 1;
947 }
948
949
950
951
952 HistogramPlot::HistogramPlot(HistogramMain *plugin,
953         int x,
954         int y)
955  : BC_CheckBox(x, y, plugin->config.plot, _("Plot histogram"))
956 {
957         this->plugin = plugin;
958 }
959
960 int HistogramPlot::handle_event()
961 {
962         plugin->config.plot = get_value();
963         plugin->send_configure_change();
964         return 1;
965 }
966
967
968
969
970 HistogramSplit::HistogramSplit(HistogramMain *plugin,
971         int x,
972         int y)
973  : BC_CheckBox(x, y, plugin->config.split, _("Split output"))
974 {
975         this->plugin = plugin;
976 }
977
978 int HistogramSplit::handle_event()
979 {
980         plugin->config.split = get_value();
981         plugin->send_configure_change();
982         return 1;
983 }
984
985
986
987 HistogramMode::HistogramMode(HistogramMain *plugin,
988         int x,
989         int y,
990         int value,
991         char *text)
992  : BC_Radial(x, y, plugin->mode == value, text)
993 {
994         this->plugin = plugin;
995         this->value = value;
996 }
997 int HistogramMode::handle_event()
998 {
999         HistogramWindow *gui = (HistogramWindow*)plugin->thread->window;
1000         plugin->mode = value;
1001         plugin->current_point= -1;
1002         gui->active_value = 0;
1003         gui->low_input_carrot->BC_Toggle::update(0);
1004         gui->gamma_carrot->BC_Toggle::update(0);
1005         gui->high_input_carrot->BC_Toggle::update(0);
1006         gui->low_output_carrot->BC_Toggle::update(0);
1007         gui->high_output_carrot->BC_Toggle::update(0);
1008         gui->update(1, 1, 1, 1);
1009 //      plugin->send_configure_change();
1010         return 1;
1011 }
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022 HistogramText::HistogramText(HistogramMain *plugin,
1023         HistogramWindow *gui,
1024         int x,
1025         int y)
1026  : BC_TumbleTextBox(gui,
1027                 0.0,
1028                 (float)HIST_MIN_INPUT,
1029                 (float)HIST_MAX_INPUT,
1030                 x,
1031                 y,
1032                 70)
1033 {
1034         this->plugin = plugin;
1035         this->gui = gui;
1036         set_precision(DIGITS);
1037         set_increment(PRECISION);
1038 }
1039
1040 float* HistogramText::get_value()
1041 {
1042         if(this == gui->low_input)
1043         {
1044                 return &plugin->config.low_input[plugin->mode];
1045         }
1046         else
1047         if(this == gui->high_input)
1048         {
1049                 return &plugin->config.high_input[plugin->mode];
1050         }
1051         else
1052         if(this == gui->gamma)
1053         {
1054                 return &plugin->config.gamma[plugin->mode];
1055         }
1056         else
1057         if(this == gui->low_output)
1058         {
1059                 return &plugin->config.low_output[plugin->mode];
1060         }
1061         else
1062         if(this == gui->high_output)
1063         {
1064                 return &plugin->config.high_output[plugin->mode];
1065         }
1066         else
1067         if(this == gui->threshold)
1068         {
1069                 return &plugin->config.threshold;
1070         }
1071
1072         return 0;
1073 }
1074
1075 int HistogramText::handle_event()
1076 {
1077         float *output = get_value();
1078         if(output)
1079         {
1080                 *output = atof(get_text());
1081         }
1082
1083         gui->update(1, 1, 0, 0);
1084         plugin->send_configure_change();
1085         return 1;
1086 }
1087
1088 void HistogramText::update()
1089 {
1090         float *output = get_value();
1091         if(output)
1092         {
1093                 BC_TumbleTextBox::update(*output);
1094         }
1095 }
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110