root / trunk / linux / dialogs.cpp

// Linux Dialogs
//

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/stat.h>
#include <string.h>
#include <unistd.h>
#include <pwd.h>
#include "opengl.h"
#include "gtkmisc.h"
#include "gtktools.h"
#include "system.h"
#include "dialogs.h"
#include "typedefs.h"
#include "globals.h"
#include "piece.h"
#include "group.h"
#include "main.h"
#include "config.h"
//#include "message.h"
#include "project.h"
#include "lc_colors.h"

// =============================================================================
// Modal dialog helper functions

void dialog_button_callback (GtkWidget *widget, gpointer data)
{
  GtkWidget *parent;
  int *loop, *ret;

  parent = gtk_widget_get_toplevel (widget);
  loop = (int*)gtk_object_get_data (GTK_OBJECT (parent), "loop");
  ret = (int*)gtk_object_get_data (GTK_OBJECT (parent), "ret");

  *loop = 0;
  *ret = GPOINTER_TO_INT (data);
}

gint dialog_delete_callback (GtkWidget *widget, GdkEvent* event, gpointer data)
{
  int *loop;

  gtk_widget_hide (widget);
  loop = (int*)gtk_object_get_data (GTK_OBJECT (widget), "loop");
  *loop = 0;

  return TRUE;
}

// =============================================================================
// MessageBox

int msgbox_execute (const char* text, const char *caption, int flags)
{
  GtkWidget *window, *w, *vbox, *hbox;
  GtkAccelGroup *group;
  int mode = (flags & LC_MB_TYPEMASK), ret, loop = 1;
  guint tmp_key;

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (((GtkWidget*)(*main_window))));
  gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                      GTK_SIGNAL_FUNC (dialog_delete_callback), NULL);
  gtk_signal_connect (GTK_OBJECT (window), "destroy",
                      GTK_SIGNAL_FUNC (gtk_widget_destroy), NULL);
  gtk_window_set_title (GTK_WINDOW (window), caption);
  gtk_container_border_width (GTK_CONTAINER (window), 10);
  gtk_object_set_data (GTK_OBJECT (window), "loop", &loop);
  gtk_object_set_data (GTK_OBJECT (window), "ret", &ret);
  gtk_widget_realize (window);

  group = gtk_accel_group_new ();
  gtk_window_add_accel_group (GTK_WINDOW (window), group);

  vbox = gtk_vbox_new (FALSE, 10);
  gtk_container_add (GTK_CONTAINER (window), vbox);
  gtk_widget_show (vbox);
 
  w = gtk_label_new (text);
  gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 2);
  gtk_label_set_justify (GTK_LABEL (w), GTK_JUSTIFY_LEFT);
  gtk_widget_show (w);
 
  w = gtk_hseparator_new ();
  gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 2);
  gtk_widget_show (w);
 
  hbox = gtk_hbox_new (FALSE, 10);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
  gtk_widget_show (hbox);
 
  if (mode == LC_MB_OK)
  {
    w = gtk_button_new_with_label ("Ok");
    gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
    gtk_signal_connect (GTK_OBJECT (w), "clicked",
                        GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (LC_OK));
    GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
    gtk_widget_grab_default (w);
    gtk_widget_show (w);
    ret = LC_OK;
  }
  else if (mode == LC_MB_OKCANCEL)
  {
    w = gtk_button_new_with_label ("Ok");
    gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
    gtk_signal_connect (GTK_OBJECT (w), "clicked",
                        GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (LC_OK));
    GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
    gtk_widget_grab_default (w);
    gtk_widget_show (w);

    w = gtk_button_new_with_label ("Cancel");
    gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
    gtk_signal_connect (GTK_OBJECT (w), "clicked",
                        GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (LC_CANCEL));
    gtk_widget_show (w);
    ret = LC_CANCEL;
  }
  else if (mode == LC_MB_YESNOCANCEL)
  {
    w = gtk_button_new_with_label ("");
    tmp_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (w)->child), "_Yes");
    gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
    gtk_signal_connect (GTK_OBJECT (w), "clicked",
                        GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (LC_YES));
    gtk_widget_add_accelerator (w, "clicked", group, tmp_key, (GdkModifierType)0, (GtkAccelFlags)0);
    GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
    gtk_widget_grab_default (w);
    gtk_widget_show (w);
    gtk_window_set_focus (GTK_WINDOW (window), w);

    w = gtk_button_new_with_label ("");
    tmp_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (w)->child), "_No");
    gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
    gtk_signal_connect (GTK_OBJECT (w), "clicked",
                        GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (LC_NO));
    gtk_widget_add_accelerator (w, "clicked", group, tmp_key, (GdkModifierType)0, (GtkAccelFlags)0);
    gtk_widget_show (w);

    w = gtk_button_new_with_label ("");
    tmp_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (w)->child), "_Cancel");
    gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
    gtk_signal_connect (GTK_OBJECT (w), "clicked",
                        GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (LC_CANCEL));
    gtk_widget_add_accelerator (w, "clicked", group, tmp_key, (GdkModifierType)0, (GtkAccelFlags)0);
    gtk_widget_add_accelerator (w, "clicked", group, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
    gtk_widget_show (w);
    ret = LC_CANCEL;
  }
  else /* if (mode == LC_MB_YESNO) */
  {
    w = gtk_button_new_with_label ("Yes");
    gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
    gtk_signal_connect (GTK_OBJECT (w), "clicked",
                        GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (LC_YES));
    GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
    gtk_widget_grab_default (w);
    gtk_widget_show (w);
 
    w = gtk_button_new_with_label ("No");
    gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
    gtk_signal_connect (GTK_OBJECT (w), "clicked",
                        GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (LC_NO));
    gtk_widget_show (w);
    ret = LC_NO;
  }

  gtk_widget_show (window);
  gtk_grab_add (window);

  while (loop)
    gtk_main_iteration ();

  gtk_grab_remove (window);
  gtk_widget_destroy (window);

  return ret;
}




// =============================================================================




// TODO: remove old functions and replace with the above ones
static int def_ret = 0;
static int* cur_ret = NULL;

void dlg_end (int ret)
{
  *cur_ret = ret;
}

int dlg_domodal(GtkWidget* dlg, int def)
{
  int ret = -1, old_def = def_ret, *old_ret = cur_ret;
  def_ret = def;
  cur_ret = &ret;

  gtk_widget_show(dlg);
  gtk_grab_add(dlg);
  while (ret == -1)
    gtk_main_iteration ();
  gtk_grab_remove(dlg);
  gtk_widget_destroy(dlg);

  cur_ret = old_ret;
  def_ret = old_def;
  return ret;
}

void dlg_default_callback(GtkWidget *widget, gpointer data)
{
  *cur_ret = GPOINTER_TO_INT(data);
}

gint dlg_delete_callback(GtkWidget *widget, GdkEvent* event, gpointer data)
{
  *cur_ret = def_ret;
  return TRUE;
}

static bool read_float(GtkWidget* widget, float* value, float min_value, float max_value)
{
  char buf[256];

  strcpy (buf, gtk_entry_get_text (GTK_ENTRY (widget)));
  if (sscanf(buf, "%f", value) == 1)
  {
    if (*value >= min_value && *value <= max_value)
      return true;
  }

  sprintf (buf, "Please enter a value between %g and %g", min_value, max_value);
  msgbox_execute (buf, "LeoCAD", LC_MB_OK | LC_MB_ICONERROR);
  gtk_window_set_focus(GTK_WINDOW(gtk_widget_get_toplevel(widget)), widget);

  return false;
}

static void write_float(GtkWidget* widget, float value)
{
  char buf[16];
  sprintf (buf, "%g", value);
  gtk_entry_set_text (GTK_ENTRY (widget), buf);
}

static bool read_int(GtkWidget* widget, int* value, int min_value, int max_value)
{
  char buf[256];

  strcpy (buf, gtk_entry_get_text (GTK_ENTRY (widget)));
  if (sscanf(buf, "%d", value) == 1)
  {
    if (*value >= min_value && *value <= max_value)
      return true;
  }

  sprintf (buf, "Please enter a value between %d and %d", min_value, max_value);
  msgbox_execute (buf, "LeoCAD", LC_MB_OK | LC_MB_ICONERROR);
  gtk_window_set_focus(GTK_WINDOW(gtk_widget_get_toplevel(widget)), widget);

  return false;
}

static void write_int(GtkWidget* widget, int value)
{
  char buf[16];
  sprintf (buf, "%d", value);
  gtk_entry_set_text (GTK_ENTRY (widget), buf);
}

// File Open/Save/Merge dialog

static char* filedlg_str;

static void filedlg_callback(GtkWidget *widget, gpointer data)
{
  if (data != NULL)
  {
    *cur_ret = LC_OK;
    strcpy(filedlg_str, gtk_file_selection_get_filename(GTK_FILE_SELECTION(data)));
  }
  else
    *cur_ret = LC_CANCEL;
}

int filedlg_execute(const char* caption, char* filename)
{
  GtkWidget* dlg;
  dlg = gtk_file_selection_new (caption);
  gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (((GtkWidget*)(*main_window))));
  filedlg_str = filename;

  gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(dlg)->ok_button),
     "clicked", (GtkSignalFunc)filedlg_callback, dlg);
  gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(dlg)->cancel_button),
     "clicked", (GtkSignalFunc)filedlg_callback, NULL);

//    gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew),"penguin.png");

  return dlg_domodal(dlg, LC_CANCEL);
}

// Color Selection Dialog

static void colorseldlg_callback(GtkWidget *widget, gpointer data)
{
  if (data != NULL)
  {
    GtkWidget* dlg = gtk_widget_get_toplevel (widget);
    double dbl[3];
    float* color = (float*)data;

    gtk_color_selection_get_color (GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG (dlg)->colorsel), dbl);
    color[0] = dbl[0];
    color[1] = dbl[1];
    color[2] = dbl[2];
    *cur_ret = LC_OK;
  }
  else
    *cur_ret = LC_CANCEL;
}

int colorseldlg_execute(void* param)
{
  float* color = (float*)param;
  double dbl[3] = { color[0], color[1], color[2] };
  GtkWidget* dlg;

  dlg = gtk_color_selection_dialog_new ("Choose Color");
  gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (((GtkWidget*)(*main_window))));
  gtk_color_selection_set_color (GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG (dlg)->colorsel), dbl);

  gtk_signal_connect (GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (dlg)->ok_button),
     "clicked", (GtkSignalFunc)colorseldlg_callback, param);
  gtk_signal_connect (GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (dlg)->cancel_button),
     "clicked", (GtkSignalFunc)colorseldlg_callback, NULL);

  return dlg_domodal(dlg, LC_CANCEL);
}

// Array Dialog

typedef struct
{
  void* data;
  GtkWidget *move_x, *move_y, *move_z;
  GtkWidget *rotate_x, *rotate_y, *rotate_z;
  GtkWidget *total;
  GtkWidget *radio1, *radio2, *radio3;
  GtkWidget *count1, *count2, *count3;
  GtkWidget *offset_x2, *offset_y2, *offset_z2;
  GtkWidget *offset_x3, *offset_y3, *offset_z3;
} LC_ARRAYDLG_STRUCT;

static void arraydlg_callback(GtkWidget *widget, gpointer data)
{
  LC_ARRAYDLG_STRUCT* s = (LC_ARRAYDLG_STRUCT*)data;
  LC_ARRAYDLG_OPTS* opts = (LC_ARRAYDLG_OPTS*)s->data;

  if (!read_float(s->move_x, &opts->fMove[0], -1000, 1000)) return;
  if (!read_float(s->move_y, &opts->fMove[1], -1000, 1000)) return;
  if (!read_float(s->move_z, &opts->fMove[2], -1000, 1000)) return;
  if (!read_float(s->rotate_x, &opts->fRotate[0], -360, 360)) return;
  if (!read_float(s->rotate_y, &opts->fRotate[1], -360, 360)) return;
  if (!read_float(s->rotate_z, &opts->fRotate[2], -360, 360)) return;
  if (!read_float(s->offset_x2, &opts->f2D[0], -1000, 1000)) return;
  if (!read_float(s->offset_y2, &opts->f2D[1], -1000, 1000)) return;
  if (!read_float(s->offset_z2, &opts->f2D[2], -1000, 1000)) return;
  if (!read_float(s->offset_x3, &opts->f3D[0], -1000, 1000)) return;
  if (!read_float(s->offset_y3, &opts->f3D[1], -1000, 1000)) return;
  if (!read_float(s->offset_z3, &opts->f3D[2], -1000, 1000)) return;

  int i;
  if (!read_int(s->count1, &i, 1, 1000)) return;
  opts->n1DCount = i;
  if (!read_int(s->count2, &i, 1, 1000)) return;
  opts->n2DCount = i;
  if (!read_int(s->count3, &i, 1, 1000)) return;
  opts->n3DCount = i;

  if (GTK_TOGGLE_BUTTON (s->radio1)->active)
    opts->nArrayDimension = 0;
  if (GTK_TOGGLE_BUTTON (s->radio2)->active)
    opts->nArrayDimension = 1;
  if (GTK_TOGGLE_BUTTON (s->radio3)->active)
    opts->nArrayDimension = 2;

  *cur_ret = LC_OK;
}

static void arraydlg_adjtotal (GtkWidget *widget, gpointer data)
{
  LC_ARRAYDLG_STRUCT* s = (LC_ARRAYDLG_STRUCT*)data;
  LC_ARRAYDLG_OPTS* opts = (LC_ARRAYDLG_OPTS*)s->data;
  char ctot[11];

  if (GTK_TOGGLE_BUTTON (s->radio1)->active)
    opts->nArrayDimension = 0;
  if (GTK_TOGGLE_BUTTON (s->radio2)->active)
    opts->nArrayDimension = 1;
  if (GTK_TOGGLE_BUTTON (s->radio3)->active)
    opts->nArrayDimension = 2;

  gint tot = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (s->count1)) *
        ((opts->nArrayDimension > 0) ? gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(s->count2)) : 1) *
        ((opts->nArrayDimension > 1) ? gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(s->count3)) : 1);

  sprintf (ctot, "%i", tot);

  gtk_entry_set_text (GTK_ENTRY (s->total), ctot);
}

static void arraydlg_radiotoggled (GtkWidget *widget, gpointer data)
{
  LC_ARRAYDLG_STRUCT* s = (LC_ARRAYDLG_STRUCT*)data;
  LC_ARRAYDLG_OPTS* opts = (LC_ARRAYDLG_OPTS*)s->data;

  if (GTK_TOGGLE_BUTTON (widget)->active == FALSE)
    return;

  arraydlg_adjtotal (widget, data);

  if (opts->nArrayDimension > 0)
  {
    gtk_widget_set_sensitive (s->count2, TRUE);
    gtk_widget_set_sensitive (s->offset_x2, TRUE);
    gtk_widget_set_sensitive (s->offset_y2, TRUE);
    gtk_widget_set_sensitive (s->offset_z2, TRUE);
  }
  else
  {
    gtk_widget_set_sensitive (s->count2, FALSE);
    gtk_widget_set_sensitive (s->offset_x2, FALSE);
    gtk_widget_set_sensitive (s->offset_y2, FALSE);
    gtk_widget_set_sensitive (s->offset_z2, FALSE);
  }

  if (opts->nArrayDimension > 1)
  {
    gtk_widget_set_sensitive (s->count3, TRUE);
    gtk_widget_set_sensitive (s->offset_x3, TRUE);
    gtk_widget_set_sensitive (s->offset_y3, TRUE);
    gtk_widget_set_sensitive (s->offset_z3, TRUE);
  }
  else
  {
    gtk_widget_set_sensitive (s->count3, FALSE);
    gtk_widget_set_sensitive (s->offset_x3, FALSE);
    gtk_widget_set_sensitive (s->offset_y3, FALSE);
    gtk_widget_set_sensitive (s->offset_z3, FALSE);
  }
}

int arraydlg_execute(void* param)
{
  GtkObject *adj;
  GtkWidget *dlg;
  GtkWidget *vbox1, *vbox2;
  GtkWidget *hbox1, *hbox2;
  GtkWidget *frame, *table, *label, *button;
  GSList *radio_group = (GSList*)NULL;
  LC_ARRAYDLG_STRUCT s;
  s.data = param;

  dlg = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (((GtkWidget*)(*main_window))));
  gtk_signal_connect (GTK_OBJECT (dlg), "delete_event",
              GTK_SIGNAL_FUNC (dlg_delete_callback), NULL);
  gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
              GTK_SIGNAL_FUNC (gtk_widget_destroy), NULL);
  gtk_widget_set_usize (dlg, 450, 320);
  gtk_window_set_title (GTK_WINDOW (dlg), "Array Options");
  gtk_window_set_policy (GTK_WINDOW (dlg), FALSE, FALSE, FALSE);
  gtk_widget_realize (dlg);

  vbox1 = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (vbox1);
  gtk_container_add (GTK_CONTAINER (dlg), vbox1);

  hbox1 = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox1);
  gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);

  frame = gtk_frame_new ("Transformation (Incremental)");
  gtk_widget_show (frame);
  gtk_box_pack_start (GTK_BOX (hbox1), frame, TRUE, TRUE, 0);
  gtk_container_border_width (GTK_CONTAINER (frame), 10);

  table = gtk_table_new (3, 4, FALSE);
  gtk_widget_show (table);
  gtk_container_add (GTK_CONTAINER (frame), table);
  gtk_container_border_width (GTK_CONTAINER (table), 10);
  gtk_table_set_col_spacings (GTK_TABLE (table), 20);

  label = gtk_label_new ("X");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1,
                    (GtkAttachOptions) 0, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

  label = gtk_label_new ("Y");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);

  label = gtk_label_new ("Z");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 3, 4, 0, 1,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);

  label = gtk_label_new ("Move");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);

  adj = gtk_adjustment_new (0, -1000, 1000, 10, 10, 10);
  s.move_x = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.move_x);
  gtk_table_attach (GTK_TABLE (table), s.move_x, 1, 2, 1, 2,
                    (GtkAttachOptions) 0, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
  gtk_widget_set_usize (s.move_x, 60, -2);
 
  adj = gtk_adjustment_new (0, -1000, 1000, 10, 10, 10);
  s.move_y = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.move_y);
  gtk_table_attach (GTK_TABLE (table), s.move_y, 2, 3, 1, 2,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.move_y, 60, -2);

  adj = gtk_adjustment_new (0, -1000, 1000, 4, 12, 12);
  s.move_z = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.move_z);
  gtk_table_attach (GTK_TABLE (table), s.move_z, 3, 4, 1, 2,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.move_z, 60, -2);

  label = gtk_label_new ("Rotate");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);

  adj = gtk_adjustment_new (0, -180, 180, 1, 10, 10);
  s.rotate_x = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (s.rotate_x), TRUE);
  gtk_widget_show (s.rotate_x);
  gtk_table_attach (GTK_TABLE (table), s.rotate_x, 1, 2, 2, 3,
                    (GtkAttachOptions) 0, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
  gtk_widget_set_usize (s.rotate_x, 60, -2);

  adj = gtk_adjustment_new (0, -180, 180, 1, 10, 10);
  s.rotate_y = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (s.rotate_y), TRUE);
  gtk_widget_show (s.rotate_y);
  gtk_table_attach (GTK_TABLE (table), s.rotate_y, 2, 3, 2, 3,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.rotate_y, 60, -2);

  adj = gtk_adjustment_new (0, -180, 180, 1, 10, 10);
  s.rotate_z = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (s.rotate_z), TRUE);
  gtk_widget_show (s.rotate_z);
  gtk_table_attach (GTK_TABLE (table), s.rotate_z, 3, 4, 2, 3,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.rotate_z, 60, -2);

  vbox2 = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (vbox2);
  gtk_box_pack_start (GTK_BOX (hbox1), vbox2, FALSE, FALSE, 0);
  gtk_widget_set_usize (vbox2, 115, 142);

  button = gtk_button_new_with_label ("OK");
  gtk_widget_show (button);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
              GTK_SIGNAL_FUNC (arraydlg_callback), &s);
  gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
  gtk_container_border_width (GTK_CONTAINER (button), 12);
  GtkAccelGroup *accel_group = gtk_accel_group_new ();
  gtk_window_add_accel_group (GTK_WINDOW (dlg), accel_group);
  gtk_widget_add_accelerator (button, "clicked", accel_group,
                              GDK_Return, (GdkModifierType)0, GTK_ACCEL_VISIBLE);

  button = gtk_button_new_with_label ("Cancel");
  gtk_widget_show (button);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
              GTK_SIGNAL_FUNC (dlg_default_callback), GINT_TO_POINTER (LC_CANCEL));
  gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
  gtk_container_border_width (GTK_CONTAINER (button), 12);
  gtk_widget_add_accelerator (button, "clicked", accel_group,
                              GDK_Escape, (GdkModifierType)0, GTK_ACCEL_VISIBLE);

  hbox2 = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox2);
  gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);

  label = gtk_label_new ("Total:");
  gtk_widget_show (label);
  gtk_box_pack_start (GTK_BOX (hbox2), label, TRUE, TRUE, 0);

  s.total = gtk_entry_new ();
  gtk_widget_show (s.total);
  gtk_box_pack_start (GTK_BOX (hbox2), s.total, TRUE, TRUE, 15);
  gtk_widget_set_usize (s.total, 50, -2);
  gtk_entry_set_editable (GTK_ENTRY (s.total), FALSE);

  frame = gtk_frame_new ("Dimensions");
  gtk_widget_show (frame);
  gtk_box_pack_start (GTK_BOX (vbox1), frame, TRUE, TRUE, 5);
  gtk_container_border_width (GTK_CONTAINER (frame), 10);

  table = gtk_table_new (4, 5, FALSE);
  gtk_widget_show (table);
  gtk_container_add (GTK_CONTAINER (frame), table);
  gtk_container_border_width (GTK_CONTAINER (table), 10);
  gtk_table_set_col_spacings (GTK_TABLE (table), 20);

  label = gtk_label_new ("Count");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 
            (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

  label = gtk_label_new ("Offsets");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 3, 4, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
            (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);

  s.radio1 = gtk_radio_button_new_with_label (radio_group, "1D");
  radio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (s.radio1));
  gtk_widget_show (s.radio1);
  gtk_table_attach (GTK_TABLE (table), s.radio1, 0, 1, 1, 2,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_signal_connect (GTK_OBJECT (s.radio1), "toggled",
              GTK_SIGNAL_FUNC (arraydlg_radiotoggled), &s);

  s.radio2 = gtk_radio_button_new_with_label (radio_group, "2D");
  radio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (s.radio2));
  gtk_widget_show (s.radio2);
  gtk_table_attach (GTK_TABLE (table), s.radio2, 0, 1, 2, 3,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_signal_connect (GTK_OBJECT (s.radio2), "toggled",
              GTK_SIGNAL_FUNC (arraydlg_radiotoggled), &s);

  s.radio3 = gtk_radio_button_new_with_label (radio_group, "3D");
  radio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (s.radio3));
  gtk_widget_show (s.radio3);
  gtk_table_attach (GTK_TABLE (table), s.radio3, 0, 1, 3, 4,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_signal_connect (GTK_OBJECT (s.radio3), "toggled",
              GTK_SIGNAL_FUNC (arraydlg_radiotoggled), &s);

  adj = gtk_adjustment_new (10, 1, 1000, 1, 10, 1);
  s.count1 = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.count1);
  gtk_table_attach (GTK_TABLE (table), s.count1, 1, 2, 1, 2,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.count1, 60, -2);
  gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
              GTK_SIGNAL_FUNC (arraydlg_adjtotal), &s);

  adj = gtk_adjustment_new (1, 1, 1000, 1, 10, 1);
  s.count2 = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.count2);
  gtk_table_attach (GTK_TABLE (table), s.count2, 1, 2, 2, 3,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.count2, 60, -2);
  gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
              GTK_SIGNAL_FUNC (arraydlg_adjtotal), &s);

  adj = gtk_adjustment_new (1, 1, 1000, 1, 10, 1);
  s.count3 = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.count3);
  gtk_table_attach (GTK_TABLE (table), s.count3, 1, 2, 3, 4,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.count3, 60, -2);
  gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
              GTK_SIGNAL_FUNC (arraydlg_adjtotal), &s);

  label = gtk_label_new ("X");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 2, 3, 1, 2,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);

  label = gtk_label_new ("Y");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 3, 4, 1, 2,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);

  label = gtk_label_new ("Z");
  gtk_widget_show (label);
  gtk_table_attach (GTK_TABLE (table), label, 4, 5, 1, 2,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);

  adj = gtk_adjustment_new (0, -1000, 1000, 10, 10, 10);
  s.offset_x2 = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.offset_x2);
  gtk_table_attach (GTK_TABLE (table), s.offset_x2, 2, 3, 2, 3,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.offset_x2, 60, -2);

  adj = gtk_adjustment_new (0, -1000, 1000, 10, 10, 10);
  s.offset_y2 = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.offset_y2);
  gtk_table_attach (GTK_TABLE (table), s.offset_y2, 3, 4, 2, 3,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.offset_y2, 60, -2);

  adj = gtk_adjustment_new (0, -1000, 1000, 4, 12, 10);
  s.offset_z2 = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.offset_z2);
  gtk_table_attach (GTK_TABLE (table), s.offset_z2, 4, 5, 2, 3,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.offset_z2, 60, -2);

  adj = gtk_adjustment_new (0, -1000, 1000, 10, 10, 10);
  s.offset_x3 = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.offset_x3);
  gtk_table_attach (GTK_TABLE (table), s.offset_x3, 2, 3, 3, 4,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.offset_x3, 60, -2);

  adj = gtk_adjustment_new (0, -1000, 1000, 10, 10, 10);
  s.offset_y3 = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.offset_y3);
  gtk_table_attach (GTK_TABLE (table), s.offset_y3, 3, 4, 3, 4,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.offset_y3, 60, -2);

  adj = gtk_adjustment_new (0, -1000, 1000, 4, 12, 10);
  s.offset_z3 = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
  gtk_widget_show (s.offset_z3);
  gtk_table_attach (GTK_TABLE (table), s.offset_z3, 4, 5, 3, 4,
                    (GtkAttachOptions) 0, (GtkAttachOptions) 0, 0, 0);
  gtk_widget_set_usize (s.offset_z3, 60, -2);

  // Initialize dialog
  arraydlg_radiotoggled (s.radio1, &s);

  return dlg_domodal(dlg, LC_CANCEL);
}

// =============================================================================
// About Dialog

int aboutdlg_execute (void* param)
{
#include "pixmaps/icon32.xpm"
  GtkWidget *dlg, *vbox1, *vbox2, *hbox, *frame, *scr, *w;
  GtkTextBuffer *buffer;
  char info[512], buf[64];
  GLboolean valueb;
  GLint value;

  dlg = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (((GtkWidget*)(*main_window))));
  gtk_signal_connect (GTK_OBJECT (dlg), "delete_event",
              GTK_SIGNAL_FUNC (dlg_delete_callback), NULL);
  gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
              GTK_SIGNAL_FUNC (gtk_widget_destroy), NULL);
  gtk_window_set_title (GTK_WINDOW (dlg), "About LeoCAD");

  gtk_widget_realize (dlg);

  vbox1 = gtk_vbox_new (FALSE, 10);
  gtk_widget_show (vbox1);
  gtk_container_add (GTK_CONTAINER (dlg), vbox1);
  gtk_container_border_width (GTK_CONTAINER (vbox1), 5);

  hbox = gtk_hbox_new (FALSE, 5);
  gtk_widget_show (hbox);
  gtk_box_pack_start (GTK_BOX (vbox1), hbox, FALSE, TRUE, 0);

  w = new_pixmap (dlg, icon32);
  gtk_widget_show (w);
  gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, TRUE, 0);
  gtk_widget_set_usize (w, 32, 32);

  vbox2 = gtk_vbox_new (TRUE, 0);
  gtk_widget_show (vbox2);
  gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 10);

  w = gtk_label_new ("LeoCAD for "LC_VERSION_OSNAME" Version "LC_VERSION_TEXT);
  gtk_widget_show (w);
  gtk_box_pack_start (GTK_BOX (vbox2), w, FALSE, FALSE, 5);

  w = gtk_label_new ("Copyright (c) 1996-2005, BT Software");
  gtk_widget_show (w);
  gtk_box_pack_start (GTK_BOX (vbox2), w, FALSE, FALSE, 5);

  vbox2 = gtk_vbox_new (TRUE, 0);
  gtk_widget_show (vbox2);
  gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, TRUE, 5);

  w = gtk_button_new_with_label ("OK");
  gtk_widget_show (w);
  gtk_signal_connect (GTK_OBJECT (w), "clicked",
              GTK_SIGNAL_FUNC (dlg_default_callback), GINT_TO_POINTER (LC_OK));
  gtk_box_pack_start (GTK_BOX (vbox2), w, FALSE, FALSE, 5);
  gtk_widget_set_usize (w, 60, -2);

  gtk_widget_grab_focus (w);
  GtkAccelGroup *accel_group = gtk_accel_group_new ();
  gtk_window_add_accel_group (GTK_WINDOW (dlg), accel_group);
  gtk_widget_add_accelerator (w, "clicked", accel_group,
                              GDK_Return, (GdkModifierType)0, GTK_ACCEL_VISIBLE);

  frame = gtk_frame_new ("System Information");
  gtk_widget_show (frame);
  gtk_box_pack_start (GTK_BOX (vbox1), frame, TRUE, TRUE, 0);
  gtk_widget_set_usize (frame, -2, 150);

  vbox2 = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (vbox2);
  gtk_container_add (GTK_CONTAINER (frame), vbox2);
  gtk_container_border_width (GTK_CONTAINER (vbox2), 5);

  strcpy (info, "OpenGL Version ");
  strcat (info, (const char*)glGetString (GL_VERSION));
  strcat (info, "\n");
  strcat (info, (const char*)glGetString (GL_RENDERER));
  strcat (info, " - ");
  strcat (info, (const char*)glGetString (GL_VENDOR));

  strcat (info, "\n\nDisplay info:\n");
  glGetIntegerv (GL_INDEX_BITS, &value);
  sprintf (buf, "Bits per pixel: %i", value);
  strcat (info, buf);
  glGetIntegerv (GL_RED_BITS, &value);
  sprintf (buf, " (%i", value);
  strcat (info, buf);
  glGetIntegerv (GL_GREEN_BITS, &value);
  sprintf (buf, "-%i", value);
  strcat (info, buf);
  glGetIntegerv (GL_BLUE_BITS, &value);
  sprintf (buf, "-%i", value);
  strcat (info, buf);
  glGetIntegerv (GL_ALPHA_BITS, &value);
  sprintf (buf, "-%i)\n", value);
  strcat (info, buf);
  glGetIntegerv (GL_DEPTH_BITS, &value);
  sprintf (buf, "Depth buffer bits: %i\n", value);
  strcat (info, buf);
  glGetIntegerv (GL_STENCIL_BITS, &value);
  sprintf (buf, "Stencil bits: %i\n", value);
  strcat (info, buf);
  glGetIntegerv (GL_AUX_BUFFERS, &value);
  sprintf (buf, "Auxillary buffers: %i\n", value);
  strcat (info, buf);
  glGetBooleanv (GL_STEREO, &valueb);
  strcat (info, "Stereoscopic viewing: ");
  if (valueb == GL_TRUE)
    strcat (info, "Yes.\n");
  else
    strcat (info, "No.\n");

  strcat (info, "Compiled Vertex Arrays: ");
  if (GL_HasCompiledVertexArrays ())
    strcat (info, "Supported.\n");
  else
    strcat (info, "Not supported.\n");

  strcat (info, "Multitexturing: ");
  if (GL_GetMultiTextures () > 1)
  {
    sprintf (buf, "Supported, %i texture units.\n", GL_GetMultiTextures ());
    strcat (info, buf);
  }
  else
    strcat (info, "Not supported.\n");
  glGetIntegerv (GL_MAX_TEXTURE_SIZE, &value);
  sprintf (buf, "Maximum texture size: %ix%i", value, value);
  strcat (info, buf);

  scr = gtk_scrolled_window_new (NULL, NULL);
  gtk_widget_show (scr);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
  gtk_box_pack_start (GTK_BOX (vbox2), scr, TRUE, TRUE, 0);

  w = gtk_text_view_new();
  gtk_widget_show (w);
  gtk_container_add (GTK_CONTAINER (scr), w);

  buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
  gtk_text_buffer_set_text (buffer, info, -1);

  //  if (GTK_TEXT (w)->vadj != NULL)
  //    gtk_adjustment_set_value (GTK_ADJUSTMENT (GTK_TEXT (w)->vadj), 0);

  return dlg_domodal(dlg, LC_OK);
}

// =============================================================================
// HTML Dialog

typedef struct
{
  void* data;
  GtkWidget *single, *multiple, *index;
  GtkWidget *list_end, *list_step, *images;
  GtkWidget *highlight, *htmlext, *directory;
} LC_HTMLDLG_STRUCT;

static void htmldlg_ok(GtkWidget *widget, gpointer data)
{
  LC_HTMLDLG_STRUCT* s = (LC_HTMLDLG_STRUCT*)data;
  LC_HTMLDLG_OPTS* opts = (LC_HTMLDLG_OPTS*)s->data;

  opts->singlepage = (GTK_TOGGLE_BUTTON (s->single)->active) ? true : false;
  opts->index = (GTK_TOGGLE_BUTTON (s->index)->active) ? true : false;
  opts->images = (GTK_TOGGLE_BUTTON (s->images)->active) ? true : false;
  opts->listend = (GTK_TOGGLE_BUTTON (s->list_end)->active) ? true : false;
  opts->liststep = (GTK_TOGGLE_BUTTON (s->list_step)->active) ? true : false;
  opts->highlight = (GTK_TOGGLE_BUTTON (s->highlight)->active) ? true : false;
  opts->htmlext = (GTK_TOGGLE_BUTTON (s->htmlext)->active) ? true : false;
  strcpy(opts->path, gtk_entry_get_text (GTK_ENTRY (s->directory)));

  *cur_ret = LC_OK;
}

static void htmldlg_images (GtkWidget *widget, gpointer data)
{
  LC_HTMLDLG_STRUCT* s = (LC_HTMLDLG_STRUCT*)data;
  LC_HTMLDLG_OPTS* opts = (LC_HTMLDLG_OPTS*)s->data;

  imageoptsdlg_execute(&opts->imdlg ,true);
}

static void htmldlg_layout (GtkWidget *widget, gpointer data)
{
  LC_HTMLDLG_STRUCT* s = (LC_HTMLDLG_STRUCT*)data;

  if (GTK_TOGGLE_BUTTON (s->single)->active)
    gtk_widget_set_sensitive (s->index, FALSE);
  else
    gtk_widget_set_sensitive (s->index, TRUE);
}

static void htmldlg_list (GtkWidget *widget, gpointer data)
{
  LC_HTMLDLG_STRUCT* s = (LC_HTMLDLG_STRUCT*)data;

  if (GTK_TOGGLE_BUTTON (s->list_end)->active ||
      GTK_TOGGLE_BUTTON (s->list_step)->active)
    gtk_widget_set_sensitive (s->images, TRUE);
  else
    gtk_widget_set_sensitive (s->images, FALSE);
}

int htmldlg_execute (void* param)
{
  GtkWidget *dlg;
  GtkWidget *vbox, *vbox1, *vbox2, *hbox;
  GtkWidget *frame, *label, *button;
  GSList *radio_group = (GSList*)NULL;
  LC_HTMLDLG_STRUCT s;
  LC_HTMLDLG_OPTS* opts = (LC_HTMLDLG_OPTS*)param;
  s.data = param;

  dlg = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (((GtkWidget*)(*main_window))));
  gtk_signal_connect (GTK_OBJECT (dlg), "delete_event",
              GTK_SIGNAL_FUNC (dlg_delete_callback), NULL);
  gtk_window_set_title (GTK_WINDOW (dlg), "HTML Options");

  vbox = gtk_vbox_new (FALSE, 10);
  gtk_widget_show (vbox);
  gtk_container_add (GTK_CONTAINER (dlg), vbox);
  gtk_container_border_width (GTK_CONTAINER (vbox), 10);

  hbox = gtk_hbox_new (FALSE, 10);
  gtk_widget_show (hbox);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);

  vbox1 = gtk_vbox_new (FALSE, 10);
  gtk_widget_show (vbox1);
  gtk_box_pack_start (GTK_BOX (hbox), vbox1, TRUE, TRUE, 0);

  frame = gtk_frame_new ("Layout");
  gtk_widget_show (frame);
  gtk_box_pack_start (GTK_BOX (vbox1), frame, FALSE, TRUE, 0);

  vbox2 = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (vbox2);
  gtk_container_add (GTK_CONTAINER (frame), vbox2);
  gtk_container_border_width (GTK_CONTAINER (vbox2), 5);

  s.single = gtk_radio_button_new_with_label (radio_group, "Single page");
  radio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (s.single));
  gtk_widget_show (s.single);
  gtk_box_pack_start (GTK_BOX (vbox2), s.single, TRUE, TRUE, 0);

  s.multiple = gtk_radio_button_new_with_label (radio_group, "One step per page");
  radio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (s.multiple));
  gtk_widget_show (s.multiple);
  gtk_box_pack_start (GTK_BOX (vbox2), s.multiple, TRUE, TRUE, 0);

  s.index = gtk_check_button_new_with_label ("Index page");
  gtk_widget_show (s.index);
  gtk_box_pack_start (GTK_BOX (vbox2), s.index, TRUE, TRUE, 0);

  vbox2 = gtk_vbox_new (FALSE, 5);
  gtk_widget_show (vbox2);
  gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, TRUE, 0);

  button = gtk_button_new_with_label ("OK");
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
              GTK_SIGNAL_FUNC (htmldlg_ok), &s);
  gtk_widget_show (button);
  gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, TRUE, 0);
  gtk_widget_set_usize (button, 60, -2);
  GtkAccelGroup *accel_group = gtk_accel_group_new ();
  gtk_window_add_accel_group (GTK_WINDOW (dlg), accel_group);
  gtk_widget_add_accelerator (button, "clicked", accel_group,
                              GDK_Return, (GdkModifierType)0, GTK_ACCEL_VISIBLE);

  button = gtk_button_new_with_label ("Cancel");
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
              GTK_SIGNAL_FUNC (dlg_default_callback), GINT_TO_POINTER (LC_CANCEL));
  gtk_widget_show (button);
  gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, TRUE, 0);
  gtk_widget_set_usize (button, 60, -2);
  gtk_widget_add_accelerator (button, "clicked", accel_group,
                              GDK_Escape, (GdkModifierType)0, GTK_ACCEL_VISIBLE);

  button = gtk_button_new_with_label ("Images...");
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
              GTK_SIGNAL_FUNC (htmldlg_images), &s);
  gtk_widget_show (button);
  gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, TRUE, 0);
  gtk_widget_set_usize (button, 60, -2);

  frame = gtk_frame_new ("Pieces List");
  gtk_widget_show (frame);
  gtk_box_pack_start (GTK_BOX (vbox1), frame, FALSE, TRUE, 0);

  vbox2 = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (vbox2);
  gtk_container_add (GTK_CONTAINER (frame), vbox2);
  gtk_container_border_width (GTK_CONTAINER (vbox2), 5);

  s.list_step = gtk_check_button_new_with_label ("After each step");
  gtk_widget_show (s.list_step);
  gtk_box_pack_start (GTK_BOX (vbox2), s.list_step, TRUE, TRUE, 0);

  s.list_end = gtk_check_button_new_with_label ("At the end");
  gtk_widget_show (s.list_end);
  gtk_box_pack_start (GTK_BOX (vbox2), s.list_end, TRUE, TRUE, 0);

  s.images = gtk_check_button_new_with_label ("Create Images");
  gtk_widget_show (s.images);
  gtk_box_pack_start (GTK_BOX (vbox2), s.images, TRUE, TRUE, 0);

  s.highlight = gtk_check_button_new_with_label ("Highlight new pieces");
  gtk_widget_show (s.highlight);
  gtk_box_pack_start (GTK_BOX (vbox), s.highlight, FALSE, TRUE, 0);

  s.htmlext = gtk_check_button_new_with_label ("Save files with .html extension");
  gtk_widget_show (s.htmlext);
  gtk_box_pack_start (GTK_BOX (vbox), s.htmlext, FALSE, TRUE, 0);

  hbox = gtk_hbox_new (FALSE, 5);
  gtk_widget_show (hbox);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

  label = gtk_label_new ("Output directory");
  gtk_widget_show (label);
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);

  s.directory = gtk_entry_new ();
  gtk_widget_show (s.directory);
  gtk_box_pack_start (GTK_BOX (hbox), s.directory, TRUE, TRUE, 0);

  button = gtk_button_new_with_label ("...");
  gtk_widget_show (button);
  gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0);

  gtk_signal_connect (GTK_OBJECT (s.single), "toggled", GTK_SIGNAL_FUNC (htmldlg_layout), &s);
  gtk_signal_connect (GTK_OBJECT (s.multiple), "toggled", GTK_SIGNAL_FUNC (htmldlg_layout), &s);
  gtk_signal_connect (GTK_OBJECT (s.list_step), "toggled", GTK_SIGNAL_FUNC (htmldlg_list), &s);
  gtk_signal_connect (GTK_OBJECT (s.list_end), "toggled", GTK_SIGNAL_FUNC (htmldlg_list), &s);

  if (opts->singlepage)
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s.single), TRUE);
  else
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s.multiple), TRUE);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s.index), opts->index);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s.images), opts->images);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s.list_end), opts->listend);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s.list_step), opts->liststep);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s.highlight), opts->highlight);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s.htmlext), opts->htmlext);

  gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (s.single));
  gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (s.list_step));