home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / brightness_contrast.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  13.6 KB  |  493 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  */
  18.  
  19. #include "config.h"
  20.  
  21. #include <gtk/gtk.h>
  22.  
  23. #include "apptypes.h"
  24.  
  25. #include "appenv.h"
  26. #include "brightness_contrast.h"
  27. #include "drawable.h"
  28. #include "gimplut.h"
  29. #include "gimpui.h"
  30. #include "gdisplay.h"
  31. #include "image_map.h"
  32. #include "lut_funcs.h"
  33.  
  34. #include "libgimp/gimpintl.h"
  35.  
  36. #define SLIDER_WIDTH 200
  37.  
  38. #define BRIGHTNESS  0x1
  39. #define CONTRAST    0x2
  40. #define ALL        (BRIGHTNESS | CONTRAST)
  41.  
  42. /*  the brightness-contrast structures  */
  43.  
  44. typedef struct _BrightnessContrast BrightnessContrast;
  45.  
  46. struct _BrightnessContrast
  47. {
  48.   gint x, y;    /*  coords for last mouse click  */
  49. };
  50.  
  51. typedef struct _BrightnessContrastDialog BrightnessContrastDialog;
  52.  
  53. struct _BrightnessContrastDialog
  54. {
  55.   GtkWidget     *shell;
  56.   GtkWidget     *gimage_name;
  57.  
  58.   GtkAdjustment *brightness_data;
  59.   GtkAdjustment *contrast_data;
  60.  
  61.   GimpDrawable  *drawable;
  62.   ImageMap       image_map;
  63.  
  64.   gdouble        brightness;
  65.   gdouble        contrast;
  66.  
  67.   gboolean       preview;
  68.  
  69.   GimpLut       *lut;
  70. };
  71.  
  72.  
  73. /*  the brightness-contrast tool options  */
  74. static ToolOptions *brightness_contrast_options = NULL;
  75.  
  76. /*  the brightness-contrast dialog  */
  77. static BrightnessContrastDialog *brightness_contrast_dialog = NULL;
  78.  
  79.  
  80. /*  brightness contrast action functions  */
  81.  
  82. static void   brightness_contrast_control (Tool *, ToolAction, gpointer);
  83.  
  84. static BrightnessContrastDialog * brightness_contrast_dialog_new (void);
  85.  
  86. static void   brightness_contrast_update          (BrightnessContrastDialog *,
  87.                            gint);
  88. static void   brightness_contrast_preview         (BrightnessContrastDialog *);
  89. static void   brightness_contrast_reset_callback  (GtkWidget *, gpointer);
  90. static void   brightness_contrast_ok_callback     (GtkWidget *, gpointer);
  91. static void   brightness_contrast_cancel_callback (GtkWidget *, gpointer);
  92. static void   brightness_contrast_preview_update  (GtkWidget *, gpointer);
  93. static void   brightness_contrast_brightness_adjustment_update (GtkAdjustment *,
  94.                                 gpointer);
  95. static void   brightness_contrast_contrast_adjustment_update   (GtkAdjustment *,
  96.                                 gpointer);
  97.  
  98. /*  brightness-contrast select action functions  */
  99.  
  100. static void
  101. brightness_contrast_control (Tool       *tool,
  102.                  ToolAction  action,
  103.                  gpointer    gdisp_ptr)
  104. {
  105.   switch (action)
  106.     {
  107.     case PAUSE:
  108.       break;
  109.  
  110.     case RESUME:
  111.       break;
  112.  
  113.     case HALT:
  114.       brightness_contrast_dialog_hide ();
  115.       break;
  116.  
  117.     default:
  118.       break;
  119.     }
  120. }
  121.  
  122. Tool *
  123. tools_new_brightness_contrast (void)
  124. {
  125.   Tool * tool;
  126.   BrightnessContrast * private;
  127.  
  128.   /*  The tool options  */
  129.   if (!brightness_contrast_options)
  130.     {
  131.       brightness_contrast_options =
  132.     tool_options_new (_("Brightness-Contrast"));
  133.       tools_register (BRIGHTNESS_CONTRAST, brightness_contrast_options);
  134.    }
  135.  
  136.   tool = tools_new_tool (BRIGHTNESS_CONTRAST);
  137.   private = g_new0 (BrightnessContrast, 1);
  138.  
  139.   tool->scroll_lock = TRUE;   /*  Disallow scrolling  */
  140.   tool->preserve    = FALSE;  /*  Don't preserve on drawable change  */
  141.  
  142.   tool->private = (void *) private;
  143.  
  144.   tool->control_func = brightness_contrast_control;
  145.  
  146.   return tool;
  147. }
  148.  
  149. void
  150. brightness_contrast_dialog_hide (void)
  151. {
  152.   if (brightness_contrast_dialog)
  153.     brightness_contrast_cancel_callback (NULL,
  154.                                      (gpointer) brightness_contrast_dialog);
  155. } 
  156.   
  157. void
  158. tools_free_brightness_contrast (Tool *tool)
  159. {
  160.   BrightnessContrast * bc;
  161.  
  162.   bc = (BrightnessContrast *) tool->private;
  163.  
  164.   /*  Close the brightness-contrast dialog  */
  165.   brightness_contrast_dialog_hide ();
  166.  
  167.   g_free (bc);
  168. }
  169.  
  170. void
  171. brightness_contrast_initialize (GDisplay *gdisp)
  172. {
  173.   if (drawable_indexed (gimage_active_drawable (gdisp->gimage)))
  174.     {
  175.       g_message (_("Brightness-Contrast does not operate on indexed drawables."));
  176.       return;
  177.     }
  178.  
  179.   /*  The brightness-contrast dialog  */
  180.   if (!brightness_contrast_dialog)
  181.     brightness_contrast_dialog = brightness_contrast_dialog_new ();
  182.   else
  183.     if (!GTK_WIDGET_VISIBLE (brightness_contrast_dialog->shell))
  184.       gtk_widget_show (brightness_contrast_dialog->shell);
  185.  
  186.   brightness_contrast_dialog->brightness = 0.0;
  187.   brightness_contrast_dialog->contrast   = 0.0;
  188.  
  189.   brightness_contrast_dialog->drawable = gimage_active_drawable (gdisp->gimage);
  190.   brightness_contrast_dialog->image_map =
  191.     image_map_create (gdisp, brightness_contrast_dialog->drawable);
  192.  
  193.   brightness_contrast_update (brightness_contrast_dialog, ALL);
  194. }
  195.  
  196. /********************************/
  197. /*  Brightness Contrast dialog  */
  198. /********************************/
  199.  
  200. static BrightnessContrastDialog *
  201. brightness_contrast_dialog_new (void)
  202. {
  203.   BrightnessContrastDialog *bcd;
  204.   GtkWidget *vbox;
  205.   GtkWidget *hbox;
  206.   GtkWidget *table;
  207.   GtkWidget *label;
  208.   GtkWidget *abox;
  209.   GtkWidget *spinbutton;
  210.   GtkWidget *slider;
  211.   GtkWidget *toggle;
  212.   GtkObject *data;
  213.  
  214.   bcd = g_new (BrightnessContrastDialog, 1);
  215.   bcd->preview = TRUE;
  216.  
  217.   bcd->lut = gimp_lut_new ();
  218.  
  219.   /*  The shell and main vbox  */
  220.   bcd->shell =
  221.     gimp_dialog_new (_("Brightness-Contrast"), "brightness_contrast",
  222.              tools_help_func, NULL,
  223.              GTK_WIN_POS_NONE,
  224.              FALSE, TRUE, FALSE,
  225.  
  226.              _("OK"), brightness_contrast_ok_callback,
  227.              bcd, NULL, NULL, TRUE, FALSE,
  228.              _("Reset"), brightness_contrast_reset_callback,
  229.              bcd, NULL, NULL, TRUE, FALSE,
  230.              _("Cancel"), brightness_contrast_cancel_callback,
  231.              bcd, NULL, NULL, FALSE, TRUE,
  232.  
  233.              NULL);
  234.  
  235.   vbox = gtk_vbox_new (FALSE, 4);
  236.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  237.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (bcd->shell)->vbox), vbox);
  238.  
  239.   /*  The table containing sliders  */
  240.   table = gtk_table_new (2, 3, FALSE);
  241.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  242.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  243.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  244.  
  245.   /*  Create the brightness scale widget  */
  246.   label = gtk_label_new (_("Brightness:"));
  247.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  248.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
  249.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  250.  
  251.   data = gtk_adjustment_new (0, -127, 127.0, 1.0, 10.0, 0.0);
  252.   bcd->brightness_data = GTK_ADJUSTMENT (data);
  253.   slider = gtk_hscale_new (GTK_ADJUSTMENT (data));
  254.   gtk_widget_set_usize (slider, SLIDER_WIDTH, -1);
  255.   gtk_scale_set_digits (GTK_SCALE (slider), 0);
  256.   gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
  257.   gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
  258.   gtk_table_attach_defaults (GTK_TABLE (table), slider, 1, 2, 0, 1);
  259.  
  260.   abox = gtk_vbox_new (FALSE, 0);
  261.   spinbutton = gtk_spin_button_new (bcd->brightness_data, 1.0, 0);
  262.   gtk_widget_set_usize (spinbutton, 75, -1);
  263.   gtk_box_pack_end (GTK_BOX (abox), spinbutton, FALSE, FALSE, 0);
  264.   gtk_table_attach (GTK_TABLE (table), abox, 2, 3, 0, 1,
  265.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  266.  
  267.   gtk_signal_connect (GTK_OBJECT (data), "value_changed",
  268.               GTK_SIGNAL_FUNC (brightness_contrast_brightness_adjustment_update),
  269.               bcd);
  270.  
  271.   gtk_widget_show (label);
  272.   gtk_widget_show (slider);
  273.   gtk_widget_show (spinbutton);
  274.   gtk_widget_show (abox);
  275.  
  276.   /*  Create the contrast scale widget  */
  277.   label = gtk_label_new (_("Contrast:"));
  278.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  279.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
  280.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  281.  
  282.   data = gtk_adjustment_new (0, -127.0, 127.0, 1.0, 10.0, 0.0);
  283.   bcd->contrast_data = GTK_ADJUSTMENT (data);
  284.   slider = gtk_hscale_new (GTK_ADJUSTMENT (data));
  285.   gtk_widget_set_usize (slider, SLIDER_WIDTH, -1);
  286.   gtk_scale_set_digits (GTK_SCALE (slider), 0);
  287.   gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
  288.   gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
  289.   gtk_table_attach_defaults (GTK_TABLE (table), slider, 1, 2, 1, 2);
  290.  
  291.   abox = gtk_vbox_new (FALSE, 0);
  292.   spinbutton = gtk_spin_button_new (bcd->contrast_data, 1.0, 0);
  293.   gtk_widget_set_usize (spinbutton, 75, -1);
  294.   gtk_box_pack_end (GTK_BOX (abox), spinbutton, FALSE, FALSE, 0);
  295.   gtk_table_attach (GTK_TABLE (table), abox, 2, 3, 1, 2,
  296.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  297.  
  298.   gtk_signal_connect (GTK_OBJECT (data), "value_changed",
  299.               GTK_SIGNAL_FUNC (brightness_contrast_contrast_adjustment_update),
  300.               bcd);
  301.  
  302.   gtk_widget_show (label);
  303.   gtk_widget_show (slider);
  304.   gtk_widget_show (spinbutton);
  305.   gtk_widget_show (abox);
  306.  
  307.   /*  Horizontal box for preview toggle button  */
  308.   hbox = gtk_hbox_new (FALSE, 4);
  309.   gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  310.  
  311.   /*  The preview toggle  */
  312.   toggle = gtk_check_button_new_with_label (_("Preview"));
  313.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bcd->preview);
  314.   gtk_box_pack_end (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
  315.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  316.               GTK_SIGNAL_FUNC (brightness_contrast_preview_update),
  317.               bcd);
  318.  
  319.   gtk_widget_show (toggle);
  320.   gtk_widget_show (hbox);
  321.  
  322.   gtk_widget_show (table);
  323.   gtk_widget_show (vbox);
  324.   gtk_widget_show (bcd->shell);
  325.  
  326.   return bcd;
  327. }
  328.  
  329. static void
  330. brightness_contrast_update (BrightnessContrastDialog *bcd,
  331.                 gint                      update)
  332. {
  333.   if (update & BRIGHTNESS)
  334.     {
  335.       gtk_adjustment_set_value (bcd->brightness_data, bcd->brightness);
  336.     }
  337.   if (update & CONTRAST)
  338.     {
  339.       gtk_adjustment_set_value (bcd->contrast_data, bcd->contrast);
  340.     }
  341. }
  342.  
  343. static void
  344. brightness_contrast_preview (BrightnessContrastDialog *bcd)
  345. {
  346.   if (!bcd->image_map)
  347.     {
  348.       g_message ("brightness_contrast_preview(): No image map");
  349.       return;
  350.     }
  351.  
  352.   active_tool->preserve = TRUE;
  353.   brightness_contrast_lut_setup (bcd->lut, bcd->brightness / 255.0,
  354.                  bcd->contrast / 127.0,
  355.                  gimp_drawable_bytes (bcd->drawable));
  356.   image_map_apply (bcd->image_map, (ImageMapApplyFunc) gimp_lut_process_2,
  357.            (void *) bcd->lut);
  358.   active_tool->preserve = FALSE;
  359. }
  360.  
  361. static void
  362. brightness_contrast_reset_callback (GtkWidget *widget,
  363.                     gpointer   data)
  364. {
  365.   BrightnessContrastDialog *bcd;
  366.  
  367.   bcd = (BrightnessContrastDialog *) data;
  368.  
  369.   bcd->brightness = 0.0;
  370.   bcd->contrast   = 0.0;
  371.  
  372.   brightness_contrast_update (bcd, ALL);
  373.  
  374.   if (bcd->preview)
  375.     brightness_contrast_preview (bcd);
  376. }
  377.  
  378. static void
  379. brightness_contrast_ok_callback (GtkWidget *widget,
  380.                  gpointer   data)
  381. {
  382.   BrightnessContrastDialog *bcd;
  383.  
  384.   bcd = (BrightnessContrastDialog *) data;
  385.  
  386.   gimp_dialog_hide (bcd->shell);
  387.  
  388.   active_tool->preserve = TRUE;
  389.  
  390.   if (!bcd->preview)
  391.   {
  392.     brightness_contrast_lut_setup (bcd->lut, bcd->brightness / 255.0,
  393.                    bcd->contrast / 127.0,
  394.                    gimp_drawable_bytes (bcd->drawable));
  395.     image_map_apply (bcd->image_map, (ImageMapApplyFunc) gimp_lut_process_2,
  396.              (void *) bcd->lut);
  397.   }
  398.  
  399.   if (bcd->image_map)
  400.     image_map_commit (bcd->image_map);
  401.  
  402.   active_tool->preserve = FALSE;
  403.  
  404.   bcd->image_map = NULL;
  405.  
  406.   active_tool->gdisp_ptr = NULL;
  407.   active_tool->drawable = NULL;
  408. }
  409.  
  410. static void
  411. brightness_contrast_cancel_callback (GtkWidget *widget,
  412.                      gpointer   data)
  413. {
  414.   BrightnessContrastDialog *bcd;
  415.  
  416.   bcd = (BrightnessContrastDialog *) data;
  417.  
  418.   gimp_dialog_hide (bcd->shell);
  419.  
  420.   if (bcd->image_map)
  421.     {
  422.       active_tool->preserve = TRUE;
  423.       image_map_abort (bcd->image_map);
  424.       active_tool->preserve = FALSE;
  425.  
  426.       bcd->image_map = NULL;
  427.       gdisplays_flush ();
  428.     }
  429.  
  430.   active_tool->gdisp_ptr = NULL;
  431.   active_tool->drawable = NULL;
  432. }
  433.  
  434. static void
  435. brightness_contrast_preview_update (GtkWidget *widget,
  436.                     gpointer   data)
  437. {
  438.   BrightnessContrastDialog *bcd;
  439.  
  440.   bcd = (BrightnessContrastDialog *) data;
  441.  
  442.   if (GTK_TOGGLE_BUTTON (widget)->active)
  443.     {
  444.       bcd->preview = TRUE;
  445.       brightness_contrast_preview (bcd);
  446.     }
  447.   else
  448.     {
  449.       bcd->preview = FALSE;
  450.       if (bcd->image_map)
  451.     {
  452.       active_tool->preserve = TRUE;
  453.       image_map_clear (bcd->image_map);
  454.       active_tool->preserve = FALSE;
  455.       gdisplays_flush ();
  456.     }
  457.     }
  458. }
  459.  
  460. static void
  461. brightness_contrast_brightness_adjustment_update (GtkAdjustment *adjustment,
  462.                           gpointer       data)
  463. {
  464.   BrightnessContrastDialog *bcd;
  465.  
  466.   bcd = (BrightnessContrastDialog *) data;
  467.  
  468.   if (bcd->brightness != adjustment->value)
  469.     {
  470.       bcd->brightness = adjustment->value;
  471.  
  472.       if (bcd->preview)
  473.     brightness_contrast_preview (bcd);
  474.     }
  475. }
  476.  
  477. static void
  478. brightness_contrast_contrast_adjustment_update (GtkAdjustment *adjustment,
  479.                         gpointer       data)
  480. {
  481.   BrightnessContrastDialog *bcd;
  482.  
  483.   bcd = (BrightnessContrastDialog *) data;
  484.  
  485.   if (bcd->contrast != adjustment->value)
  486.     {
  487.       bcd->contrast = adjustment->value;
  488.  
  489.       if (bcd->preview)
  490.     brightness_contrast_preview (bcd);
  491.     }
  492. }
  493.