home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / fp / fp_gtk.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-11-08  |  35.5 KB  |  1,169 lines
  1. #include "config.h"
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6.  
  7. #include <gtk/gtk.h>
  8.  
  9. #include <libgimp/gimp.h>
  10. #include <libgimp/gimpui.h>
  11.  
  12. #include "libgimp/stdplugins-intl.h"
  13.  
  14. #include "fp.h"
  15.  
  16. /* These values are translated for the GUI but also used internally
  17.    to figure out which button the user pushed, etc.
  18.    Not my design, please don't blame me -- njl */
  19.  
  20. static const gchar *hue_red     = N_("Red:");
  21. static const gchar *hue_green   = N_("Green:");
  22. static const gchar *hue_blue    = N_("Blue:");
  23. static const gchar *hue_cyan    = N_("Cyan:");
  24. static const gchar *hue_yellow  = N_("Yellow:");
  25. static const gchar *hue_magenta = N_("Magenta:");
  26.  
  27. static const gchar *val_darker  = N_("Darker:");
  28. static const gchar *val_lighter = N_("Lighter:");
  29.  
  30. static const gchar *sat_more    = N_("More Sat:");
  31. static const gchar *sat_less    = N_("Less Sat:");
  32.  
  33. static const gchar *current_val = N_("Current:");
  34.  
  35. AdvancedWindow AW = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
  36.  
  37. extern FP_Params Current;
  38.  
  39. extern GimpDrawable *drawable;
  40. extern GimpDrawable *mask;
  41.  
  42. FP_Intensity ShMidHi[]   = { SHADOWS, MIDTONES, HIGHLIGHTS };
  43. gint         HueSatVal[] = { BY_HUE, BY_SAT, BY_VAL };
  44.  
  45. gint nudgeArray[256];
  46.  
  47. GtkWidget *origPreview, *curPreview;
  48. GtkWidget *rPreview, *gPreview, *bPreview;
  49. GtkWidget *cPreview, *yPreview, *mPreview;
  50. GtkWidget *centerPreview;
  51. GtkWidget *darkerPreview, *lighterPreview, *middlePreview;
  52. GtkWidget *allOrSell, *dlg;
  53. GtkWidget *plusSatPreview, *SatPreview, *minusSatPreview;
  54.  
  55. struct
  56. {
  57.   GtkWidget *bna;
  58.   GtkWidget *palette;
  59.   GtkWidget *rough;
  60.   GtkWidget *range;
  61.   GtkWidget *show;
  62.   GtkWidget *lnd;
  63.   GtkWidget *pixelsBy;
  64.   GtkWidget *frameSelect;
  65.   GtkWidget *satur;
  66. } fpFrames;
  67.  
  68. fpInterface FPint =
  69. {
  70.   FALSE   /*  run  */
  71. };
  72.  
  73. ReducedImage *reduced;
  74.  
  75. /***********************************************************/
  76. /************   Main Dialog Window   ******************/
  77. /***********************************************************/
  78.  
  79. GtkWidget *
  80. fp_create_bna (void)
  81. {
  82.   GtkWidget *frame, *blabel, *alabel, *bframe, *aframe, *table;
  83.   
  84.   Create_A_Preview (&origPreview, &bframe, reduced->width, reduced->height);
  85.   Create_A_Preview (&curPreview, &aframe, reduced->width, reduced->height);
  86.   
  87.   frame = gtk_frame_new (_("Before and After"));
  88.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
  89.  
  90.   /* All the previews */
  91.   alabel = gtk_label_new (_("Current:"));
  92.   gtk_widget_show (alabel);
  93.   gtk_misc_set_alignment (GTK_MISC (alabel), 0.0, 0.5);
  94.  
  95.   blabel = gtk_label_new (_("Original:"));
  96.   gtk_widget_show (blabel);
  97.   gtk_misc_set_alignment (GTK_MISC (blabel), 0.0, 0.5);
  98.  
  99.   table = gtk_table_new (2, 2, FALSE);
  100.   gtk_container_set_border_width (GTK_CONTAINER (table), 4);
  101.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  102.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  103.  
  104.   gtk_container_add (GTK_CONTAINER (frame), table);
  105.   
  106.   gtk_table_attach (GTK_TABLE (table), blabel, 0, 1, 0, 1,
  107.             0, GTK_EXPAND | GTK_FILL, 0, 0);
  108.  
  109.   gtk_table_attach (GTK_TABLE (table), alabel, 1, 2, 0, 1,
  110.             0, GTK_EXPAND | GTK_FILL, 0, 0);
  111.  
  112.   gtk_table_attach (GTK_TABLE (table), bframe, 0, 1, 1, 2,
  113.             GTK_EXPAND, GTK_EXPAND, 0, 0);
  114.  
  115.   gtk_table_attach (GTK_TABLE (table), aframe, 1, 2, 1, 2,
  116.             GTK_EXPAND, GTK_EXPAND, 0, 0);
  117.  
  118.   gtk_widget_show (table);
  119.   gtk_widget_show (frame);
  120.  
  121.   return frame;
  122. }
  123.  
  124. /* close a sub dialog (from window manager) by simulating toggle click */
  125. void
  126. sub_dialog_destroy (GtkWidget *dialog,
  127.             GdkEvent  *ev,
  128.             gpointer   dummy)
  129. {
  130.   GtkWidget *button =
  131.     GTK_WIDGET (gtk_object_get_data (GTK_OBJECT (dialog), "ctrlButton"));
  132.  
  133.   gtk_signal_emit_by_name (GTK_OBJECT (button), "clicked", dialog);
  134. }
  135.  
  136. GtkWidget *
  137. fp_create_circle_palette (void)
  138. {
  139.   GtkWidget *frame, *table;
  140.   GtkWidget *rVbox, *rFrame;
  141.   GtkWidget *gVbox, *gFrame;
  142.   GtkWidget *bVbox, *bFrame;
  143.   GtkWidget *cVbox, *cFrame;
  144.   GtkWidget *yVbox, *yFrame;
  145.   GtkWidget *mVbox, *mFrame;
  146.   GtkWidget *centerVbox, *centerFrame;
  147.  
  148.   GtkWidget *win;
  149.  
  150.   frame = gtk_frame_new (NULL);
  151.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
  152.   gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
  153.   gtk_widget_show (frame);
  154.  
  155.   table = gtk_table_new (11, 11, FALSE);
  156.   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
  157.   gtk_widget_show (table);
  158.  
  159.   gtk_container_add (GTK_CONTAINER (frame), table);
  160.  
  161.   Create_A_Preview (&rPreview, &rFrame, reduced->width, reduced->height);
  162.   Create_A_Preview (&gPreview, &gFrame, reduced->width, reduced->height);
  163.   Create_A_Preview (&bPreview, &bFrame, reduced->width, reduced->height);
  164.   Create_A_Preview (&cPreview, &cFrame, reduced->width, reduced->height);
  165.   Create_A_Preview (&yPreview, &yFrame, reduced->width, reduced->height);
  166.   Create_A_Preview (&mPreview, &mFrame, reduced->width, reduced->height);
  167.   Create_A_Preview (¢erPreview, ¢erFrame,
  168.             reduced->width, reduced->height);
  169.  
  170.   Create_A_Table_Entry (&rVbox, rFrame, hue_red);
  171.   Create_A_Table_Entry (&gVbox, gFrame, hue_green);
  172.   Create_A_Table_Entry (&bVbox, bFrame, hue_blue);
  173.   Create_A_Table_Entry (&cVbox, cFrame, hue_cyan);
  174.   Create_A_Table_Entry (&yVbox, yFrame, hue_yellow);
  175.   Create_A_Table_Entry (&mVbox, mFrame, hue_magenta);
  176.   Create_A_Table_Entry (¢erVbox, centerFrame, current_val);
  177.   
  178.   gtk_table_attach (GTK_TABLE (table), rVbox, 8, 11 ,4 , 7,
  179.             GTK_EXPAND , GTK_EXPAND, 0 ,0);
  180.   gtk_table_attach (GTK_TABLE (table), gVbox, 2, 5, 0, 3,
  181.             GTK_EXPAND, GTK_EXPAND, 0, 0);
  182.   gtk_table_attach (GTK_TABLE (table), bVbox, 2, 5, 8, 11,
  183.             GTK_EXPAND, GTK_EXPAND,0,0);
  184.   gtk_table_attach (GTK_TABLE (table), cVbox, 0, 3, 4, 7,
  185.             GTK_EXPAND, GTK_EXPAND, 0 ,0);
  186.   gtk_table_attach (GTK_TABLE (table), yVbox, 6, 9, 0, 3,
  187.             GTK_EXPAND, GTK_EXPAND, 0 ,0);
  188.   gtk_table_attach (GTK_TABLE (table), mVbox, 6, 9, 8, 11,
  189.             GTK_EXPAND, GTK_EXPAND, 0 ,0);
  190.   gtk_table_attach (GTK_TABLE (table), centerVbox, 4, 7, 4, 7,
  191.             GTK_EXPAND, GTK_EXPAND, 0 ,0);
  192.  
  193.   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  194.  
  195.   gimp_help_connect_help_accel (win, gimp_standard_help_func, "filters/fp.html");
  196.  
  197.   gtk_window_set_title (GTK_WINDOW (win), _("Hue Variations"));
  198.   gtk_container_add (GTK_CONTAINER (win), frame);
  199.   gtk_signal_connect (GTK_OBJECT (win), "delete_event",
  200.               GTK_SIGNAL_FUNC (sub_dialog_destroy),
  201.               NULL);
  202.  
  203.   return win;
  204. }
  205.  
  206. GtkWidget *
  207. fp_create_rough (void)
  208. {
  209.   GtkWidget *frame, *scale, *vbox;
  210.   GtkObject *data;
  211.  
  212.   frame = gtk_frame_new (_("Roughness"));
  213.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
  214.   gtk_widget_show (frame);
  215.  
  216.   data = gtk_adjustment_new (Current.Rough, 0, 1.0, 0.05, 0.01, 0.0);
  217.   Current.roughnessScale = scale = gtk_hscale_new (GTK_ADJUSTMENT (data));
  218.  
  219.   gtk_widget_set_usize (scale, 60, 0);
  220.   gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  221.   gtk_scale_set_digits (GTK_SCALE (scale), 2);
  222.   gtk_signal_connect (GTK_OBJECT (data), "value_changed",
  223.               GTK_SIGNAL_FUNC (fp_scale_update),
  224.               &Current.Rough);      
  225.   gtk_widget_show (scale);
  226.  
  227.   vbox = gtk_vbox_new (FALSE, 2);
  228.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  229.   gtk_widget_show (vbox);
  230.   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
  231.   gtk_container_add (GTK_CONTAINER( frame), vbox);
  232.   
  233.   return frame;
  234. }
  235.  
  236. GtkWidget *
  237. fp_create_range (void)
  238. {
  239.   GtkWidget *frame, *vbox;
  240.   GSList *group=NULL;
  241.  
  242.   frame = gtk_frame_new (_("Affected Range"));
  243.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
  244.    
  245.   gtk_widget_show (frame);
  246.  
  247.   vbox = gtk_vbox_new (FALSE, 2);
  248.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  249.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);  
  250.   gtk_widget_show (vbox);
  251.  
  252.   group = Button_In_A_Box (vbox, group, _("Shadows"), 
  253.                GTK_SIGNAL_FUNC (fp_change_current_range),
  254.                ShMidHi + SHADOWS,
  255.                Current.Range == SHADOWS);
  256.   group = Button_In_A_Box (vbox, group, _("Midtones"), 
  257.                GTK_SIGNAL_FUNC (fp_change_current_range),
  258.                ShMidHi + MIDTONES,
  259.                Current.Range == MIDTONES);
  260.   group = Button_In_A_Box (vbox, group, _("Highlights"), 
  261.                GTK_SIGNAL_FUNC (fp_change_current_range),
  262.                ShMidHi + HIGHLIGHTS,
  263.                Current.Range == HIGHLIGHTS);
  264.  
  265.   return frame;
  266. }
  267.  
  268. GtkWidget *
  269. fp_create_control (void)
  270. {
  271.   GtkWidget *frame, *box;
  272.  
  273.   frame = gtk_frame_new (_("Windows"));
  274.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
  275.    
  276.   gtk_widget_show (frame);
  277.  
  278.   box = gtk_vbox_new (FALSE, 2);
  279.   gtk_container_add (GTK_CONTAINER (frame), box);
  280.   gtk_container_set_border_width (GTK_CONTAINER (box), 4);  
  281.   gtk_widget_show (box);
  282.  
  283.   Frames_Check_Button_In_A_Box (box, _("Hue"),
  284.                 GTK_SIGNAL_FUNC (fp_show_hide_frame),
  285.                 fpFrames.palette,
  286.                 Current.VisibleFrames & HUE);
  287.   Frames_Check_Button_In_A_Box (box, _("Saturation"),
  288.                 GTK_SIGNAL_FUNC (fp_show_hide_frame),
  289.                 fpFrames.satur,
  290.                 Current.VisibleFrames & SATURATION);
  291.   Frames_Check_Button_In_A_Box (box, _("Value"),
  292.                 GTK_SIGNAL_FUNC (fp_show_hide_frame),
  293.                 fpFrames.lnd,
  294.                 Current.VisibleFrames & VALUE);
  295.   Frames_Check_Button_In_A_Box (box, _("Advanced"),
  296.                 GTK_SIGNAL_FUNC (fp_show_hide_frame),
  297.                 AW.window,
  298.                 FALSE); 
  299.  
  300.   return frame;
  301. }
  302.  
  303. GtkWidget *
  304. fp_create_lnd (void)
  305. {
  306.   GtkWidget *frame, *table, *lighterFrame, *middleFrame, *darkerFrame;
  307.   GtkWidget *lighterVbox, *middleVbox, *darkerVbox;
  308.   GtkWidget *win;
  309.  
  310.   Create_A_Preview (&lighterPreview, &lighterFrame,
  311.             reduced->width, reduced->height);
  312.   Create_A_Preview (&middlePreview, &middleFrame,
  313.             reduced->width, reduced->height);
  314.   Create_A_Preview (&darkerPreview, &darkerFrame,
  315.             reduced->width, reduced->height);
  316.  
  317.   Create_A_Table_Entry (&lighterVbox, lighterFrame, val_lighter);
  318.   Create_A_Table_Entry (&middleVbox, middleFrame, current_val);
  319.   Create_A_Table_Entry (&darkerVbox, darkerFrame, val_darker);
  320.  
  321.   frame = gtk_frame_new (NULL);
  322.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
  323.   gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
  324.   gtk_widget_show (frame);
  325.  
  326.   table = gtk_table_new (1, 11, FALSE);
  327.   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
  328.   gtk_widget_show (table);
  329.  
  330.     
  331.   gtk_table_attach (GTK_TABLE (table), lighterVbox, 0, 3, 0, 1,
  332.             GTK_EXPAND , GTK_EXPAND, 0, 0);
  333.   gtk_table_attach (GTK_TABLE (table), middleVbox, 4, 7, 0, 1,
  334.             GTK_EXPAND, GTK_EXPAND, 0, 0);
  335.   gtk_table_attach (GTK_TABLE (table), darkerVbox, 8, 11, 0, 1,
  336.             GTK_EXPAND, GTK_EXPAND, 0, 0);
  337.   gtk_container_add (GTK_CONTAINER (frame), table);
  338.  
  339.   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  340.  
  341.   gimp_help_connect_help_accel (win, gimp_standard_help_func, "filters/fp.html");
  342.  
  343.   gtk_window_set_title (GTK_WINDOW (win), _("Value Variations"));
  344.   gtk_container_add (GTK_CONTAINER (win), frame);
  345.   gtk_signal_connect (GTK_OBJECT (win), "delete_event",
  346.               GTK_SIGNAL_FUNC (sub_dialog_destroy),
  347.               NULL);
  348.  
  349.   return win;
  350. }
  351.  
  352. GtkWidget *
  353. fp_create_msnls (void)
  354. {
  355.   GtkWidget *frame, *table, *lessFrame, *middleFrame, *moreFrame;
  356.   GtkWidget *lessVbox, *middleVbox, *moreVbox;
  357.   GtkWidget *win;
  358.  
  359.   Create_A_Preview (&minusSatPreview, &lessFrame,
  360.             reduced->width, reduced->height);
  361.   Create_A_Preview (&SatPreview, &middleFrame,
  362.             reduced->width, reduced->height);
  363.   Create_A_Preview (&plusSatPreview, &moreFrame,
  364.             reduced->width, reduced->height);
  365.  
  366.   Create_A_Table_Entry (&moreVbox, moreFrame, sat_more);
  367.   Create_A_Table_Entry (&middleVbox, middleFrame, current_val);
  368.   Create_A_Table_Entry (&lessVbox, lessFrame, sat_less);
  369.  
  370.   frame = gtk_frame_new (NULL);
  371.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
  372.   gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
  373.   gtk_widget_show (frame);
  374.  
  375.   table = gtk_table_new (1, 11, FALSE);
  376.   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
  377.   gtk_widget_show (table);
  378.  
  379.   gtk_table_attach (GTK_TABLE (table), moreVbox, 0, 3, 0, 1,
  380.             GTK_EXPAND, GTK_EXPAND, 0, 0);
  381.   gtk_table_attach (GTK_TABLE (table), middleVbox, 4, 7, 0, 1,
  382.             GTK_EXPAND, GTK_EXPAND, 0, 0);
  383.   gtk_table_attach (GTK_TABLE (table), lessVbox, 8, 11, 0, 1,
  384.             GTK_EXPAND, GTK_EXPAND, 0, 0);
  385.   gtk_container_add (GTK_CONTAINER (frame), table);
  386.  
  387.   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  388.  
  389.   gimp_help_connect_help_accel (win, gimp_standard_help_func, "filters/fp.html");
  390.  
  391.   gtk_window_set_title (GTK_WINDOW (win), _("Saturation Variations"));
  392.   gtk_container_add (GTK_CONTAINER (win), frame);
  393.   gtk_signal_connect (GTK_OBJECT (win), "delete_event",
  394.               GTK_SIGNAL_FUNC (sub_dialog_destroy),
  395.               NULL);
  396.  
  397.   return win;
  398. }
  399.  
  400. GtkWidget *
  401. fp_create_pixels_select_by (void)
  402. {
  403.   GtkWidget *frame, *vbox;
  404.   GSList *group=NULL;
  405.  
  406.   frame = gtk_frame_new (_("Select Pixels by"));
  407.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
  408.   gtk_widget_show (frame);
  409.  
  410.   vbox = gtk_vbox_new (FALSE, 2);
  411.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  412.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);  
  413.   gtk_widget_show (vbox);
  414.  
  415.   group = Button_In_A_Box (vbox, group, _("Hue"), 
  416.                GTK_SIGNAL_FUNC (fp_change_current_pixels_by),
  417.                HueSatVal + 0,
  418.                Current.ValueBy == BY_HUE);
  419.   group = Button_In_A_Box (vbox,group, _("Saturation"), 
  420.                GTK_SIGNAL_FUNC (fp_change_current_pixels_by),
  421.                HueSatVal + 1,
  422.                Current.ValueBy == BY_SAT);
  423.   group = Button_In_A_Box (vbox,group, _("Value"), 
  424.                GTK_SIGNAL_FUNC (fp_change_current_pixels_by),
  425.                HueSatVal + 2,
  426.                Current.ValueBy == BY_VAL);
  427.   return frame;
  428. }
  429.  
  430. GtkWidget *
  431. fp_create_show (void)
  432. {
  433.   GtkWidget *frame, *vbox;
  434.   GSList *group = NULL;
  435.  
  436.   frame = gtk_frame_new(_("Show"));
  437.   gtk_widget_show (frame);
  438.  
  439.   vbox = gtk_vbox_new (FALSE, 2);
  440.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  441.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);  
  442.   gtk_widget_show (vbox);
  443.  
  444.   group = Button_In_A_Box (vbox, group, _("Entire Image"),
  445.                GTK_SIGNAL_FUNC (fp_entire_image),
  446.                &Current.SlctnOnly,
  447.                FALSE);
  448.  
  449.   group = Button_In_A_Box (vbox, group, _("Selection Only"),
  450.                GTK_SIGNAL_FUNC (fp_selection_only),
  451.                &Current.SlctnOnly,
  452.                TRUE);
  453.  
  454.   group = Button_In_A_Box (vbox, group, _("Selection In Context"), 
  455.                GTK_SIGNAL_FUNC (fp_selection_in_context),
  456.                &Current.SlctnOnly,
  457.                FALSE);
  458.  
  459.   return frame;
  460. }
  461.  
  462. #ifdef __FP_UNUSED_STUFF__
  463. GtkWidget *
  464. fp_create_frame_select (void)
  465. {
  466.   GtkWidget *frame, *box;
  467.  
  468.   frame = gtk_frame_new (_("Display"));
  469.   gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
  470.   gtk_widget_show (frame);
  471.  
  472.   box = gtk_hbox_new (FALSE, 8);
  473.   gtk_container_add (GTK_CONTAINER (frame), box);
  474.   gtk_container_set_border_width (GTK_CONTAINER (box),4);  
  475.   gtk_widget_show (box);
  476.  
  477.   Check_Button_In_A_Box (box, _("CirclePalette"),
  478.              GTK_SIGNAL_FUNC (fp_show_hide_frame),
  479.              fpFrames.palette,TRUE);
  480.   Check_Button_In_A_Box (box, _("Lighter And Darker"),
  481.              GTK_SIGNAL_FUNC (fp_show_hide_frame),
  482.              fpFrames.lnd,TRUE);
  483.   Check_Button_In_A_Box (box, _("Saturation"),
  484.              GTK_SIGNAL_FUNC (fp_show_hide_frame),
  485.              fpFrames.satur,FALSE);
  486.  
  487.   return frame;
  488. }
  489. #endif
  490.  
  491. void Create_A_Preview (GtkWidget **preview,
  492.                GtkWidget **frame,
  493.                int         previewWidth,
  494.                int         previewHeight)
  495. {
  496.   *frame = gtk_frame_new (NULL);
  497.   gtk_frame_set_shadow_type (GTK_FRAME (*frame), GTK_SHADOW_IN);
  498.   gtk_widget_show (*frame);
  499.  
  500.   *preview = gtk_preview_new (Current.Color ?
  501.                   GTK_PREVIEW_COLOR : GTK_PREVIEW_GRAYSCALE);
  502.   gtk_preview_size (GTK_PREVIEW (*preview), previewWidth, previewHeight);
  503.   gtk_widget_show (*preview);
  504.   gtk_container_add (GTK_CONTAINER (*frame), *preview);
  505. }
  506.  
  507. GSList *
  508. Button_In_A_Box (GtkWidget     *vbox,
  509.          GSList        *group,
  510.          guchar        *label,
  511.          GtkSignalFunc  function,
  512.          gpointer       data,
  513.          gboolean       clicked)
  514. {
  515.   GtkWidget *button;
  516.  
  517.   button = gtk_radio_button_new_with_label (group, label);
  518.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  519.               GTK_SIGNAL_FUNC (function),
  520.               data);
  521.   gtk_widget_show (button);
  522.   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  523.   if (clicked)
  524.     gtk_button_clicked (GTK_BUTTON (button));
  525.  
  526.   return gtk_radio_button_group (GTK_RADIO_BUTTON (button));
  527. }
  528.  
  529. void
  530. Check_Button_In_A_Box (GtkWidget     *vbox,
  531.                guchar        *label,
  532.                GtkSignalFunc  function,
  533.                gpointer       data,
  534.                gboolean       clicked)
  535. {
  536.   GtkWidget *button;
  537.  
  538.   button = gtk_check_button_new_with_label (label);
  539.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  540.               GTK_SIGNAL_FUNC (function),
  541.               data);
  542.   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  543.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), clicked);
  544.  
  545.   gtk_widget_show (button);
  546. }
  547.  
  548. void
  549. Frames_Check_Button_In_A_Box (GtkWidget     *vbox,
  550.                   guchar        *label,
  551.                   GtkSignalFunc  function,
  552.                   GtkWidget     *frame,
  553.                   gboolean       clicked)
  554. {
  555.   GtkWidget *button;
  556.  
  557.   button = gtk_check_button_new_with_label (label);
  558.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  559.               GTK_SIGNAL_FUNC (function),
  560.               frame);
  561.   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  562.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), clicked);
  563.   gtk_object_set_data (GTK_OBJECT (frame), "ctrlButton", (gpointer) button);
  564.  
  565.   gtk_widget_show (button);
  566. }
  567.  
  568. void
  569. Create_A_Table_Entry (GtkWidget   **box,
  570.               GtkWidget    *SmallerFrame,
  571.               const gchar  *description)
  572. {
  573.   GtkWidget *label, *button, *table;
  574.  
  575.   *box = gtk_vbox_new (FALSE, 1);
  576.   gtk_container_set_border_width (GTK_CONTAINER (*box), PR_BX_BRDR);
  577.   gtk_widget_show (*box);
  578.  
  579.   /* Delayed translation applied here */
  580.   label = gtk_label_new (gettext (description));
  581.  
  582.   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  583.   gtk_widget_show (label);
  584.  
  585.   table = gtk_table_new (2, 1, FALSE);
  586.   gtk_widget_show (table);
  587.  
  588.   gtk_box_pack_start (GTK_BOX (*box), table, TRUE, TRUE, 0);
  589.  
  590.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
  591.             0, 0, 0, 0);
  592.  
  593.   if (description != current_val)
  594.     {
  595.       button = gtk_button_new ();
  596.       gtk_signal_connect (GTK_OBJECT (button), "clicked",
  597.               GTK_SIGNAL_FUNC (selectionMade),
  598.               (gchar *) description);
  599.  
  600.       gtk_container_add (GTK_CONTAINER (button), SmallerFrame);
  601.       gtk_widget_show (button);
  602.       gtk_table_attach (GTK_TABLE (table), button, 0, 1, 1, 2,
  603.             0, 0, 0, 4);
  604.     }
  605.   else
  606.     {
  607.       gtk_table_attach (GTK_TABLE (table), SmallerFrame, 0, 1, 1, 2,
  608.             0, 0, 0, 4);
  609.     }
  610. }
  611.  
  612. void
  613. fp_redraw_all_windows (void)
  614. {
  615.   reduced = Reduce_The_Image (drawable,mask,
  616.                   Current.PreviewSize,
  617.                   Current.SlctnOnly);
  618.   Adjust_Preview_Sizes (reduced->width, reduced->height);
  619.  
  620.   /*gtk_container_check_resize(GTK_CONTAINER(fpFrames.palette), NULL);*/
  621.   gtk_widget_draw (fpFrames.palette, NULL);
  622.  
  623.   /*gtk_container_check_resize(GTK_CONTAINER(fpFrames.satur), NULL);*/
  624.   gtk_widget_draw (fpFrames.satur, NULL);
  625.  
  626.   /*gtk_container_check_resize(GTK_CONTAINER(fpFrames.lnd), NULL);*/
  627.   gtk_widget_draw (fpFrames.lnd, NULL);
  628.  
  629.   /*gtk_container_check_resize(GTK_CONTAINER(dlg), NULL);*/
  630.   gtk_widget_draw (dlg, NULL);
  631.  
  632.   refreshPreviews (Current.VisibleFrames);
  633. }
  634.  
  635. void
  636. fp_entire_image (GtkWidget *button,
  637.          gpointer   data)
  638. {
  639.   if (!GTK_TOGGLE_BUTTON (button)->active)
  640.     return;
  641.   Current.SlctnOnly = 0;
  642.   fp_redraw_all_windows ();
  643. } 
  644.  
  645. void
  646. fp_selection_only (GtkWidget *button,
  647.            gpointer   data)
  648. {
  649.   static gint notFirstTime = 0;
  650.  
  651.   if (!(notFirstTime++))
  652.     return;
  653.  
  654.   if (!GTK_TOGGLE_BUTTON (button)->active)
  655.     return;
  656.   Current.SlctnOnly = 1;
  657.   fp_redraw_all_windows ();
  658. }
  659.  
  660. void
  661. fp_selection_in_context (GtkWidget *button,
  662.              gpointer   data)
  663. {
  664.   if (!GTK_TOGGLE_BUTTON (button)->active)
  665.     return;
  666.  
  667.   Current.SlctnOnly = 2;
  668.   fp_redraw_all_windows ();
  669. }
  670.  
  671. void
  672. fp_show_hide_frame (GtkWidget *button, 
  673.             GtkWidget *frame)
  674. {
  675.   gint prev = Current.VisibleFrames;
  676.  
  677.   if (frame == NULL)
  678.     return;
  679.  
  680.   if (GTK_TOGGLE_BUTTON (button)->active)
  681.     {
  682.       if (!GTK_WIDGET_VISIBLE (frame))
  683.     {
  684.       gtk_widget_show (frame);
  685.  
  686.       if (frame==fpFrames.palette) 
  687.         Current.VisibleFrames |= HUE;
  688.       else if (frame==fpFrames.satur)
  689.         Current.VisibleFrames |= SATURATION;
  690.       else if (frame==fpFrames.lnd)
  691.         Current.VisibleFrames |= VALUE;
  692.  
  693.       refreshPreviews (Current.VisibleFrames & ~prev);
  694.     }
  695.     }    
  696.   else
  697.     {
  698.       if (GTK_WIDGET_VISIBLE (frame))
  699.     {
  700.       gtk_widget_hide (frame);
  701.  
  702.       if (frame==fpFrames.palette) 
  703.         Current.VisibleFrames &= ~HUE;
  704.       else if (frame==fpFrames.satur)
  705.         Current.VisibleFrames &= ~SATURATION;
  706.       else if (frame==fpFrames.lnd)
  707.         Current.VisibleFrames &= ~VALUE;
  708.     }
  709.     }
  710. }
  711.  
  712. void
  713. Adjust_Preview_Sizes (gint width,
  714.               gint height)
  715. {
  716.   gtk_preview_size (GTK_PREVIEW (origPreview),     width, height);
  717.   gtk_preview_size (GTK_PREVIEW (curPreview),      width, height);
  718.   gtk_preview_size (GTK_PREVIEW (rPreview),        width, height);
  719.   gtk_preview_size (GTK_PREVIEW (gPreview),        width, height);
  720.   gtk_preview_size (GTK_PREVIEW (bPreview),        width, height);
  721.   gtk_preview_size (GTK_PREVIEW (cPreview),        width, height);
  722.   gtk_preview_size (GTK_PREVIEW (yPreview),        width, height);
  723.   gtk_preview_size (GTK_PREVIEW (mPreview),        width, height);
  724.   gtk_preview_size (GTK_PREVIEW (centerPreview),   width, height);
  725.   gtk_preview_size (GTK_PREVIEW (lighterPreview),  width, height);
  726.   gtk_preview_size (GTK_PREVIEW (darkerPreview),   width, height);
  727.   gtk_preview_size (GTK_PREVIEW (middlePreview),   width, height);
  728.   gtk_preview_size (GTK_PREVIEW (minusSatPreview), width, height);
  729.   gtk_preview_size (GTK_PREVIEW (SatPreview),      width, height);
  730.   gtk_preview_size (GTK_PREVIEW (plusSatPreview),  width, height);
  731. }
  732.  
  733. void      
  734. selectionMade (GtkWidget *widget,
  735.            gpointer   data)
  736. {
  737.   Current.Touched[Current.ValueBy] = 1;
  738.   
  739.   if (data == (gpointer) hue_red) {
  740.     Update_Current_FP (HUE, RED);
  741.   } else if (data == (gpointer) hue_green) {
  742.     Update_Current_FP (HUE, GREEN);
  743.   } else if (data == (gpointer) hue_blue) {
  744.     Update_Current_FP (HUE, BLUE);
  745.   } else if (data == (gpointer) hue_cyan) {
  746.     Update_Current_FP (HUE, CYAN);
  747.   } else if (data == (gpointer) hue_yellow) {
  748.     Update_Current_FP (HUE, YELLOW);
  749.   } else if (data == (gpointer) hue_magenta) {
  750.     Update_Current_FP (HUE, MAGENTA);
  751.   } else if (data == (gpointer) val_darker) {
  752.     Update_Current_FP (VALUE, DOWN);
  753.   } else if (data == (gpointer) val_lighter) {
  754.     Update_Current_FP (VALUE, UP);
  755.   } else if (data == (gpointer) sat_more) {
  756.     Update_Current_FP (SATURATION, UP);
  757.   } else if (data == (gpointer) sat_less) {
  758.     Update_Current_FP (SATURATION, DOWN);
  759.   }
  760.  
  761.   refreshPreviews (Current.VisibleFrames);
  762. }
  763.  
  764. void
  765. refreshPreviews (gint which)
  766. {
  767.   fp_Create_Nudge (nudgeArray);
  768.   fp_render_preview     (origPreview,     NONEATALL,  0);
  769.   fp_render_preview     (curPreview,      CURRENT,    0);
  770.   if (which & HUE)
  771.     {
  772.       fp_render_preview (rPreview,        HUE,        RED);
  773.       fp_render_preview (gPreview,        HUE,        GREEN);
  774.       fp_render_preview (bPreview,        HUE,        BLUE);
  775.       fp_render_preview (cPreview,        HUE,        CYAN);
  776.       fp_render_preview (yPreview,        HUE,        YELLOW);
  777.       fp_render_preview (mPreview,        HUE,        MAGENTA);
  778.       fp_render_preview (centerPreview,   CURRENT,    0);
  779.     }
  780.   if (which & VALUE)
  781.     {
  782.       fp_render_preview (lighterPreview,  VALUE,      UP);
  783.       fp_render_preview (middlePreview,   CURRENT,    0);
  784.       fp_render_preview (darkerPreview,   VALUE,      DOWN);
  785.     }
  786.   if (which & SATURATION)
  787.     {
  788.       fp_render_preview (plusSatPreview,  SATURATION, UP);
  789.       fp_render_preview (SatPreview,      CURRENT,    0);
  790.       fp_render_preview (minusSatPreview, SATURATION, DOWN);
  791.     }
  792. }
  793.  
  794. void
  795. fp_ok_callback (GtkWidget *widget,
  796.         gpointer   data)
  797. {
  798.   FPint.run = TRUE;
  799.  
  800.   gtk_widget_destroy (GTK_WIDGET (data));
  801. }
  802.  
  803. void
  804. fp_scale_update (GtkAdjustment *adjustment,
  805.          float         *scale_val)
  806. {
  807.   static gfloat prevValue = 0.25;
  808.  
  809.   *scale_val = adjustment->value;
  810.  
  811.   if (prevValue != adjustment->value)
  812.     {
  813.       fp_Create_Nudge (nudgeArray);
  814.       refreshPreviews (Current.VisibleFrames);
  815.       if (AW.window != NULL && GTK_WIDGET_VISIBLE (AW.window))
  816.     fp_create_smoothness_graph (AW.aliasingPreview);
  817.       prevValue = adjustment->value;
  818.     }
  819. }
  820.  
  821. void
  822. fp_change_current_range (GtkAdjustment *button,
  823.              gint          *Intensity)
  824. {
  825.   static FP_Intensity prevValue=MIDTONES;
  826.   static int notFirstTime=0;
  827.   
  828.   if (!(notFirstTime++))  return;
  829.   if (!GTK_TOGGLE_BUTTON (button)->active)  return;
  830.   if (*Intensity == prevValue) return;
  831.  
  832.   Current.Range = *Intensity;
  833.   refreshPreviews (Current.VisibleFrames);
  834.   if (AW.window != NULL && GTK_WIDGET_VISIBLE (AW.window))
  835.     fp_create_smoothness_graph (AW.aliasingPreview);
  836.   prevValue = *Intensity;
  837. }
  838.  
  839. void
  840. fp_change_current_pixels_by (GtkWidget *button,
  841.                  gint      *valueBy)
  842. {
  843.   gint prevValue = VALUE;
  844.   static gint notFirstTime = 0;
  845.   
  846.   if (!(notFirstTime++))
  847.     return;
  848.  
  849.   if (!GTK_TOGGLE_BUTTON(button)->active)
  850.     return;
  851.  
  852.   if (*valueBy == prevValue)
  853.     return;
  854.  
  855.   Current.ValueBy = *valueBy;
  856.   refreshPreviews (Current.VisibleFrames);
  857.   if (AW.window != NULL &&
  858.       GTK_WIDGET_VISIBLE (AW.window) &&
  859.       AW.rangePreview != NULL)
  860.     fp_range_preview_spill (AW.rangePreview,Current.ValueBy);
  861.  
  862.   prevValue = *valueBy;
  863. }
  864.  
  865. void
  866. fp_advanced_call (void)
  867. { 
  868.   if (AW.window!=NULL) 
  869.     if (GTK_WIDGET_VISIBLE (AW.window))
  870.       gtk_widget_hide (AW.window);
  871.     else 
  872.       gtk_widget_show (AW.window);
  873.   else 
  874.     fp_advanced_dialog ();
  875. }
  876.  
  877. gint
  878. fp_dialog (void)
  879. {
  880.   GtkWidget *bna;
  881.   GtkWidget *palette;
  882.   GtkWidget *lnd;
  883.   GtkWidget *show;
  884.   GtkWidget *rough;
  885.   GtkWidget *range;
  886.   GtkWidget *pixelsBy;
  887.   GtkWidget *satur;
  888.   GtkWidget *control;
  889.   GtkWidget *table;
  890.  
  891.   reduced = Reduce_The_Image (drawable,mask,
  892.                   Current.PreviewSize,
  893.                   Current.SlctnOnly);
  894.  
  895.   gimp_ui_init ("fp", TRUE);
  896.  
  897.   /********************************************************************/
  898.   /************************* All the Standard Stuff *******************/
  899.   dlg = gimp_dialog_new (_("Filter Pack Simulation"), "fp",
  900.              gimp_standard_help_func, "filters/fp.html",
  901.              GTK_WIN_POS_MOUSE,
  902.              FALSE, TRUE, FALSE,
  903.  
  904.              _("OK"), fp_ok_callback,
  905.              NULL, NULL, NULL, TRUE, FALSE,
  906.              _("Reset"), resetFilterPacks,
  907.              NULL, NULL, NULL, FALSE, FALSE,
  908.              _("Cancel"), gtk_widget_destroy,
  909.              NULL, 1, NULL, FALSE, TRUE,
  910.  
  911.              NULL);
  912.  
  913.   gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
  914.               GTK_SIGNAL_FUNC (gtk_main_quit),
  915.               NULL);
  916.  
  917.   /********************************************************************/
  918.   
  919.   fp_advanced_dialog ();
  920.  
  921.   fpFrames.bna          = bna          = fp_create_bna();
  922.   fpFrames.rough        = rough        = fp_create_rough();
  923.   fpFrames.range        = range        = fp_create_range();
  924.   fpFrames.palette      = palette      = fp_create_circle_palette();
  925.   fpFrames.lnd          = lnd          = fp_create_lnd();
  926.   fpFrames.show         = show         = fp_create_show();
  927.   fpFrames.satur        = satur        = fp_create_msnls();
  928.   fpFrames.pixelsBy     = pixelsBy     = fp_create_pixels_select_by();
  929.                           control      = fp_create_control();
  930.   /********************************************************************/
  931.   /********************   PUT EVRYTHING TOGETHER     ******************/
  932.   
  933.   table = gtk_table_new (4, 2, FALSE);
  934.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  935.   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  936.   gtk_container_set_border_width (GTK_CONTAINER (table), 6);
  937.  
  938.   gtk_table_attach (GTK_TABLE (table), bna, 0, 2, 0, 1,
  939.             GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  940.  
  941.   gtk_table_attach (GTK_TABLE (table), control, 1, 2, 1, 3,
  942.             GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  943.  
  944.   gtk_table_attach (GTK_TABLE (table), rough, 1, 2, 3, 4,
  945.             GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  946.  
  947.   gtk_table_attach (GTK_TABLE (table), show, 0, 1, 1, 2,
  948.             GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  949.  
  950.   gtk_table_attach (GTK_TABLE (table), range, 0, 1, 2, 3,
  951.             GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  952.  
  953.   gtk_table_attach (GTK_TABLE (table), pixelsBy, 0, 1, 3, 4,
  954.             GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  955.           
  956.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), table, TRUE, TRUE, 0);
  957.   gtk_widget_show (table);
  958.   gtk_widget_show (dlg);
  959.  
  960.   refreshPreviews (Current.VisibleFrames);
  961.  
  962.   gtk_main ();
  963.   gdk_flush ();
  964.   
  965.   return FPint.run;
  966. }
  967.  
  968. /***********************************************************/
  969. /************   Advanced Options Window   ******************/
  970. /***********************************************************/
  971.  
  972. void
  973. fp_advanced_ok (void)
  974. {
  975.   gtk_widget_hide (AW.window);
  976. }
  977.  
  978. void     
  979. As_You_Drag (GtkWidget *button)
  980. {
  981.   static gboolean notFirstTime = FALSE;
  982.  
  983.   if (! notFirstTime)
  984.     return;
  985.  
  986.   notFirstTime = TRUE;
  987.  
  988.   if (GTK_TOGGLE_BUTTON (button)->active)
  989.     {
  990.       Current.RealTime=TRUE;
  991.       gtk_range_set_update_policy (GTK_RANGE (Current.roughnessScale),0);
  992.       gtk_range_set_update_policy (GTK_RANGE (Current.aliasingScale),0);
  993.       gtk_range_set_update_policy (GTK_RANGE (Current.previewSizeScale),0);
  994.     }
  995.   else
  996.     {
  997.       Current.RealTime=FALSE;
  998.       gtk_range_set_update_policy (GTK_RANGE (Current.roughnessScale),
  999.                    GTK_UPDATE_DELAYED);
  1000.       gtk_range_set_update_policy (GTK_RANGE (Current.aliasingScale),
  1001.                    GTK_UPDATE_DELAYED);
  1002.       gtk_range_set_update_policy (GTK_RANGE (Current.previewSizeScale),
  1003.                    GTK_UPDATE_DELAYED);
  1004.     }
  1005.  
  1006.   return;
  1007. }
  1008.  
  1009. void
  1010. preview_size_scale_update (GtkAdjustment *adjustment,
  1011.                float         *scale_val)
  1012. {
  1013.   Current.PreviewSize = adjustment->value;
  1014.   fp_redraw_all_windows();
  1015. }
  1016.  
  1017. gint
  1018. fp_advanced_dialog (void)
  1019. {
  1020.   guchar *rangeNames[] = { N_("Shadows:"), N_("Midtones:"), N_("Highlights:")};
  1021.   GtkWidget *frame, *mainvbox;
  1022.   GtkObject *smoothnessData;
  1023.   GtkWidget *graphFrame, *table, *scale;
  1024.   GtkWidget *vbox, *label, *labelTable;
  1025.   GtkWidget *optionsFrame;
  1026.   gint i;
  1027.  
  1028.   AW.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  1029.  
  1030.   gimp_help_connect_help_accel (AW.window, gimp_standard_help_func,
  1031.                 "filters/fp.html");
  1032.  
  1033.   gtk_window_set_title (GTK_WINDOW (AW.window),
  1034.             _("Advanced Filter Pack Options"));
  1035.   gtk_signal_connect (GTK_OBJECT (AW.window), "delete_event",
  1036.               GTK_SIGNAL_FUNC (sub_dialog_destroy),
  1037.               NULL);
  1038.  
  1039.   mainvbox = gtk_hbox_new (FALSE, 4);
  1040.   gtk_container_set_border_width (GTK_CONTAINER (mainvbox), 6);
  1041.   gtk_container_add (GTK_CONTAINER (AW.window), mainvbox);
  1042.   gtk_widget_show (mainvbox);
  1043.  
  1044.   frame = gtk_frame_new (_("Smoothness of Aliasing"));
  1045.   gtk_box_pack_start (GTK_BOX (mainvbox), frame, TRUE, TRUE, 0);
  1046.   gtk_widget_show (frame);
  1047.  
  1048.   table = gtk_table_new (3, 1, FALSE);
  1049.   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  1050.   gtk_container_set_border_width (GTK_CONTAINER (table), 4);
  1051.   gtk_container_add (GTK_CONTAINER (frame), table);
  1052.   gtk_widget_show (table);
  1053.  
  1054.   graphFrame = gtk_frame_new (NULL);
  1055.   gtk_frame_set_shadow_type (GTK_FRAME (graphFrame), GTK_SHADOW_IN);
  1056.   gtk_container_set_border_width (GTK_CONTAINER (graphFrame),0);
  1057.   gtk_widget_show (graphFrame);
  1058.   gtk_table_attach (GTK_TABLE (table), graphFrame, 0, 1, 0, 1,
  1059.             GTK_EXPAND, 0, 0, 0);
  1060.  
  1061.   vbox = gtk_vbox_new (FALSE, 0);
  1062.   gtk_container_add (GTK_CONTAINER (graphFrame), vbox);
  1063.   gtk_widget_show (vbox);
  1064.  
  1065.   AW.aliasingPreview = gtk_preview_new (GTK_PREVIEW_COLOR);
  1066.   gtk_preview_size (GTK_PREVIEW (AW.aliasingPreview), 256, MAX_ROUGHNESS);
  1067.   gtk_box_pack_start (GTK_BOX (vbox),AW.aliasingPreview, TRUE, TRUE, 0);
  1068.   gtk_widget_show (AW.aliasingPreview);
  1069.  
  1070.   fp_create_smoothness_graph (AW.aliasingPreview);
  1071.  
  1072.   AW.rangePreview = gtk_preview_new (GTK_PREVIEW_COLOR);
  1073.   gtk_preview_size (GTK_PREVIEW (AW.rangePreview), 256, RANGE_HEIGHT);
  1074.   gtk_box_pack_start(GTK_BOX(vbox),AW.rangePreview, TRUE, TRUE, 0);
  1075.   gtk_widget_show (AW.rangePreview);
  1076.  
  1077.   fp_range_preview_spill (AW.rangePreview, Current.ValueBy);
  1078.  
  1079.   labelTable = gtk_table_new (3, 4, FALSE);
  1080.   gtk_table_set_col_spacings (GTK_TABLE (labelTable), 4);
  1081.   gtk_table_set_row_spacings (GTK_TABLE (labelTable), 2);
  1082.   gtk_widget_show (labelTable);
  1083.   gtk_table_attach (GTK_TABLE (table), labelTable, 0, 1, 1, 2,
  1084.             GTK_EXPAND, 0, 0, 0);
  1085.  
  1086.   for (i = 0; i < 12; i++)
  1087.     {
  1088.       label = Current.rangeLabels[i] = gtk_label_new ("-");
  1089.       if (!(i % 4))
  1090.     {
  1091.       gtk_label_set_text (GTK_LABEL(label), gettext (rangeNames[i/4]));
  1092.       gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  1093.     }
  1094.       gtk_widget_show (label);
  1095.       gtk_table_attach (GTK_TABLE (labelTable), label, i%4, i%4+1, i/4, i/4+1,
  1096.             GTK_EXPAND | GTK_FILL, 0, 0, 0);
  1097.     }
  1098.  
  1099.   /************************************************************/
  1100.   
  1101.   AW.aliasingGraph = gtk_drawing_area_new ();
  1102.   gtk_drawing_area_size (GTK_DRAWING_AREA (AW.aliasingGraph),
  1103.                2 * MARGIN + 256,
  1104.               RANGE_HEIGHT);
  1105.   gtk_box_pack_start (GTK_BOX (vbox), AW.aliasingGraph, TRUE, TRUE, 0);
  1106.   gtk_widget_show (AW.aliasingGraph);
  1107.   gtk_widget_set_events (AW.aliasingGraph, RANGE_ADJUST_MASK);
  1108.   gtk_signal_connect (GTK_OBJECT (AW.aliasingGraph),"event",
  1109.               GTK_SIGNAL_FUNC (FP_Range_Change_Events),
  1110.              &Current);
  1111.  
  1112.   /************************************************************/
  1113.  
  1114.   smoothnessData = gtk_adjustment_new (Current.Alias, 0, 1.0, 0.05, 0.01, 0.0);
  1115.  
  1116.   Current.aliasingScale = scale =
  1117.     gtk_hscale_new (GTK_ADJUSTMENT (smoothnessData));
  1118.   gtk_widget_set_usize (scale, 200, 0);
  1119.   gtk_scale_set_digits (GTK_SCALE (scale), 2);
  1120.   gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  1121.   gtk_range_set_update_policy (GTK_RANGE (scale), 0);
  1122.   gtk_signal_connect (GTK_OBJECT (smoothnessData), "value_changed",
  1123.               GTK_SIGNAL_FUNC (fp_scale_update),
  1124.               &Current.Alias);
  1125.   gtk_widget_show (scale);
  1126.   gtk_table_attach (GTK_TABLE (table), scale, 0, 1, 2, 3,
  1127.             0, 0, 0, 0);
  1128.  
  1129.   /******************* MISC OPTIONS ***************************/
  1130.  
  1131.   optionsFrame = gtk_frame_new (_("Miscellaneous Options"));
  1132.   gtk_widget_show (optionsFrame);
  1133.  
  1134.   gtk_box_pack_start (GTK_BOX (mainvbox), optionsFrame, TRUE, TRUE, 0);
  1135.  
  1136.  
  1137.   vbox = gtk_vbox_new (FALSE, 4);
  1138.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  1139.   gtk_container_add (GTK_CONTAINER (optionsFrame), vbox);
  1140.   gtk_widget_show (vbox);
  1141.  
  1142.   Check_Button_In_A_Box (vbox, _("Preview as You Drag"),
  1143.              GTK_SIGNAL_FUNC (As_You_Drag),
  1144.              NULL, TRUE);
  1145.  
  1146.   frame = gtk_frame_new (_("Preview Size"));
  1147.   gtk_widget_show (frame);
  1148.  
  1149.   smoothnessData = gtk_adjustment_new (Current.PreviewSize, 
  1150.                        50, MAX_PREVIEW_SIZE, 
  1151.                        5, 5, 0.0);
  1152.       
  1153.   Current.previewSizeScale = scale =
  1154.     gtk_hscale_new (GTK_ADJUSTMENT (smoothnessData));
  1155.   gtk_container_add (GTK_CONTAINER (frame),scale);
  1156.   gtk_widget_set_usize (scale, 100, 0);
  1157.   gtk_scale_set_digits (GTK_SCALE (scale), 0);
  1158.   gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  1159.   gtk_range_set_update_policy (GTK_RANGE (scale), 0);
  1160.   gtk_signal_connect (GTK_OBJECT (smoothnessData), "value_changed",
  1161.               GTK_SIGNAL_FUNC (preview_size_scale_update),
  1162.               &Current.PreviewSize);        
  1163.   gtk_widget_show (scale);
  1164.  
  1165.   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
  1166.  
  1167.   return 1;
  1168. }
  1169.