/*
 * Photo Image Print System
 * Copyright (C) 2000-2004 EPSON KOWA Corporation.
 * Copyright (C) SEIKO EPSON CORPORATION 2000-2004.
 *
 *  This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * As a special exception, EPSON KOWA Corporation gives permission to
 * link the code of this program with libraries which are covered by
 * the EPSON KOWA PUBLIC LICENCE and distribute their linked
 * combinations.  You must obey the GNU General Public License in all
 * respects for all of the code used other than the libraries which
 * are covered by EPSON KOWA PUBLIC LICENCE.
 */
#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#if USE_GTK

#include <string.h>
#include <ctype.h>
#include <math.h>
#include "xMode.h"

typedef struct _IO_SIGDATA{
	GtkWidget *filewin;
	GtkWidget *entry;
} IO_SIGDATA;

extern void *options[EX_N_OPT];
extern void *opt_address[EX_N_OPT];
extern char *input_file;
extern char *output_file;
extern int output_type;

static GtkWidget* commonPixmapLoad(char*);

static RADIO_PACK* radioPackAdd(int);
static void radioPackChengeValue(GtkWidget*, RADIO_PACK*);

static CHECK_PACK* checkPackAdd(int);
static void checkPackSetSensitive(CHECK_PACK*, int);
static void checkPackChengeValue(GtkWidget*, CHECK_PACK*);

static SELECT_PACK* selectPackAdd(int);
static void selectPackSetSensitive(SELECT_PACK*, char*[]);
static void selectPackVisibility(SELECT_PACK*, int);
static void selectPackChengeValue(GtkWidget*, SELECT_PACK*);

static SPIN_PACK* spinPackAdd(int);
static void spinPackChengeValue(GtkAdjustment*, SPIN_PACK*);

static ADJUSTMENT_PACK* adjustmentPackAdd(int);
static void adjustmentPackSetSensitive(ADJUSTMENT_PACK*, int);
static void adjustmentPackChengeValue(GtkAdjustment*, ADJUSTMENT_PACK*);
static void adjustmentPackChengeEntry(GtkWidget*, ADJUSTMENT_PACK*);
static void adjustmentPackCheckEntry(GtkWidget*, GdkEvent*, ADJUSTMENT_PACK*);

static void ioOutputTypeSet(GtkWidget*, gpointer);
static GtkWidget* ioPackButton(GtkWidget*);
static void ioPackFileSelection(GtkWidget*, GtkWidget*);
static void ioPackOkSel(GtkWidget*, IO_SIGDATA*);
static void ioPackCanSel(GtkWidget*, IO_SIGDATA*);
static void ioPackChengeValue(GtkEntry*, char*);

#ifdef CONV_VERSION2
static void
margin_default_set (GtkWidget*, void*);
static void
margin_abjset (void);
static void
margin_updata (int, long, long);

#endif /* CONV_VERSION2 */

/* ================================================== */
/*           common functions */
/* ================================================== */
static GtkWidget* commonPixmapLoad(char *map)
{
	GtkWidget *pixmap = NULL;
	//=-=-=-=-=-=-=-=-=-=-=-=-=-=
	//    under construction
	//=-=-=-=-=-=-=-=-=-=-=-=-=-=
	return pixmap;
}

char* commonLabelCall(int id, OPTION_DATA *data)
{
	int i;
	char *title = NULL;
	
	if (data == NULL) {
		for (i = 0; opt_all[i].id != END_ARRAY; i++) {
			if(opt_all[i].id == id) {
				title = opt_all[i].x_name;
			}
		}
	} else {
		title = data->x_name;
	}

	if (title)
		return (char*)_(title);
	
	return NULL;
}

void commonSetOptionsSensitive(void)
{
	int i, j, count;
	int flag[ENTRY_MAX];
	char *new_entry[ENTRY_MAX];
	const short *mode;
	SEP_INIT_PARAM *sepip_lite;
	OPTION_DATA *data;
	SELECT_PACK *sp;

	sepip_lite = (SEP_INIT_PARAM *)malloc(sizeof(SEP_INIT_PARAM));

	count = 0;
	sp = (SELECT_PACK *)opt_address[P_COLOR_MODE];
	if(strcmp((char *)options[P_INK], "MONO")){ /* Color */
		mode = pModeCol;
		flag[0] = TRUE;
		gtk_widget_show(sp->hbox);
	}
	else{ /* mono */
		mode = pModeMono;
		flag[0] = FALSE;
		gtk_widget_hide(sp->hbox);
	}


	if(strcmp((char *)options[P_COLOR_MODE], "NONE")) flag[1] = TRUE;
	else flag[1] = FALSE;
	adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_BRIGHTNESS], flag[1]);
	adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_CONTRAST], flag[1]);

	if(flag[1]){
		adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_SATURATION], flag[0]);
		adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_STRENGTH_CYAN], flag[0]);
		adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_STRENGTH_MAGENTA], flag[0]);
		adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_STRENGTH_YELLOW], flag[0]);
	}
	else{
		adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_SATURATION], FALSE);
		adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_STRENGTH_CYAN], FALSE);
		adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_STRENGTH_MAGENTA], FALSE);
		adjustmentPackSetSensitive((ADJUSTMENT_PACK *)opt_address[P_STRENGTH_YELLOW], FALSE);
	}


	/* パラメータと,そのダミー */
	sepip_lite->src_resolution.x = sepip_lite->halftone_type
		= sepip_lite->high_speed = sepip_lite->qlevel = -1;
	sepip_lite->media_type = getValueOfDatabases(P_MEDIA_TYPE, (char *)options[P_MEDIA_TYPE]);

	/* make new resolution entry */
	data = opt_all[P_RESOLUTION].data;

	for(i = 0; data[i].value != END_ARRAY; i++) flag[i] = FALSE;
	sepip_lite->media_type = getValueOfDatabases(P_MEDIA_TYPE, (char *)options[P_MEDIA_TYPE]);
  
	count = 0;
	for(i = 0; i < mode[0]; i++){
		if(!printModeCheck(mode, i, sepip_lite))
		{
			for(j = 0; data[j].value != END_ARRAY; j++)
			{
				if(mode[i * MODE_ITEM + 2] & (int)ldexp(1.0, j))
				{
					flag[j] = TRUE;
				}
			}
		}
	}
	count = 0;
	for(i = 0; data[i].value != END_ARRAY; i++)
	{
		if(flag[i] == TRUE)
		{
			new_entry[count++] = data[i].rsc_name;
		}
	}
	new_entry[count] = NULL;
	selectPackSetSensitive((SELECT_PACK *)opt_address[P_RESOLUTION], new_entry);


	// make new quality level entry
	sepip_lite->src_resolution.x = getValueOfDatabases(P_RESOLUTION, (char *)options[P_RESOLUTION]);
	data = opt_all[P_QUALITY_LEVEL].data;

	for(i = 0; data[i].value != END_ARRAY; i++) flag[i] = FALSE;
	for(i = 0; i < mode[0]; i++){
		if(!printModeCheck(mode, i, sepip_lite)){
			unsigned int bit = mode[i * MODE_ITEM + 5];
			switch (sepip_lite->src_resolution.x)
			{
			case 120:
			case 180: flag[0] = TRUE;
	  
			case 720: bit = bit >> 4;
			case 360: bit = bit >> 4;
			}
			bit &= 0x0f;
			for(j = 0; data[j].value != END_ARRAY; j++){
				if(bit == data[j].value) flag[j] = TRUE;
			}
		}
	}
	count = 0;
	for(i = 0; data[i].value != END_ARRAY; i++)
		if(flag[i] == TRUE) new_entry[count++] = data[i].rsc_name;
	new_entry[count] = NULL;
	selectPackSetSensitive((SELECT_PACK *)opt_address[P_QUALITY_LEVEL], new_entry);
	selectPackVisibility((SELECT_PACK *)opt_address[P_QUALITY_LEVEL], i - 1);

	/* check high speed sensitive */
	data = opt_all[P_QUALITY_LEVEL].data;

	for(i = 0; data[i].value != END_ARRAY; i++) flag[i] = FALSE;
	sepip_lite->qlevel = getValueOfDatabases(P_QUALITY_LEVEL, (char *)options[P_QUALITY_LEVEL]);

	for(i = 0; i < mode[0]; i++){
		if(!printModeCheck(mode, i, sepip_lite))
		{
			checkPackSetSensitive((CHECK_PACK *)opt_address[P_HIGH_SPEED], mode[i * MODE_ITEM + 4]);
			goto OUT;
		}
	}
 OUT:


	/* make halftonetype entry */
	data = opt_all[P_HALF_TONE].data;
	for(i = 0; data[i].value != END_ARRAY; i++) flag[i] = FALSE;

	for(i = 0; i < mode[0]; i++){
		if(!printModeCheck(mode, i, sepip_lite)){
			for(j = 0; data[j].value != END_ARRAY; j++){
				if(mode[i * MODE_ITEM + 3] & (int)ldexp(1.0, j)) flag[j] = TRUE;
			}
			goto OUT2;
		}
	}
 OUT2:

	count = 0;
	for(i = 0; data[i].value != END_ARRAY; i++)
		if(flag[i] == TRUE) new_entry[count++] = data[i].rsc_name;
	new_entry[count] = NULL;
	selectPackSetSensitive((SELECT_PACK *)opt_address[P_HALF_TONE], new_entry);
  
	free(sepip_lite);
#ifdef ROLL_PAPER
	{
		char **msentry;
		switch(getValueOfDatabases(P_BIN, (char *)options[P_BIN])){
		case PIPS_BIN_AUTO: msentry = mediaSizeEntry; break;
		case PIPS_BIN_USER: msentry = mediaSizeEntry_R; break;
#if !(PM820_3300C)
		case PIPS_BIN_TRIMBANNER: msentry = mediaSizeEntry_TR; break;
#else
		case PIPS_BIN_TB_PM3300C: msentry = mediaSizeEntry_TR_PM3300C; break;
		case PIPS_BIN_TB_PM820C: msentry = mediaSizeEntry_TR_PM820C; break;
#endif /* PM820_3300C */
#if (PM820C)
		case PIPS_BIN_AUTO_TRIM: msentry = mediaSizeEntry_TA; break;
#endif /* PM820C */

		default: return;
		}
		selectPackSetSensitive((SELECT_PACK *)opt_address[P_MEDIA_SIZE], msentry);
	}
#endif /* ROLL_PAPER */

#ifdef CONV_VERSION2
	margin_abjset ();
#endif /* CONV_VERSION2 */
}


/* ================================================== */
/*           radio pack functions */
/* ================================================== */

static RADIO_PACK* radioPackAdd(int id)
{
	RADIO_PACK *rp;

	rp = (RADIO_PACK *)malloc(sizeof(RADIO_PACK));
	rp->id = id;
	rp->pixmap = NULL;
	rp->label = NULL;
	rp->group = NULL;

	opt_address[id] = rp;
	return rp;
}


static void radioPackChengeValue(GtkWidget *widget, RADIO_PACK *rp)
{
	GSList *node;
	GtkWidget *radio;
	int i, id;

	id = rp->id;
	for(i = 0; (node = g_slist_nth(rp->group, i)) != NULL; i++){
		radio = (GtkWidget *)node->data;
		if(radio == widget){
			options[id] = (void *)opt_all[id].data[i].rsc_name;
			break;
		}
	}
	commonSetOptionsSensitive();
}

GtkWidget* radioPackNew(char *map, char *entry[], int id)
{
	GtkWidget *frame;
	GtkWidget *hbox;
	GtkWidget *pixmap;
	GtkWidget *radio;
	GSList *group;
	RADIO_PACK *rp;
	OPTION_DATA *data;
	int offset = 0;
	gpointer sig_id;

	rp = radioPackAdd(id);
	sig_id = opt_address[id];

	frame = gtk_frame_new(commonLabelCall(id, NULL));
	gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);

	hbox = gtk_hbox_new(FALSE, GTK_BORDER);

	if(map) pixmap = commonPixmapLoad(map);
  
	for(offset = 0; entry[offset] != NULL; offset++);
	if((data = databasesCall(CALL_FOR_RSC_NAME, id, (void*)entry[--offset])) == NULL)
		return NULL;
	radio = gtk_radio_button_new_with_label(NULL,
						commonLabelCall(id, data));
	if(!strcmp(data->rsc_name, (char*)options[id]))
		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(radio), TRUE);
	else gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(radio), FALSE);
	gtk_signal_connect(GTK_OBJECT(radio), "pressed",
			   GTK_SIGNAL_FUNC(radioPackChengeValue), sig_id);

	gtk_box_pack_start(GTK_BOX(hbox), radio, FALSE, FALSE, 0);
	gtk_widget_show(radio);
	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radio));
	offset--;
	for(; offset >= 0; offset--){
		if((data = databasesCall(CALL_FOR_RSC_NAME, id, (void*)entry[offset])) == NULL)
			return NULL;
		radio = gtk_radio_button_new_with_label(group,
							commonLabelCall(id, data));
		if(!strcmp(data->rsc_name, (char*)options[id]))
			gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(radio), TRUE);
		else gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(radio), FALSE);
		gtk_signal_connect(GTK_OBJECT(radio), "pressed",
				   GTK_SIGNAL_FUNC(radioPackChengeValue), sig_id);
		gtk_box_pack_start(GTK_BOX(hbox), radio, FALSE, FALSE, 0);
		gtk_widget_show(radio);
	}
	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radio));
  
	gtk_container_add(GTK_CONTAINER(frame), hbox);
	gtk_widget_show(hbox);

	rp->id = id;
	if(map) rp->pixmap = pixmap;
	rp->group = group;
  
	gtk_container_set_border_width (GTK_CONTAINER (frame), GTK_BORDER);
	return frame;
}

/* ================================================== */
/*           check_pack functions */
/* ================================================== */

static CHECK_PACK* checkPackAdd(int id)
{
	CHECK_PACK *cp;

	cp = (CHECK_PACK *)malloc(sizeof(CHECK_PACK));
	cp->id = id;
	cp->id = 0;
	cp->pixmap = NULL;
	cp->check = NULL;

	opt_address[id] = cp;
	return cp;
}


static void checkPackSetSensitive(CHECK_PACK *cp, int flag)
{
	int aflag = FALSE;

	if(flag == 2) aflag = TRUE;
	if(cp->pixmap) gtk_widget_set_sensitive(cp->pixmap, TRUE);
	gtk_widget_set_sensitive(cp->check, aflag);

	if(flag != 2)
		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(cp->check), flag);
	cp->flag = 1;
	gtk_signal_emit_by_name(GTK_OBJECT(cp->check), "toggled");
}


static void checkPackChengeValue(GtkWidget *widget, CHECK_PACK *cp)
{
	OPTION_DATA *optdata;
	int i, id;

	id = cp->id;
	if(GTK_TOGGLE_BUTTON(widget)->active){
		for(i = 0; opt_all[i].id != id; i++);
		optdata = databasesCall(CALL_FOR_X_NAME, id, (void*)opt_all[i].x_name);
		options[id] = (void *)optdata->rsc_name;
	}
	else{
		options[id] = NULL;
	}
	if(cp->flag == 0){
		commonSetOptionsSensitive();
	}
	cp->flag = 0;
}

GtkWidget* checkPackNew(char *map, int id)
{
	GtkWidget *hbox;
	GtkWidget *pixmap;
	GtkWidget *check;
	CHECK_PACK *cp;
	void *sig_id;
  
	cp = checkPackAdd(id);
	sig_id = opt_address[id];

	hbox = gtk_hbox_new(FALSE, GTK_BORDER);

	if(map){
		pixmap = commonPixmapLoad(map);
		gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, TRUE, 0);
	}

	check = gtk_check_button_new_with_label(commonLabelCall(id, NULL));
	gtk_widget_show(check);
	gtk_box_pack_start(GTK_BOX(hbox), check, TRUE, TRUE, 0);
	if(options[id] != NULL) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
	else gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);

	gtk_signal_connect(GTK_OBJECT(check), "toggled", GTK_SIGNAL_FUNC(checkPackChengeValue), sig_id);

	cp->id = id;
	cp->flag = 0;
	if(map) cp->pixmap = pixmap;
	cp->check = check;
	return hbox;
}


/* ================================================== */
/*           select_pack functions */
/* ================================================== */

static SELECT_PACK* selectPackAdd(int id)
{
	SELECT_PACK *sp;

	sp = (SELECT_PACK *)malloc(sizeof(SELECT_PACK));
	sp->id = id;
	sp->pixmap = NULL;
	sp->label = NULL;
	sp->optmenu = NULL;
	sp->hbox = NULL;

	opt_address[id] = sp;
	return sp;
}


static void selectPackSetSensitive(SELECT_PACK *sp, char *entry[])
{
	GtkWidget *optmenu;
	GtkWidget *menu;
	GtkWidget *item;
	OPTION_DATA *data;
	int i, id, def;
	char *title;
	gpointer sig_id;

	id = sp->id;
	title = commonLabelCall(id, NULL);
	sig_id = opt_address[id];
	menu = gtk_menu_new();
	def = -1;
	for(i = 0; entry[i] != NULL; i++){
		data = databasesCall(CALL_FOR_RSC_NAME, id, (void*)entry[i]);
		item = gtk_menu_item_new_with_label(commonLabelCall(id, data));
		gtk_object_set_data(GTK_OBJECT(item), title, data);
		gtk_signal_connect(GTK_OBJECT(item), "activate",
				   GTK_SIGNAL_FUNC(selectPackChengeValue), sig_id);
		if(!strcmp(data->rsc_name, (char*)options[id])) def = i;
		gtk_menu_insert(GTK_MENU(menu), item, i);
		gtk_widget_show(item);
	}
	if(def == -1){
		options[id] = entry[0];
		def = 0;
	}
	gtk_menu_set_active(GTK_MENU(menu), def);
	optmenu = sp->optmenu;
	gtk_option_menu_remove_menu(GTK_OPTION_MENU(optmenu));
	gtk_option_menu_set_menu(GTK_OPTION_MENU(optmenu), menu);
}


static void selectPackVisibility(SELECT_PACK *sp, int flag)
{
	if(sp == NULL) return;
	if(flag) gtk_widget_show(sp->hbox);
	else gtk_widget_hide(sp->hbox);
}
  

static void selectPackChengeValue(GtkWidget *widget, SELECT_PACK *sp)
{
	GtkWidget *label;
	OPTION_DATA *optdata;
	int id;

	id = sp->id;
	label = sp->label;
	optdata = (OPTION_DATA *)gtk_object_get_data(GTK_OBJECT(widget), GTK_LABEL(label)->label);
	options[id] = optdata->rsc_name;
	commonSetOptionsSensitive();

	/* set margin abjustment  -add Mon Aug 28 2000 sk */
#ifdef CONV_VERSION2
	if (id == P_MEDIA_SIZE || id == P_BIN)
	{
		margin_default_set (NULL, NULL);
	}
#endif /* CONV_VERSION2 */
}



GtkWidget* selectPackNew(char *map, char *entry[], int id)
{
	GtkWidget *hbox;
	GtkWidget *pixmap;
	GtkWidget *label;
	GtkWidget *optmenu;
	GtkWidget *menu;
	GtkWidget *item;
	SELECT_PACK *sp;
	OPTION_DATA *data;
	char *title;
	int i, def;
	gpointer sig_id;

	sp = selectPackAdd(id);
	sig_id = opt_address[id];

	hbox = gtk_hbox_new(FALSE, GTK_BORDER);

	if(map) pixmap = commonPixmapLoad(map);

	title = commonLabelCall(id, NULL);
	label = gtk_label_new(title);
	gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
	gtk_widget_show(label);

	optmenu = gtk_option_menu_new();
	menu = gtk_menu_new();
	for(i = 0; entry[i] != NULL; i++){
		if((data = databasesCall(CALL_FOR_RSC_NAME, id, (void*)entry[i])) == NULL)
			return NULL;
		item = gtk_menu_item_new_with_label(commonLabelCall(id, data));
		gtk_object_set_data(GTK_OBJECT(item), title, data);
		if(!strcmp(data->rsc_name, (char*)options[id])) def = i;
		gtk_menu_insert(GTK_MENU(menu), item, i);
		gtk_widget_show(item);
		gtk_signal_connect(GTK_OBJECT(item), "activate",
				   GTK_SIGNAL_FUNC(selectPackChengeValue), sig_id);

	}
	gtk_menu_set_active(GTK_MENU(menu), def);
	gtk_option_menu_set_menu(GTK_OPTION_MENU(optmenu), menu);
	gtk_box_pack_start(GTK_BOX(hbox), optmenu, TRUE, TRUE, 0);
	gtk_widget_show(optmenu);
  
	if(map) sp->pixmap = pixmap;
	sp->label = label;
	sp->optmenu = optmenu;
	sp->hbox = hbox;
	return hbox;
}


/* ================================================== */
/*           spin_pack functions */
/* ================================================== */


static SPIN_PACK* spinPackAdd(int id)
{
	SPIN_PACK *spp;

	spp = (SPIN_PACK *)malloc(sizeof(SPIN_PACK));
	spp->id = id;
	spp->pixmap = NULL;
	spp->label = NULL;
	spp->adj = NULL;
	spp->spin = NULL;

	opt_address[id] = spp;
	return spp;
}


/* spinPackSetSensitive 未使用 */

static void spinPackChengeValue(GtkAdjustment *adj, SPIN_PACK *spp)
{
	int id, *new_value;
  
	id = spp->id;
	new_value = (int *)options[id];
	*new_value = (int)adj->value;
}



GtkWidget* spinPackNew(char *map, int id, double param[])
{
	GtkWidget *hbox;
	GtkWidget *pixmap;
	GtkWidget *label;
	GtkObject *adj;
	GtkWidget *spin;
	SPIN_PACK *spp;
	gpointer sig_id;
	int *value;

	spp = spinPackAdd(id);
	sig_id = opt_address[id];

	hbox = gtk_hbox_new(FALSE, GTK_BORDER);

	if(map) pixmap = commonPixmapLoad(map);
  
	label = gtk_label_new(commonLabelCall(id, NULL));
	gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
	gtk_widget_show(label);
  
	value = (int*)options[id];
	adj = gtk_adjustment_new(*value, param[0], param[1],
				 param[2], param[3], param[4]);
	spin = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 0, 0);
	gtk_spin_button_set_shadow_type(GTK_SPIN_BUTTON(spin), GTK_SHADOW_OUT);
	gtk_box_pack_start(GTK_BOX(hbox), spin, TRUE, TRUE, 0);
	gtk_widget_show(spin);
	gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
			   GTK_SIGNAL_FUNC(spinPackChengeValue), sig_id);

	if(map) spp->pixmap = pixmap;
	spp->label = label;
	spp->adj = adj;
	spp->spin = spin;
	return hbox;
}

/* ================================================== */
/*           adjustment_pack functions */
/* ================================================== */

static ADJUSTMENT_PACK* adjustmentPackAdd(int id)
{
	ADJUSTMENT_PACK *ap;

	ap = (ADJUSTMENT_PACK *)malloc(sizeof(ADJUSTMENT_PACK));
	ap->id = id;
	ap->pixmap = NULL;
	ap->label = NULL;
	ap->adj = NULL;
	ap->entry = NULL;
	ap->hscale = NULL;
	ap->max = 0.0;
	ap->min = 0.0;
	opt_address[id] = ap;
	return ap;
}


static void adjustmentPackSetSensitive(ADJUSTMENT_PACK *ap, int flag)
{
	if(ap->pixmap) gtk_widget_set_sensitive(ap->pixmap, flag);
	gtk_widget_set_sensitive(ap->label, flag);
	gtk_widget_set_sensitive(ap->entry, flag);
	gtk_widget_set_sensitive(ap->hscale, flag);
}


static void adjustmentPackChengeValue(GtkAdjustment *adj,
				      ADJUSTMENT_PACK *ap)
{
	int id, *new_value;
	GString *strval;

	id = ap->id;
	strval = g_string_new ("");
	g_string_sprintf (strval, "%i", (int)adj->value);

	if (strcmp (gtk_entry_get_text (GTK_ENTRY(ap->entry)), strval->str))
		gtk_entry_set_text(GTK_ENTRY(ap->entry), strval->str);
	g_string_free(strval, TRUE);

	new_value = (int *)options[id];
	*new_value = (int)adj->value;  
	return;
}


static void adjustmentPackChengeEntry(GtkWidget* widget,
				      ADJUSTMENT_PACK *ap)
{
	int id, *opt_value, i, check;
	char* strval;

	id = ap->id;
	opt_value = (int *)options[id];
	strval = (char*)gtk_entry_get_text(GTK_ENTRY(widget));

	check = 0;
	for (i = 0; i < strlen (strval); i++)
	{
		if (!isdigit (strval[i]))
			if (i != 0 || strval[i] != '-')
				check = 1;
	}

	if (!check)
	{
		double new_value;

		new_value = atof(strval);
		if ((double)new_value >= ap->min && (double)new_value <= ap->max)
		{
			*opt_value = (int)new_value;
			if (*opt_value != (double)((GtkAdjustment *)ap->adj)->value)
				gtk_adjustment_set_value(GTK_ADJUSTMENT(ap->adj),
							 (gfloat)*opt_value);
			return;		/* NO_ERROR */
		}
	}

	gtk_signal_handler_block_by_data (GTK_OBJECT(widget), (gpointer)ap);
	sprintf (strval, "%d", *opt_value);
	gtk_entry_set_text(GTK_ENTRY(widget), strval);
	gtk_signal_handler_unblock_by_data (GTK_OBJECT(widget), (gpointer)ap);
  
	return;
}

static void adjustmentPackCheckEntry(GtkWidget* widget,
				     GdkEvent* event, ADJUSTMENT_PACK *ap )
{
	int id, *opt_value, len;
	char* strval;

	/* check only for NULL */

	id = ap->id;
	opt_value = (int *)options[id];
	strval = (char*)gtk_entry_get_text(GTK_ENTRY(widget));

	
	len = strlen(strval);
	/* 文字列が存在していて, 最大桁が0でなければOK */
	if ((len == 0)
	    || ((len > 1) && ((strval[0] == '0')
			      || (strval[0] == '-') && (strval[1] == '0'))))
	{
		gtk_signal_handler_block_by_data (GTK_OBJECT(widget), (gpointer)ap);
		/* *opt_value = 0; */
		sprintf (strval, "%d", *opt_value );
		gtk_entry_set_text(GTK_ENTRY(widget), strval);
		gtk_signal_handler_unblock_by_data (GTK_OBJECT(widget), (gpointer)ap);
	}
	return;
}

GtkWidget* adjustmentPackNew(char *map, int id, double param[])
{
	GtkWidget *hbox;
	GtkWidget *pixmap;
	GtkWidget *label;
	GtkObject *adj;
	GtkWidget *entry;
	GtkWidget *hscale;
	GString *strval;
	ADJUSTMENT_PACK *ap;
	gpointer sig_id;
	int *value;

	ap = adjustmentPackAdd(id);
	sig_id = opt_address[id];
  
	hbox = gtk_hbox_new(FALSE, GTK_BORDER);

	if(map) pixmap = commonPixmapLoad(map);
  
	label = gtk_label_new(commonLabelCall(id, NULL));
	gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
	gtk_widget_show(label);

	value = (int*)options[id];
	entry = gtk_entry_new_with_max_length(3);
	strval = g_string_new("");
	g_string_sprintf(strval, "%i", *value);
	gtk_entry_set_text(GTK_ENTRY(entry), strval->str);
	g_string_free(strval, TRUE);
  
	gtk_widget_set_usize(entry, entry->style->font->ascent * 4,
			     entry->style->font->ascent +
			     entry->style->font->descent +
			     entry->style->klass->ythickness * 2);
	gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, TRUE, 0);
	gtk_widget_show(entry);
	gtk_signal_connect(GTK_OBJECT(entry), "changed",
			   GTK_SIGNAL_FUNC(adjustmentPackChengeEntry), sig_id);
	/* focus out */
	gtk_signal_connect(GTK_OBJECT(entry), "focus_out_event",
			   GTK_SIGNAL_FUNC(adjustmentPackCheckEntry), sig_id );

	adj = gtk_adjustment_new(*value, param[0], param[1],
				 param[2], param[3], param[4]);
  
	hscale = gtk_hscale_new(GTK_ADJUSTMENT(adj));
	gtk_scale_set_draw_value(GTK_SCALE(hscale), FALSE);
	gtk_widget_set_usize(hscale, 180, 14);
	gtk_box_pack_start(GTK_BOX(hbox), hscale, FALSE, TRUE, 0);
	gtk_widget_show(hscale);
	gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
			   GTK_SIGNAL_FUNC(adjustmentPackChengeValue), sig_id);

	if(map) ap->pixmap = pixmap;
	ap->label = label;
	ap->adj = adj;
	ap->entry = entry;
	ap->hscale = hscale;
	ap->max = param[1];
	ap->min = param[0];
	return hbox;
}


/* ================================================== */
/*           io_pack functions */
/* ================================================== */

typedef struct _IO_PACK{
	char *label;
	GtkWidget *hbox;
} IO_PACK;

GtkWidget* ioPackNew(char *title, int flag)
{
	GtkWidget *frame;
	GtkWidget *vbox;
	GtkWidget *hbox;
	GtkWidget *entry;
	GtkWidget *button;
	GtkWidget *radio;
	GSList *group;
	IO_PACK *ip;

	frame = gtk_frame_new(title);
	gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);

	vbox = gtk_vbox_new(FALSE, 5);
	hbox = gtk_hbox_new(FALSE, 10);

	entry = gtk_entry_new();
	gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
	if(flag == INPUT){
		gtk_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(ioPackChengeValue), input_file);
		gtk_entry_set_text(GTK_ENTRY(entry), input_file);
	}
	else{
		gtk_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(ioPackChengeValue), output_file);
		gtk_entry_set_text(GTK_ENTRY(entry), output_file);
	}
	gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
	gtk_widget_show(entry);

	button = ioPackButton(entry);
	gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
	gtk_widget_show(button);

	if(flag == OUTPUT){
		ip = (IO_PACK *)malloc(sizeof(IO_PACK));
		ip->hbox = hbox;
		radio = gtk_radio_button_new_with_label(NULL, _(outputLabels[0]));
		gtk_box_pack_start(GTK_BOX(vbox), radio, FALSE, TRUE, 0);
		ip->label = outputLabels[0];
		gtk_signal_connect(GTK_OBJECT(radio), "clicked",
				   GTK_SIGNAL_FUNC(ioOutputTypeSet), ip);
		gtk_widget_show(radio);

		group = gtk_radio_button_group(GTK_RADIO_BUTTON(radio));
		radio = gtk_radio_button_new_with_label(group, (char*)_(outputLabels[1]));
		gtk_box_pack_start(GTK_BOX(vbox), radio, FALSE, TRUE, 0);
		gtk_signal_connect(GTK_OBJECT(radio), "clicked",
				   GTK_SIGNAL_FUNC(ioOutputTypeSet), NULL);
		gtk_widget_show(radio);
    
		opt_address[P_OUTPUT_EX] = ip;
	}

	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
	if(flag == INPUT) gtk_widget_show(hbox);

	gtk_container_add(GTK_CONTAINER(frame), vbox);
	gtk_widget_show(vbox);

	gtk_container_set_border_width (GTK_CONTAINER (frame), GTK_BORDER);
	return frame;
}


static void ioOutputTypeSet(GtkWidget *widget, gpointer data)
{
	IO_PACK *ip;

	ip = (IO_PACK *)opt_address[P_OUTPUT_EX];
	if(data != NULL){
		output_type = 1;
		gtk_widget_hide(ip->hbox);
	}
	else{
		output_type = 0;
		gtk_widget_show(ip->hbox);
	}
}


static GtkWidget* ioPackButton(GtkWidget *entry)
{
	GtkWidget *button;
	char *name;

	name = ioLabels[2];
	button = gtk_button_new_with_label(_(name));
	gtk_signal_connect(GTK_OBJECT(button), "clicked",
			   GTK_SIGNAL_FUNC(ioPackFileSelection), entry);

	return button;
}

static void ioPackFileSelection(GtkWidget *widget, GtkWidget *entry)
{
	GtkWidget *filewin;
	IO_SIGDATA *io_sig;

	io_sig = (IO_SIGDATA *)malloc(sizeof(IO_SIGDATA));

	filewin = gtk_file_selection_new("select file");
	gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(filewin));
	gtk_file_selection_set_filename(GTK_FILE_SELECTION(filewin), gtk_entry_get_text(GTK_ENTRY(entry)));
	io_sig->entry = entry;
	io_sig->filewin = filewin;
	gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filewin)),
			   "delete_event", GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
	gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filewin)->ok_button),
			   "clicked", GTK_SIGNAL_FUNC(ioPackOkSel), io_sig);
	gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filewin)->cancel_button),
			   "clicked", GTK_SIGNAL_FUNC(ioPackCanSel), NULL);
	gtk_widget_show(filewin);

	gtk_grab_add(filewin);
	gtk_main();
	gtk_grab_remove(filewin);

	gtk_widget_destroy(filewin);
	g_free(io_sig);
}


static void ioPackOkSel(GtkWidget *widget, IO_SIGDATA *io_sig)
{
	char *name;
  
	if((name = gtk_file_selection_get_filename
	    (GTK_FILE_SELECTION(io_sig->filewin))) != NULL)
		gtk_entry_set_text(GTK_ENTRY(io_sig->entry), name);
	gtk_main_quit();
}


static void ioPackCanSel(GtkWidget *widget, IO_SIGDATA *io_sig)
{
	gtk_main_quit();
}


static void ioPackChengeValue(GtkEntry *entry, char *file)
{
	strcpy(file, gtk_entry_get_text(entry));
}


#ifdef CONV_VERSION2
/* デフォルトマージンを設定出来る様にする為に, 追加
   かなり無理矢理                Mon Aug 28 2000 sk */
#include "paper.h"

GtkWidget*
margin_default_set_button (void)
{
	GtkWidget *button;
	char* name;

	name = def_margin_label;
	button = gtk_button_new_with_label(_(name));
	gtk_signal_connect(GTK_OBJECT(button), "clicked",
			   GTK_SIGNAL_FUNC(margin_default_set), NULL);
	return button;
}

static void
margin_default_set (GtkWidget *widget, void* data)
{
	LP_PAPER_CONF lp_paper;
	SPIN_PACK *mgx = (SPIN_PACK*)opt_address[P_MARGIN_X];
	SPIN_PACK *mgy = (SPIN_PACK*)opt_address[P_MARGIN_Y];

#ifdef ROLL_PAPER
	lp_paper = call_paper_conf ((char*)options[P_BIN],
				    (char*)options[P_MEDIA_SIZE]);
#else
	lp_paper = call_paper_conf ("",
				    (char*)options[P_MEDIA_SIZE]);
#endif /* ROLL_PAPER */
  
	gtk_adjustment_set_value (GTK_ADJUSTMENT(mgx->adj),
				  (gfloat)DOT_TO_MM(lp_paper->margin_x));
	gtk_adjustment_set_value (GTK_ADJUSTMENT(mgy->adj),
				  (gfloat)DOT_TO_MM(lp_paper->margin_y));
  
	return;
}

static void
margin_abjset (void)
{
	LP_PAPER_CONF lp_paper;
  
#ifdef ROLL_PAPER
	lp_paper = call_paper_conf ((char*)options[P_BIN],
				    (char*)options[P_MEDIA_SIZE]);
#else
	lp_paper = call_paper_conf ("",
				    (char*)options[P_MEDIA_SIZE]);
#endif /* ROLL_PAPER */
	margin_updata (P_MARGIN_X, lp_paper->margin_x, lp_paper->margin_x + lp_paper->area_x);
	margin_updata (P_MARGIN_Y, lp_paper->margin_y, lp_paper->margin_y + lp_paper->area_y);

	return;
}

static void
margin_updata (int id, long def, long max)
{
	GtkAdjustment *adj;  
	SPIN_PACK *mg = (SPIN_PACK*)opt_address[id];

	adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON(mg->spin));
	adj->upper = DOT_TO_MM(max)  - 1; /* マージン最大値を1mm少なく設定する */
	gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON(mg->spin), GTK_ADJUSTMENT(adj));
	if (*((int*)options[id]) > (DOT_TO_MM(max) - 1)) /* 同様にマージン最大値を少なく */
		gtk_adjustment_set_value (GTK_ADJUSTMENT(adj), (gfloat)DOT_TO_MM(def));

	return;
}
#endif /* CONV_VERSION2 */

#endif /* USE_GTK */