#include "config.h"

#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include <libgimpwidgets/gimpwidgets.h>

#include "main.h"
#include "interface.h"
#include "texturize.h"

#include "plugin-intl.h"


/*  Constants  */

#define SCALE_WIDTH        180
#define SPIN_BUTTON_WIDTH   75
#define RANDOM_SEED_WIDTH  100


/*  Local function prototypes  */

/*  Local variables  */

static PlugInUIVals *ui_state = NULL;


/*  Public functions  */

gboolean dialog (gint32              image_ID,
                 GimpDrawable       *drawable,
                 PlugInVals         *vals,
                 PlugInImageVals    *image_vals,
                 PlugInDrawableVals *drawable_vals,
                 PlugInUIVals       *ui_vals) {
  GtkWidget *dlg;
  GtkWidget *main_vbox;
  GtkWidget *frame;
  GtkWidget *table;
  GtkWidget *tileable_checkbox;
  GtkObject *adj;
  gint row;
  gboolean   run = FALSE;

  image_vals->width_p  = gimp_image_width(image_ID);
  image_vals->height_p = gimp_image_height(image_ID);
  // Here are the default values of the dialog box
  if (vals->width_i < image_vals->width_p
      || vals->height_i < image_vals->height_p) {
    vals->width_i  = 2 * image_vals->width_p;
    vals->height_i = 2 * image_vals->height_p;
  }

  vals->overlap = 100;
  vals->make_tileable = FALSE;

  ui_state = ui_vals;

  gimp_ui_init (PLUGIN_NAME, TRUE);

  dlg = gimp_dialog_new(
    _("Texturize Plug-in for GIMP"),
    PLUGIN_NAME,
    NULL, GTK_DIALOG_MODAL,
    gimp_standard_help_func, "plug-in-template",
    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
    GTK_STOCK_OK,     GTK_RESPONSE_OK,
    NULL);

  main_vbox = gtk_vbox_new (FALSE, 12);
  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dlg)->vbox), main_vbox);

  // Size of the new image ?
  frame = gimp_frame_new (_("Please set the size of the new image\nand the maximum overlap between patches."));
  gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
  gtk_widget_show (frame);

  table = gtk_table_new (3, 3, FALSE);
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
  gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  gtk_container_add (GTK_CONTAINER (frame), table);
  gtk_widget_show (table);

  row = 0;

  // Width of the new image?
  adj = gimp_scale_entry_new(GTK_TABLE (table), 0, row++,_("Width :"),
                             SCALE_WIDTH, SPIN_BUTTON_WIDTH,
                             vals->width_i,
                             image_vals->width_p,
                             20 * image_vals->width_p,
                             1, 10, 0, TRUE, 0, 0,
                             _("Set the new image's width"), NULL);

  g_signal_connect(adj, "value_changed",
                   G_CALLBACK (gimp_int_adjustment_update),
                   &vals->width_i);

  // Height of the new image?
  adj = gimp_scale_entry_new(GTK_TABLE (table), 0, row++,_("Height :"),
                             SCALE_WIDTH, SPIN_BUTTON_WIDTH,
                             vals->height_i,
                             image_vals->height_p,
                             20*image_vals->height_p,
                             1, 10, 0, TRUE, 0, 0,
                             _("Set the new image's height"), NULL);

  g_signal_connect(adj, "value_changed",
                   G_CALLBACK (gimp_int_adjustment_update),
                   &vals->height_i);

  // Patch overlap?
  adj = gimp_scale_entry_new(GTK_TABLE (table), 0, row++,
                             _("Overlap (pixels) :"),
                             SCALE_WIDTH, SPIN_BUTTON_WIDTH,
                             vals->overlap,
                             MIN(25, MIN(image_vals->width_p - 1 ,image_vals->height_p - 1)),
                             MIN(image_vals->width_p, image_vals->height_p),
                             5, 10, 0, TRUE, 0, 0,
                             _("Set the overlap between patches (larger values make better "
                               "but longer texturizing "
                               "and tend to make periodic results)"),
                             NULL);

  g_signal_connect(adj, "value_changed",
                   G_CALLBACK (gimp_int_adjustment_update),
                   &vals->overlap);


  // Tileable texture?
  tileable_checkbox = gtk_check_button_new_with_mnemonic(_("_Tileable"));
  gtk_box_pack_start(GTK_BOX (main_vbox), tileable_checkbox, FALSE, FALSE, 0);
  gtk_widget_show(tileable_checkbox);
  gimp_help_set_help_data(tileable_checkbox,
                          _("Selects if to create a tileable texture"),
                          NULL);

  g_signal_connect(GTK_WIDGET (tileable_checkbox), "toggled",
                   G_CALLBACK (gimp_toggle_button_update),
                   &vals->make_tileable);

  // Show the main containers.
  gtk_widget_show(main_vbox);
  gtk_widget_show(dlg);

  run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK);

  gtk_widget_destroy (dlg);

  return run;
}
