static SANE_Status
init_options (Ibm_Scanner * s)
{
int i;
DBG (11, ">> init_options\n");
memset (s->opt, 0, sizeof (s->opt));
memset (s->val, 0, sizeof (s->val));
for (i = 0; i < NUM_OPTIONS; ++i)
{
s->opt[i].size = sizeof (SANE_Word);
s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
}
s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
/* "Mode" group: */
s->opt[OPT_MODE_GROUP].title = "Scan Mode";
s->opt[OPT_MODE_GROUP].desc = "";
s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_MODE_GROUP].cap = 0;
s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* scan mode */
s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
s->opt[OPT_MODE].type = SANE_TYPE_STRING;
s->opt[OPT_MODE].size = max_string_size (mode_list);
s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
s->opt[OPT_MODE].constraint.string_list = mode_list;
s->val[OPT_MODE].s = strdup (mode_list[s->hw->info.image_mode_default]);
/* x resolution */
s->opt[OPT_X_RESOLUTION].name = "X" SANE_NAME_SCAN_RESOLUTION;
s->opt[OPT_X_RESOLUTION].title = "X " SANE_TITLE_SCAN_RESOLUTION;
s->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
s->opt[OPT_X_RESOLUTION].type = SANE_TYPE_INT;
s->opt[OPT_X_RESOLUTION].unit = SANE_UNIT_DPI;
s->opt[OPT_X_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_X_RESOLUTION].constraint.range = &ibm2456_res_range;
s->val[OPT_X_RESOLUTION].w = s->hw->info.xres_default;
/*
if (is50)
s->opt[OPT_X_RESOLUTION].constraint.range = &is50_res_range;
else
*/
s->opt[OPT_X_RESOLUTION].constraint.range = &ibm2456_res_range;
/* y resolution */
s->opt[OPT_Y_RESOLUTION].name = "Y" SANE_NAME_SCAN_RESOLUTION;
s->opt[OPT_Y_RESOLUTION].title = "Y " SANE_TITLE_SCAN_RESOLUTION;
s->opt[OPT_Y_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
s->opt[OPT_Y_RESOLUTION].type = SANE_TYPE_INT;
s->opt[OPT_Y_RESOLUTION].unit = SANE_UNIT_DPI;
s->opt[OPT_Y_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
s->val[OPT_Y_RESOLUTION].w = s->hw->info.yres_default;
s->opt[OPT_Y_RESOLUTION].constraint.range = &ibm2456_res_range;
/* adf */
s->opt[OPT_ADF].name = "adf";
s->opt[OPT_ADF].title = "Use ADF";
s->opt[OPT_ADF].desc = "Uses the automatic document feeder.";
s->opt[OPT_ADF].type = SANE_TYPE_BOOL;
s->opt[OPT_ADF].unit = SANE_UNIT_NONE;
s->opt[OPT_ADF].constraint_type = SANE_CONSTRAINT_NONE;
s->val[OPT_ADF].b = s->hw->info.adf_default;
/* "Geometry" group: */
s->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
s->opt[OPT_GEOMETRY_GROUP].desc = "";
s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* paper */
s->opt[OPT_PAPER].name = "paper";
s->opt[OPT_PAPER].title = "Paper format";
s->opt[OPT_PAPER].desc = "Sets the paper format.";
s->opt[OPT_PAPER].type = SANE_TYPE_STRING;
s->opt[OPT_PAPER].size = max_string_size (paper_list);
s->opt[OPT_PAPER].constraint_type = SANE_CONSTRAINT_STRING_LIST;
s->opt[OPT_PAPER].constraint.string_list = paper_list;
s->val[OPT_PAPER].s = strdup (paper_list[s->hw->info.paper_default]);
/* top-left x */
s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
s->opt[OPT_TL_X].type = SANE_TYPE_INT;
s->opt[OPT_TL_X].unit = SANE_UNIT_PIXEL;
s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_TL_X].constraint.range = &default_x_range;
s->val[OPT_TL_X].w = 0;
/* top-left y */
s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
s->opt[OPT_TL_Y].type = SANE_TYPE_INT;
s->opt[OPT_TL_Y].unit = SANE_UNIT_PIXEL;
s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_TL_Y].constraint.range = &default_y_range;
s->val[OPT_TL_Y].w = 0;
/* bottom-right x */
s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
s->opt[OPT_BR_X].type = SANE_TYPE_INT;
s->opt[OPT_BR_X].unit = SANE_UNIT_PIXEL;
s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BR_X].constraint.range = &default_x_range;
s->val[OPT_BR_X].w = default_x_range.max;
/* bottom-right y */
s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
s->opt[OPT_BR_Y].type = SANE_TYPE_INT;
s->opt[OPT_BR_Y].unit = SANE_UNIT_PIXEL;
s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BR_Y].constraint.range = &default_y_range;
s->val[OPT_BR_Y].w = default_y_range.max;
/* "Enhancement" group: */
s->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* brightness */
s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BRIGHTNESS].constraint.range = &u8_range;
s->val[OPT_BRIGHTNESS].w = s->hw->info.brightness_default;
/* contrast */
s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
s->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
s->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_CONTRAST].constraint.range = &u8_range;
s->val[OPT_CONTRAST].w = s->hw->info.contrast_default;
DBG (11, "<< init_options\n");
return SANE_STATUS_GOOD;
}
static SANE_Status
init_options (Tamarack_Scanner *s)
{
int i;
memset (s->opt, 0, sizeof (s->opt));
memset (s->val, 0, sizeof (s->val));
for (i = 0; i < NUM_OPTIONS; ++i) {
s->opt[i].size = sizeof (SANE_Word);
s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
}
s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
/* "Mode" group: */
s->opt[OPT_MODE_GROUP].title = "Scan Mode";
s->opt[OPT_MODE_GROUP].desc = "";
s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_MODE_GROUP].cap = 0;
s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* scan mode */
s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
s->opt[OPT_MODE].desc = "Select the scan mode";
s->opt[OPT_MODE].type = SANE_TYPE_STRING;
s->opt[OPT_MODE].size = max_string_size (mode_list);
s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
s->opt[OPT_MODE].constraint.string_list = mode_list;
s->val[OPT_MODE].s = strdup (mode_list[OPT_MODE_DEFAULT]);
/* resolution */
s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
s->opt[OPT_RESOLUTION].type = SANE_TYPE_FIXED;
s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_RESOLUTION].constraint.range = &s->hw->dpi_range;
s->val[OPT_RESOLUTION].w = SANE_FIX (OPT_RESOLUTION_DEFAULT);
/* preview */
s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
s->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
s->val[OPT_PREVIEW].w = 0;
/* gray preview */
s->opt[OPT_GRAY_PREVIEW].name = SANE_NAME_GRAY_PREVIEW;
s->opt[OPT_GRAY_PREVIEW].title = SANE_TITLE_GRAY_PREVIEW;
s->opt[OPT_GRAY_PREVIEW].desc = SANE_DESC_GRAY_PREVIEW;
s->opt[OPT_GRAY_PREVIEW].type = SANE_TYPE_BOOL;
s->val[OPT_GRAY_PREVIEW].w = SANE_FALSE;
/* "Geometry" group: */
s->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
s->opt[OPT_GEOMETRY_GROUP].desc = "";
s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* top-left x */
s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_TL_X].constraint.range = &s->hw->x_range;
s->val[OPT_TL_X].w = 0;
/* top-left y */
s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_TL_Y].constraint.range = &s->hw->y_range;
s->val[OPT_TL_Y].w = 0;
/* bottom-right x */
s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BR_X].constraint.range = &s->hw->x_range;
s->val[OPT_BR_X].w = s->hw->x_range.max;
/* bottom-right y */
s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BR_Y].constraint.range = &s->hw->y_range;
s->val[OPT_BR_Y].w = s->hw->y_range.max;
/* "Enhancement" group: */
s->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* transparency adapter. */
s->opt[OPT_TRANS].name = "transparency";
s->opt[OPT_TRANS].title = "transparency";
s->opt[OPT_TRANS].desc = "Turn on the transparency adapter.";
s->opt[OPT_TRANS].type = SANE_TYPE_BOOL;
s->opt[OPT_TRANS].unit = SANE_UNIT_NONE;
s->val[OPT_TRANS].w = SANE_FALSE;
/* brightness */
s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS
" This option is active for lineart/halftone modes only. "
"For multibit modes (grey/color) use the gamma-table(s).";
s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_FIXED;
s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_PERCENT;
s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BRIGHTNESS].constraint.range = &percentage_range;
s->val[OPT_BRIGHTNESS].w = SANE_FIX(0);
/* contrast */
s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST
" This option is active for lineart/halftone modes only. "
"For multibit modes (grey/color) use the gamma-table(s).";
s->opt[OPT_CONTRAST].type = SANE_TYPE_FIXED;
s->opt[OPT_CONTRAST].unit = SANE_UNIT_PERCENT;
s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_CONTRAST].constraint.range = &percentage_range;
s->val[OPT_CONTRAST].w = SANE_FIX(0);
/* Threshold */
s->opt[OPT_THRESHOLD].name = "Threshold";
s->opt[OPT_THRESHOLD].title = "Threshold";
s->opt[OPT_THRESHOLD].desc = "Threshold: below this level is black, above is white"
" This option is active for bitmap modes only. ";
s->opt[OPT_THRESHOLD].type = SANE_TYPE_FIXED;
s->opt[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT;
s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_THRESHOLD].constraint.range = &abs_percentage_range;
s->val[OPT_THRESHOLD].w = SANE_FIX(50);
s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
#if 0
/* custom-gamma table */
s->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
s->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
s->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
s->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
s->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
/* grayscale gamma vector */
s->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
s->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
s->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
s->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT;
s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE;
s->opt[OPT_GAMMA_VECTOR].size = 256 * sizeof (SANE_Word);
s->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_GAMMA_VECTOR].constraint.range = &u8_range;
s->val[OPT_GAMMA_VECTOR].wa = &s->gamma_table[0][0];
/* red gamma vector */
s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
s->opt[OPT_GAMMA_VECTOR_R].size = 256 * sizeof (SANE_Word);
s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
s->val[OPT_GAMMA_VECTOR_R].wa = &s->gamma_table[1][0];
/* green gamma vector */
s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
s->opt[OPT_GAMMA_VECTOR_G].size = 256 * sizeof (SANE_Word);
s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
s->val[OPT_GAMMA_VECTOR_G].wa = &s->gamma_table[2][0];
/* blue gamma vector */
s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
s->opt[OPT_GAMMA_VECTOR_B].size = 256 * sizeof (SANE_Word);
s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
s->val[OPT_GAMMA_VECTOR_B].wa = &s->gamma_table[3][0];
#endif
return SANE_STATUS_GOOD;
}
static SANE_Status
attach (SANE_String_Const devname)
{
struct device_s *dev;
dev = malloc (sizeof (struct device_s));
if (!dev)
return SANE_STATUS_NO_MEM;
memset (dev, 0, sizeof (struct device_s));
dev->devname = devname;
DBG(1,"New device found: %s\n",dev->devname);
/* Init the whole structure with default values */
/* Number of options */
dev->optiond[0].name = "";
dev->optiond[0].title = NULL;
dev->optiond[0].desc = NULL;
dev->optiond[0].type = SANE_TYPE_INT;
dev->optiond[0].unit = SANE_UNIT_NONE;
dev->optiond[0].size = sizeof (SANE_Word);
dev->optionw[0] = OPTION_MAX;
/* resolution */
dev->optiond[RES_OFFSET].name = "resolution";
dev->optiond[RES_OFFSET].title = "resolution";
dev->optiond[RES_OFFSET].desc = "resolution";
dev->optiond[RES_OFFSET].type = SANE_TYPE_INT;
dev->optiond[RES_OFFSET].unit = SANE_UNIT_DPI;
dev->optiond[RES_OFFSET].type = SANE_TYPE_INT;
dev->optiond[RES_OFFSET].size = sizeof (SANE_Word);
dev->optiond[RES_OFFSET].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
dev->optiond[RES_OFFSET].constraint_type = SANE_CONSTRAINT_WORD_LIST;
dev->optiond[RES_OFFSET].constraint.word_list = resolution_list;
dev->optionw[RES_OFFSET] = 75;
/* scan area */
dev->optiond[X1_OFFSET].name = "tl-x";
dev->optiond[X1_OFFSET].title = "tl-x";
dev->optiond[X1_OFFSET].desc = "tl-x";
dev->optiond[X1_OFFSET].type = SANE_TYPE_INT;
dev->optiond[X1_OFFSET].unit = SANE_UNIT_MM;
dev->optiond[X1_OFFSET].size = sizeof (SANE_Word);
dev->optiond[X1_OFFSET].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
dev->optiond[X1_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
dev->optiond[X1_OFFSET].constraint.range = &range_x;
dev->optionw[X1_OFFSET] = 0;
dev->optiond[Y1_OFFSET].name = "tl-y";
dev->optiond[Y1_OFFSET].title = "tl-y";
dev->optiond[Y1_OFFSET].desc = "tl-y";
dev->optiond[Y1_OFFSET].type = SANE_TYPE_INT;
dev->optiond[Y1_OFFSET].unit = SANE_UNIT_MM;
dev->optiond[Y1_OFFSET].size = sizeof (SANE_Word);
dev->optiond[Y1_OFFSET].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
dev->optiond[Y1_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
dev->optiond[Y1_OFFSET].constraint.range = &range_y;
dev->optionw[Y1_OFFSET] = 0;
dev->optiond[X2_OFFSET].name = "br-x";
dev->optiond[X2_OFFSET].title = "br-x";
dev->optiond[X2_OFFSET].desc = "br-x";
dev->optiond[X2_OFFSET].type = SANE_TYPE_INT;
dev->optiond[X2_OFFSET].unit = SANE_UNIT_MM;
dev->optiond[X2_OFFSET].size = sizeof (SANE_Word);
dev->optiond[X2_OFFSET].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
dev->optiond[X2_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
dev->optiond[X2_OFFSET].constraint.range = &range_x;
dev->optionw[X2_OFFSET] = MAX_X_S;
dev->optiond[Y2_OFFSET].name = "br-y";
dev->optiond[Y2_OFFSET].title = "br-y";
dev->optiond[Y2_OFFSET].desc = "br-y";
dev->optiond[Y2_OFFSET].type = SANE_TYPE_INT;
dev->optiond[Y2_OFFSET].unit = SANE_UNIT_MM;
dev->optiond[Y2_OFFSET].size = sizeof (SANE_Word);
dev->optiond[Y2_OFFSET].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
dev->optiond[Y2_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
dev->optiond[Y2_OFFSET].constraint.range = &range_y;
dev->optionw[Y2_OFFSET] = MAX_Y_S;
/* brightness */
dev->optiond[BRIGH_OFFSET].name = "brightness";
dev->optiond[BRIGH_OFFSET].title = "Brightness";
dev->optiond[BRIGH_OFFSET].desc = "Set the brightness";
dev->optiond[BRIGH_OFFSET].type = SANE_TYPE_INT;
dev->optiond[BRIGH_OFFSET].unit = SANE_UNIT_NONE;
dev->optiond[BRIGH_OFFSET].size = sizeof (SANE_Word);
dev->optiond[BRIGH_OFFSET].cap =
SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
dev->optiond[BRIGH_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
dev->optiond[BRIGH_OFFSET].constraint.range = &range_br_cont;
dev->optionw[BRIGH_OFFSET] = 0x6;
/* contrast */
dev->optiond[CONTR_OFFSET].name = "contrast";
dev->optiond[CONTR_OFFSET].title = "Contrast";
dev->optiond[CONTR_OFFSET].desc = "Set the contrast";
dev->optiond[CONTR_OFFSET].type = SANE_TYPE_INT;
dev->optiond[CONTR_OFFSET].unit = SANE_UNIT_NONE;
dev->optiond[CONTR_OFFSET].size = sizeof (SANE_Word);
dev->optiond[CONTR_OFFSET].cap =
SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
dev->optiond[CONTR_OFFSET].constraint_type = SANE_CONSTRAINT_RANGE;
dev->optiond[CONTR_OFFSET].constraint.range = &range_br_cont;
dev->optionw[CONTR_OFFSET] = 0x6;
/* Color */
dev->optiond[COLOR_OFFSET].name = SANE_NAME_SCAN_MODE;
dev->optiond[COLOR_OFFSET].title = SANE_TITLE_SCAN_MODE;
dev->optiond[COLOR_OFFSET].desc = SANE_DESC_SCAN_MODE;
dev->optiond[COLOR_OFFSET].type = SANE_TYPE_STRING;
dev->optiond[COLOR_OFFSET].size = max_string_size (mode_list);
dev->optiond[COLOR_OFFSET].cap =
SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
dev->optiond[COLOR_OFFSET].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->optiond[COLOR_OFFSET].constraint.string_list = mode_list;
dev->optionw[COLOR_OFFSET] = RGB;
dev->dn = 0;
dev->idx = cur_idx;
dev->status = STATUS_IDLE;
dev->next = devlist_head;
devlist_head = dev;
devlist_count++;
return SANE_STATUS_GOOD;
}
/* Reset the options for that scanner. */
static void
leo_init_options (Leo_Scanner * dev)
{
int i;
/* Pre-initialize the options. */
memset (dev->opt, 0, sizeof (dev->opt));
memset (dev->val, 0, sizeof (dev->val));
for (i = 0; i < OPT_NUM_OPTIONS; ++i)
{
dev->opt[i].size = sizeof (SANE_Word);
dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
}
/* Number of options. */
dev->opt[OPT_NUM_OPTS].name = "";
dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS;
/* Mode group */
dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan mode");
dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */
dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
dev->opt[OPT_MODE_GROUP].cap = 0;
dev->opt[OPT_MODE_GROUP].size = 0;
dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* Scanner supported modes */
dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
dev->opt[OPT_MODE].size = max_string_size (scan_mode_list);
dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_MODE].constraint.string_list = scan_mode_list;
dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */
/* X and Y resolution */
dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_RESOLUTION].constraint.range = &dev->res_range;
dev->val[OPT_RESOLUTION].w = dev->res_range.max / 2;
/* Halftone pattern */
dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING;
dev->opt[OPT_HALFTONE_PATTERN].size =
max_string_size (halftone_pattern_list);
dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_HALFTONE_PATTERN].constraint_type =
SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list =
halftone_pattern_list;
dev->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]);
/* Geometry group */
dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */
dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
dev->opt[OPT_GEOMETRY_GROUP].cap = 0;
dev->opt[OPT_GEOMETRY_GROUP].size = 0;
dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* Upper left X */
dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
dev->opt[OPT_TL_X].unit = SANE_UNIT_MM;
dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_TL_X].constraint.range = &x_range;
dev->val[OPT_TL_X].w = x_range.min;
/* Upper left Y */
dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_TL_Y].constraint.range = &y_range;
dev->val[OPT_TL_Y].w = y_range.min;
/* Bottom-right x */
dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
dev->opt[OPT_BR_X].unit = SANE_UNIT_MM;
dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_BR_X].constraint.range = &x_range;
dev->val[OPT_BR_X].w = x_range.max;
/* Bottom-right y */
dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_BR_Y].constraint.range = &y_range;
dev->val[OPT_BR_Y].w = y_range.max;
/* Enhancement group */
dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */
dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED;
dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* custom-gamma table */
dev->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
dev->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
dev->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
dev->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
dev->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
/* red gamma vector */
dev->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
dev->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
dev->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
dev->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
dev->opt[OPT_GAMMA_VECTOR_R].size = GAMMA_LENGTH * sizeof (SANE_Word);
dev->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range;
dev->val[OPT_GAMMA_VECTOR_R].wa = dev->gamma_R;
/* green gamma vector */
dev->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
dev->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
dev->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
dev->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
dev->opt[OPT_GAMMA_VECTOR_G].size = GAMMA_LENGTH * sizeof (SANE_Word);
dev->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range;
dev->val[OPT_GAMMA_VECTOR_G].wa = dev->gamma_G;
/* blue gamma vector */
dev->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
dev->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
dev->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
dev->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
dev->opt[OPT_GAMMA_VECTOR_B].size = GAMMA_LENGTH * sizeof (SANE_Word);
dev->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range;
dev->val[OPT_GAMMA_VECTOR_B].wa = dev->gamma_B;
/* grayscale gamma vector */
dev->opt[OPT_GAMMA_VECTOR_GRAY].name = SANE_NAME_GAMMA_VECTOR;
dev->opt[OPT_GAMMA_VECTOR_GRAY].title = SANE_TITLE_GAMMA_VECTOR;
dev->opt[OPT_GAMMA_VECTOR_GRAY].desc = SANE_DESC_GAMMA_VECTOR;
dev->opt[OPT_GAMMA_VECTOR_GRAY].type = SANE_TYPE_INT;
dev->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GAMMA_VECTOR_GRAY].unit = SANE_UNIT_NONE;
dev->opt[OPT_GAMMA_VECTOR_GRAY].size = GAMMA_LENGTH * sizeof (SANE_Word);
dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GAMMA_VECTOR_GRAY].constraint.range = &gamma_range;
dev->val[OPT_GAMMA_VECTOR_GRAY].wa = dev->gamma_GRAY;
/* preview */
dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
dev->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
dev->val[OPT_PREVIEW].w = SANE_FALSE;
/* Lastly, set the default scan mode. This might change some
* values previously set here. */
sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE,
(SANE_String_Const *) scan_mode_list[0], NULL);
}
/* Reset the options for that scanner. */
void
kv_init_options (PKV_DEV dev)
{
int i;
if (dev->option_set)
return;
DBG (DBG_proc, "kv_init_options: enter\n");
/* Pre-initialize the options. */
memset (dev->opt, 0, sizeof (dev->opt));
memset (dev->val, 0, sizeof (dev->val));
for (i = 0; i < OPT_NUM_OPTIONS; ++i)
{
dev->opt[i].size = sizeof (SANE_Word);
dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
}
/* Number of options. */
dev->opt[OPT_NUM_OPTS].name = "";
dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS;
/* Mode group */
dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */
dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
dev->opt[OPT_MODE_GROUP].cap = 0;
dev->opt[OPT_MODE_GROUP].size = 0;
dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* Scanner supported modes */
dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
dev->opt[OPT_MODE].size = max_string_size (go_scan_mode_list);
dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_MODE].constraint.string_list = go_scan_mode_list;
dev->val[OPT_MODE].s = strdup (""); /* will be set later */
/* X and Y resolution */
dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
dev->opt[OPT_RESOLUTION].constraint.word_list = go_resolutions_list;
dev->val[OPT_RESOLUTION].w = go_resolutions_list[3];
/* Duplex */
dev->opt[OPT_DUPLEX].name = SANE_NAME_DUPLEX;
dev->opt[OPT_DUPLEX].title = SANE_TITLE_DUPLEX;
dev->opt[OPT_DUPLEX].desc = SANE_DESC_DUPLEX;
dev->opt[OPT_DUPLEX].type = SANE_TYPE_BOOL;
dev->opt[OPT_DUPLEX].unit = SANE_UNIT_NONE;
dev->val[OPT_DUPLEX].w = SANE_FALSE;
if (!dev->support_info.support_duplex)
dev->opt[OPT_DUPLEX].cap |= SANE_CAP_INACTIVE;
/* Scan source */
dev->opt[OPT_SCAN_SOURCE].name = SANE_NAME_SCAN_SOURCE;
dev->opt[OPT_SCAN_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
dev->opt[OPT_SCAN_SOURCE].desc = SANE_I18N ("Sets the scan source");
dev->opt[OPT_SCAN_SOURCE].type = SANE_TYPE_STRING;
dev->opt[OPT_SCAN_SOURCE].size = max_string_size (go_scan_source_list);
dev->opt[OPT_SCAN_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_SCAN_SOURCE].constraint.string_list = go_scan_source_list;
dev->val[OPT_SCAN_SOURCE].s = strdup (go_scan_source_list[0]);
dev->opt[OPT_SCAN_SOURCE].cap &= ~SANE_CAP_SOFT_SELECT;
/* for KV-S1020C / KV-S1025C, scan source is fixed to ADF */
/* Feeder mode */
dev->opt[OPT_FEEDER_MODE].name = "feeder-mode";
dev->opt[OPT_FEEDER_MODE].title = SANE_I18N ("Feeder mode");
dev->opt[OPT_FEEDER_MODE].desc = SANE_I18N ("Sets the feeding mode");
dev->opt[OPT_FEEDER_MODE].type = SANE_TYPE_STRING;
dev->opt[OPT_FEEDER_MODE].size = max_string_size (go_feeder_mode_list);
dev->opt[OPT_FEEDER_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_FEEDER_MODE].constraint.string_list = go_feeder_mode_list;
dev->val[OPT_FEEDER_MODE].s = strdup (go_feeder_mode_list[1]);
/* Long paper */
dev->opt[OPT_LONGPAPER].name = SANE_NAME_LONGPAPER;
dev->opt[OPT_LONGPAPER].title = SANE_TITLE_LONGPAPER;
dev->opt[OPT_LONGPAPER].desc = SANE_I18N ("Enable/Disable long paper mode");
dev->opt[OPT_LONGPAPER].type = SANE_TYPE_BOOL;
dev->opt[OPT_LONGPAPER].unit = SANE_UNIT_NONE;
dev->val[OPT_LONGPAPER].w = SANE_FALSE;
/* Length control */
dev->opt[OPT_LENGTHCTL].name = SANE_NAME_LENGTHCTL;
dev->opt[OPT_LENGTHCTL].title = SANE_TITLE_LENGTHCTL;
dev->opt[OPT_LENGTHCTL].desc =
SANE_I18N ("Enable/Disable length control mode");
dev->opt[OPT_LENGTHCTL].type = SANE_TYPE_BOOL;
dev->opt[OPT_LENGTHCTL].unit = SANE_UNIT_NONE;
dev->val[OPT_LENGTHCTL].w = SANE_TRUE;
/* Manual feed */
dev->opt[OPT_MANUALFEED].name = SANE_NAME_MANUALFEED;
dev->opt[OPT_MANUALFEED].title = SANE_TITLE_MANUALFEED;
dev->opt[OPT_MANUALFEED].desc = SANE_I18N ("Sets the manual feed mode");
dev->opt[OPT_MANUALFEED].type = SANE_TYPE_STRING;
dev->opt[OPT_MANUALFEED].size = max_string_size (go_manual_feed_list);
dev->opt[OPT_MANUALFEED].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_MANUALFEED].constraint.string_list = go_manual_feed_list;
dev->val[OPT_MANUALFEED].s = strdup (go_manual_feed_list[0]);
/*Manual feed timeout */
dev->opt[OPT_FEED_TIMEOUT].name = SANE_NAME_FEED_TIMEOUT;
dev->opt[OPT_FEED_TIMEOUT].title = SANE_TITLE_FEED_TIMEOUT;
dev->opt[OPT_FEED_TIMEOUT].desc =
SANE_I18N ("Sets the manual feed timeout in seconds");
dev->opt[OPT_FEED_TIMEOUT].type = SANE_TYPE_INT;
dev->opt[OPT_FEED_TIMEOUT].unit = SANE_UNIT_NONE;
dev->opt[OPT_FEED_TIMEOUT].size = sizeof (SANE_Int);
dev->opt[OPT_FEED_TIMEOUT].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_FEED_TIMEOUT].constraint.range = &(go_value_range);
dev->opt[OPT_FEED_TIMEOUT].cap |= SANE_CAP_INACTIVE;
dev->val[OPT_FEED_TIMEOUT].w = 30;
/* Double feed */
dev->opt[OPT_DBLFEED].name = SANE_NAME_DBLFEED;
dev->opt[OPT_DBLFEED].title = SANE_TITLE_DBLFEED;
dev->opt[OPT_DBLFEED].desc =
SANE_I18N ("Enable/Disable double feed detection");
dev->opt[OPT_DBLFEED].type = SANE_TYPE_BOOL;
dev->opt[OPT_DBLFEED].unit = SANE_UNIT_NONE;
dev->val[OPT_DBLFEED].w = SANE_FALSE;
/* Fit to page */
dev->opt[OPT_FIT_TO_PAGE].name = SANE_I18N ("fit-to-page");
dev->opt[OPT_FIT_TO_PAGE].title = SANE_I18N ("Fit to page");
dev->opt[OPT_FIT_TO_PAGE].desc =
SANE_I18N ("Scanner shrinks image to fit scanned page");
dev->opt[OPT_FIT_TO_PAGE].type = SANE_TYPE_BOOL;
dev->opt[OPT_FIT_TO_PAGE].unit = SANE_UNIT_NONE;
dev->val[OPT_FIT_TO_PAGE].w = SANE_FALSE;
/* Geometry group */
dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */
dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
dev->opt[OPT_GEOMETRY_GROUP].cap = 0;
dev->opt[OPT_GEOMETRY_GROUP].size = 0;
dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* Paper sizes list */
dev->opt[OPT_PAPER_SIZE].name = SANE_NAME_PAPER_SIZE;
dev->opt[OPT_PAPER_SIZE].title = SANE_TITLE_PAPER_SIZE;
dev->opt[OPT_PAPER_SIZE].desc = SANE_DESC_PAPER_SIZE;
dev->opt[OPT_PAPER_SIZE].type = SANE_TYPE_STRING;
dev->opt[OPT_PAPER_SIZE].size = max_string_size (go_paper_list);
dev->opt[OPT_PAPER_SIZE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_PAPER_SIZE].constraint.string_list = go_paper_list;
dev->val[OPT_PAPER_SIZE].s = strdup (""); /* will be set later */
/* Landscape */
dev->opt[OPT_LANDSCAPE].name = SANE_NAME_LANDSCAPE;
dev->opt[OPT_LANDSCAPE].title = SANE_TITLE_LANDSCAPE;
dev->opt[OPT_LANDSCAPE].desc =
SANE_I18N ("Set paper position : "
"true for landscape, false for portrait");
dev->opt[OPT_LANDSCAPE].type = SANE_TYPE_BOOL;
dev->opt[OPT_LANDSCAPE].unit = SANE_UNIT_NONE;
dev->val[OPT_LANDSCAPE].w = SANE_FALSE;
/* Upper left X */
dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
dev->opt[OPT_TL_X].unit = SANE_UNIT_MM;
dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_TL_X].constraint.range = &(dev->x_range);
/* Upper left Y */
dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_TL_Y].constraint.range = &(dev->y_range);
/* Bottom-right x */
dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
dev->opt[OPT_BR_X].unit = SANE_UNIT_MM;
dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_BR_X].constraint.range = &(dev->x_range);
/* Bottom-right y */
dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_BR_Y].constraint.range = &(dev->y_range);
/* Enhancement group */
dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */
dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED;
dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* Brightness */
dev->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
dev->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
dev->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
dev->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
dev->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
dev->opt[OPT_BRIGHTNESS].size = sizeof (SANE_Int);
dev->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_BRIGHTNESS].constraint.range = &(go_value_range);
dev->val[OPT_BRIGHTNESS].w = 128;
/* Contrast */
dev->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
dev->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
dev->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
dev->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
dev->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
dev->opt[OPT_CONTRAST].size = sizeof (SANE_Int);
dev->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_CONTRAST].constraint.range = &(go_value_range);
dev->val[OPT_CONTRAST].w = 128;
/* Automatic threshold */
dev->opt[OPT_AUTOMATIC_THRESHOLD].name = "automatic-threshold";
dev->opt[OPT_AUTOMATIC_THRESHOLD].title = SANE_I18N ("Automatic threshold");
dev->opt[OPT_AUTOMATIC_THRESHOLD].desc =
SANE_I18N
("Automatically sets brightness, contrast, white level, "
"gamma, noise reduction and image emphasis");
dev->opt[OPT_AUTOMATIC_THRESHOLD].type = SANE_TYPE_STRING;
dev->opt[OPT_AUTOMATIC_THRESHOLD].size =
max_string_size (go_automatic_threshold_list);
dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint_type =
SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint.string_list =
go_automatic_threshold_list;
dev->val[OPT_AUTOMATIC_THRESHOLD].s =
strdup (go_automatic_threshold_list[0]);
/* Halftone pattern */
dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING;
dev->opt[OPT_HALFTONE_PATTERN].size =
max_string_size (go_halftone_pattern_list);
dev->opt[OPT_HALFTONE_PATTERN].constraint_type =
SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list =
go_halftone_pattern_list;
dev->val[OPT_HALFTONE_PATTERN].s = strdup (go_halftone_pattern_list[0]);
/* Automatic separation */
dev->opt[OPT_AUTOMATIC_SEPARATION].name = SANE_NAME_AUTOSEP;
dev->opt[OPT_AUTOMATIC_SEPARATION].title = SANE_TITLE_AUTOSEP;
dev->opt[OPT_AUTOMATIC_SEPARATION].desc = SANE_DESC_AUTOSEP;
dev->opt[OPT_AUTOMATIC_SEPARATION].type = SANE_TYPE_BOOL;
dev->opt[OPT_AUTOMATIC_SEPARATION].unit = SANE_UNIT_NONE;
dev->val[OPT_AUTOMATIC_SEPARATION].w = SANE_FALSE;
/* White level base */
dev->opt[OPT_WHITE_LEVEL].name = SANE_NAME_WHITE_LEVEL;
dev->opt[OPT_WHITE_LEVEL].title = SANE_TITLE_WHITE_LEVEL;
dev->opt[OPT_WHITE_LEVEL].desc = SANE_DESC_WHITE_LEVEL;
dev->opt[OPT_WHITE_LEVEL].type = SANE_TYPE_STRING;
dev->opt[OPT_WHITE_LEVEL].size = max_string_size (go_white_level_list);
dev->opt[OPT_WHITE_LEVEL].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_WHITE_LEVEL].constraint.string_list = go_white_level_list;
dev->val[OPT_WHITE_LEVEL].s = strdup (go_white_level_list[0]);
/* Noise reduction */
dev->opt[OPT_NOISE_REDUCTION].name = "noise-reduction";
dev->opt[OPT_NOISE_REDUCTION].title = SANE_I18N ("Noise reduction");
dev->opt[OPT_NOISE_REDUCTION].desc =
SANE_I18N ("Reduce the isolated dot noise");
dev->opt[OPT_NOISE_REDUCTION].type = SANE_TYPE_STRING;
dev->opt[OPT_NOISE_REDUCTION].size =
max_string_size (go_noise_reduction_list);
dev->opt[OPT_NOISE_REDUCTION].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_NOISE_REDUCTION].constraint.string_list =
go_noise_reduction_list;
dev->val[OPT_NOISE_REDUCTION].s = strdup (go_noise_reduction_list[0]);
/* Image emphasis */
dev->opt[OPT_IMAGE_EMPHASIS].name = "image-emphasis";
dev->opt[OPT_IMAGE_EMPHASIS].title = SANE_I18N ("Image emphasis");
dev->opt[OPT_IMAGE_EMPHASIS].desc = SANE_I18N ("Sets the image emphasis");
dev->opt[OPT_IMAGE_EMPHASIS].type = SANE_TYPE_STRING;
dev->opt[OPT_IMAGE_EMPHASIS].size =
max_string_size (go_image_emphasis_list);
dev->opt[OPT_IMAGE_EMPHASIS].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_IMAGE_EMPHASIS].constraint.string_list =
go_image_emphasis_list;
dev->val[OPT_IMAGE_EMPHASIS].s = strdup (SANE_I18N ("medium"));
/* Gamma */
dev->opt[OPT_GAMMA].name = "gamma";
dev->opt[OPT_GAMMA].title = SANE_I18N ("Gamma");
dev->opt[OPT_GAMMA].desc = SANE_I18N ("Gamma");
dev->opt[OPT_GAMMA].type = SANE_TYPE_STRING;
dev->opt[OPT_GAMMA].size = max_string_size (go_gamma_list);
dev->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_GAMMA].constraint.string_list = go_gamma_list;
dev->val[OPT_GAMMA].s = strdup (go_gamma_list[0]);
/* Lamp color dropout */
dev->opt[OPT_LAMP].name = "lamp-color";
dev->opt[OPT_LAMP].title = SANE_I18N ("Lamp color");
dev->opt[OPT_LAMP].desc = SANE_I18N ("Sets the lamp color (color dropout)");
dev->opt[OPT_LAMP].type = SANE_TYPE_STRING;
dev->opt[OPT_LAMP].size = max_string_size (go_lamp_list);
dev->opt[OPT_LAMP].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_LAMP].constraint.string_list = go_lamp_list;
dev->val[OPT_LAMP].s = strdup (go_lamp_list[0]);
if (!dev->support_info.support_lamp)
dev->opt[OPT_LAMP].cap |= SANE_CAP_INACTIVE;
/* Inverse image */
dev->opt[OPT_INVERSE].name = SANE_NAME_INVERSE;
dev->opt[OPT_INVERSE].title = SANE_TITLE_INVERSE;
dev->opt[OPT_INVERSE].desc =
SANE_I18N ("Inverse image in B/W or halftone mode");
dev->opt[OPT_INVERSE].type = SANE_TYPE_BOOL;
dev->opt[OPT_INVERSE].unit = SANE_UNIT_NONE;
dev->val[OPT_INVERSE].w = SANE_FALSE;
/* Mirror image (left/right flip) */
dev->opt[OPT_MIRROR].name = SANE_NAME_MIRROR;
dev->opt[OPT_MIRROR].title = SANE_TITLE_MIRROR;
dev->opt[OPT_MIRROR].desc = SANE_I18N ("Mirror image (left/right flip)");
dev->opt[OPT_MIRROR].type = SANE_TYPE_BOOL;
dev->opt[OPT_MIRROR].unit = SANE_UNIT_NONE;
dev->val[OPT_MIRROR].w = SANE_FALSE;
/* JPEG Image Compression */
dev->opt[OPT_JPEG].name = "jpeg";
dev->opt[OPT_JPEG].title = SANE_I18N ("jpeg compression");
dev->opt[OPT_JPEG].desc =
SANE_I18N
("JPEG Image Compression with Q parameter, '0' - no compression");
dev->opt[OPT_JPEG].type = SANE_TYPE_INT;
dev->opt[OPT_JPEG].unit = SANE_UNIT_NONE;
dev->opt[OPT_JPEG].size = sizeof (SANE_Int);
dev->opt[OPT_JPEG].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_JPEG].constraint.range = &(go_jpeg_compression_range);
dev->val[OPT_JPEG].w = 0;
/* Lastly, set the default scan mode. This might change some
* values previously set here. */
sane_control_option (dev, OPT_PAPER_SIZE, SANE_ACTION_SET_VALUE,
(void *) go_paper_list[default_paper_size_idx], NULL);
sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE,
(void *) go_scan_mode_list[0], NULL);
DBG (DBG_proc, "kv_init_options: exit\n");
dev->option_set = 1;
}
/* Reset the options for that scanner. */
void
kvs40xx_init_options (struct scanner *s)
{
int i;
SANE_Option_Descriptor *o;
/* Pre-initialize the options. */
memset (s->opt, 0, sizeof (s->opt));
memset (s->val, 0, sizeof (s->val));
for (i = 0; i < NUM_OPTIONS; i++)
{
s->opt[i].size = sizeof (SANE_Word);
s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
}
/* Number of options. */
o = &s->opt[NUM_OPTS];
o->name = "";
o->title = SANE_TITLE_NUM_OPTIONS;
o->desc = SANE_DESC_NUM_OPTIONS;
o->type = SANE_TYPE_INT;
o->cap = SANE_CAP_SOFT_DETECT;
s->val[NUM_OPTS].w = NUM_OPTIONS;
/* Mode group */
o = &s->opt[MODE_GROUP];
o->title = SANE_I18N ("Scan Mode");
o->desc = ""; /* not valid for a group */
o->type = SANE_TYPE_GROUP;
o->cap = 0;
o->size = 0;
o->constraint_type = SANE_CONSTRAINT_NONE;
/* Scanner supported modes */
o = &s->opt[MODE];
o->name = SANE_NAME_SCAN_MODE;
o->title = SANE_TITLE_SCAN_MODE;
o->desc = SANE_DESC_SCAN_MODE;
o->type = SANE_TYPE_STRING;
o->size = max_string_size (mode_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = mode_list;
s->val[MODE].s = malloc (o->size);
strcpy (s->val[MODE].s, mode_list[2]);
/* X and Y resolution */
o = &s->opt[RESOLUTION];
o->name = SANE_NAME_SCAN_RESOLUTION;
o->title = SANE_TITLE_SCAN_RESOLUTION;
o->desc = SANE_DESC_SCAN_RESOLUTION;
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_DPI;
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range = &resolutions_range;
s->val[RESOLUTION].w = 100;
/* Duplex */
o = &s->opt[DUPLEX];
o->name = "duplex";
o->title = SANE_I18N ("Duplex");
o->desc = SANE_I18N ("Enable Duplex (Dual-Sided) Scanning");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[DUPLEX].w = SANE_FALSE;
/*FIXME
if (!s->support_info.support_duplex)
o->cap |= SANE_CAP_INACTIVE;
*/
/* Feeder mode */
o = &s->opt[FEEDER_MODE];
o->name = "feeder-mode";
o->title = SANE_I18N ("Feeder mode");
o->desc = SANE_I18N ("Sets the feeding mode");
o->type = SANE_TYPE_STRING;
o->size = max_string_size (feeder_mode_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = feeder_mode_list;
s->val[FEEDER_MODE].s = malloc (o->size);
strcpy (s->val[FEEDER_MODE].s, feeder_mode_list[0]);
/* Scan source */
o = &s->opt[SOURCE];
o->name = SANE_NAME_SCAN_SOURCE;
o->title = SANE_TITLE_SCAN_SOURCE;
o->desc = SANE_DESC_SCAN_SOURCE;
o->type = SANE_TYPE_STRING;
o->size = max_string_size (source_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = source_list;
s->val[SOURCE].s = malloc (o->size);
strcpy (s->val[SOURCE].s, source_list[0]);
if (s->id != KV_S7075C)
o->cap |= SANE_CAP_INACTIVE;
/* Length control */
o = &s->opt[LENGTHCTL];
o->name = "length-control";
o->title = SANE_I18N ("Length control mode");
o->desc =
SANE_I18N
("Length Control Mode is a mode that the scanner reads up to the shorter length of actual"
" paper or logical document length.");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[LENGTHCTL].w = SANE_FALSE;
o = &s->opt[LONG_PAPER];
o->name = "long-paper";
o->title = SANE_I18N ("Long paper mode");
o->desc = SANE_I18N ("Long Paper Mode is a mode that the scanner "
"reads the image after it divides long paper "
"by the length which is set in Document Size option.");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[LONG_PAPER].w = SANE_FALSE;
o->cap |= SANE_CAP_INACTIVE;
/* Manual feed */
o = &s->opt[MANUALFEED];
o->name = "manual-feed";
o->title = SANE_I18N ("Manual feed mode");
o->desc = SANE_I18N ("Sets the manual feed mode");
o->type = SANE_TYPE_STRING;
o->size = max_string_size (manual_feed_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = manual_feed_list;
s->val[MANUALFEED].s = malloc (o->size);
strcpy (s->val[MANUALFEED].s, manual_feed_list[0]);
/*Manual feed timeout */
o = &s->opt[FEED_TIMEOUT];
o->name = "feed-timeout";
o->title = SANE_I18N ("Manual feed timeout");
o->desc = SANE_I18N ("Sets the manual feed timeout in seconds");
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_NONE;
o->size = sizeof (SANE_Int);
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range = &(byte_value_range);
o->cap |= SANE_CAP_INACTIVE;
s->val[FEED_TIMEOUT].w = 30;
/* Double feed */
o = &s->opt[DBLFEED];
o->name = "dfeed";
o->title = SANE_I18N ("Double feed detection");
o->desc = SANE_I18N ("Enable/Disable double feed detection");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[DBLFEED].w = SANE_FALSE;
o = &s->opt[DFEED_SENCE];
o->name = "dfeed-sense";
o->title = SANE_I18N ("Double feed detector sensitivity");
o->desc = SANE_I18N ("Set the double feed detector sensitivity");
o->type = SANE_TYPE_STRING;
o->size = max_string_size (dfeed_sence_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = dfeed_sence_list;
s->val[DFEED_SENCE].s = malloc (o->size);
strcpy (s->val[DFEED_SENCE].s, dfeed_sence_list[0]);
o->cap |= SANE_CAP_INACTIVE;
o = &s->opt[DFSTOP];
o->name = "dfstop";
o->title = SANE_I18N ("Do not stop after double feed detection");
o->desc = SANE_I18N ("Do not stop after double feed detection");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[DFSTOP].w = SANE_FALSE;
o->cap |= SANE_CAP_INACTIVE;
o = &s->opt[DFEED_L];
o->name = "dfeed_l";
o->title = SANE_I18N ("Ignore left double feed sensor");
o->desc = SANE_I18N ("Ignore left double feed sensor");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[DFEED_L].w = SANE_FALSE;
o->cap |= SANE_CAP_INACTIVE;
o = &s->opt[DFEED_C];
o->name = "dfeed_c";
o->title = SANE_I18N ("Ignore center double feed sensor");
o->desc = SANE_I18N ("Ignore center double feed sensor");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[DFEED_C].w = SANE_FALSE;
o->cap |= SANE_CAP_INACTIVE;
o = &s->opt[DFEED_R];
o->name = "dfeed_r";
o->title = SANE_I18N ("Ignore right double feed sensor");
o->desc = SANE_I18N ("Ignore right double feed sensor");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[DFEED_R].w = SANE_FALSE;
o->cap |= SANE_CAP_INACTIVE;
/* Fit to page */
o = &s->opt[FIT_TO_PAGE];
o->name = SANE_I18N ("fit-to-page");
o->title = SANE_I18N ("Fit to page");
o->desc = SANE_I18N ("Scanner shrinks image to fit scanned page");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[FIT_TO_PAGE].w = SANE_FALSE;
/* Geometry group */
o = &s->opt[GEOMETRY_GROUP];
o->title = SANE_I18N ("Geometry");
o->desc = ""; /* not valid for a group */
o->type = SANE_TYPE_GROUP;
o->cap = 0;
o->size = 0;
o->constraint_type = SANE_CONSTRAINT_NONE;
/* Paper sizes list */
o = &s->opt[PAPER_SIZE];
o->name = "paper-size";
o->title = SANE_I18N ("Paper size");
o->desc = SANE_I18N ("Physical size of the paper in the ADF");
o->type = SANE_TYPE_STRING;
o->constraint.string_list =
s->id == KV_S4085CL || s->id == KV_S4065CL ? paper_list_woA3 : paper_list;
o->size = max_string_size (o->constraint.string_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
s->val[PAPER_SIZE].s = malloc (o->size);
strcpy (s->val[PAPER_SIZE].s, SANE_I18N ("A4"));
/* Landscape */
o = &s->opt[LANDSCAPE];
o->name = "landscape";
o->title = SANE_I18N ("Landscape");
o->desc =
SANE_I18N ("Set paper position : "
"true for landscape, false for portrait");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[LANDSCAPE].w = SANE_FALSE;
/* Upper left X */
o = &s->opt[TL_X];
o->name = SANE_NAME_SCAN_TL_X;
o->title = SANE_TITLE_SCAN_TL_X;
o->desc = SANE_DESC_SCAN_TL_X;
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_MM;
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range =
(s->id == KV_S4085CL || s->id == KV_S4065CL)
? &tl_x_range_A4 : &tl_x_range;
o->cap |= SANE_CAP_INACTIVE;
s->val[TL_X].w = 0;
/* Upper left Y */
o = &s->opt[TL_Y];
o->name = SANE_NAME_SCAN_TL_Y;
o->title = SANE_TITLE_SCAN_TL_Y;
o->desc = SANE_DESC_SCAN_TL_Y;
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_MM;
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range =
(s->id == KV_S4085CL || s->id == KV_S4065CL)
? &tl_y_range_A4 : &tl_y_range;
o->cap |= SANE_CAP_INACTIVE;
s->val[TL_Y].w = 0;
/* Bottom-right x */
o = &s->opt[BR_X];
o->name = SANE_NAME_SCAN_BR_X;
o->title = SANE_TITLE_SCAN_BR_X;
o->desc = SANE_DESC_SCAN_BR_X;
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_MM;
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range =
(s->id == KV_S4085CL || s->id == KV_S4065CL)
? &br_x_range_A4 : &br_x_range;
o->cap |= SANE_CAP_INACTIVE;
s->val[BR_X].w = 210;
/* Bottom-right y */
o = &s->opt[BR_Y];
o->name = SANE_NAME_SCAN_BR_Y;
o->title = SANE_TITLE_SCAN_BR_Y;
o->desc = SANE_DESC_SCAN_BR_Y;
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_MM;
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range =
(s->id == KV_S4085CL || s->id == KV_S4065CL)
? &br_y_range_A4 : &br_y_range;
o->cap |= SANE_CAP_INACTIVE;
s->val[BR_Y].w = 297;
/* Enhancement group */
o = &s->opt[ADVANCED_GROUP];
o->title = SANE_I18N ("Advanced");
o->desc = ""; /* not valid for a group */
o->type = SANE_TYPE_GROUP;
o->cap = SANE_CAP_ADVANCED;
o->size = 0;
o->constraint_type = SANE_CONSTRAINT_NONE;
/* Brightness */
o = &s->opt[BRIGHTNESS];
o->name = SANE_NAME_BRIGHTNESS;
o->title = SANE_TITLE_BRIGHTNESS;
o->desc = SANE_DESC_BRIGHTNESS;
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_NONE;
o->size = sizeof (SANE_Int);
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range = &(byte_value_range);
s->val[BRIGHTNESS].w = 128;
/* Contrast */
o = &s->opt[CONTRAST];
o->name = SANE_NAME_CONTRAST;
o->title = SANE_TITLE_CONTRAST;
o->desc = SANE_DESC_CONTRAST;
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_NONE;
o->size = sizeof (SANE_Int);
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range = &(byte_value_range);
s->val[CONTRAST].w = 128;
/* threshold */
o = &s->opt[THRESHOLD];
o->name = SANE_NAME_THRESHOLD;
o->title = SANE_TITLE_THRESHOLD;
o->desc = SANE_DESC_THRESHOLD;
o->type = SANE_TYPE_INT;
o->size = sizeof (SANE_Int);
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range = &(byte_value_range);
s->val[THRESHOLD].w = 128;
o->cap |= SANE_CAP_INACTIVE;
o = &s->opt[AUTOMATIC_THRESHOLD];
o->name = "athreshold";
o->title = SANE_I18N ("Automatic threshold mode");
o->desc = SANE_I18N ("Sets the automatic threshold mode");
o->type = SANE_TYPE_STRING;
o->size = max_string_size (automatic_threshold_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = automatic_threshold_list;
s->val[AUTOMATIC_THRESHOLD].s = malloc (o->size);
strcpy (s->val[AUTOMATIC_THRESHOLD].s, automatic_threshold_list[0]);
o->cap |= SANE_CAP_INACTIVE;
/* Image emphasis */
o = &s->opt[IMAGE_EMPHASIS];
o->name = "image-emphasis";
o->title = SANE_I18N ("Image emphasis");
o->desc = SANE_I18N ("Sets the image emphasis");
o->type = SANE_TYPE_STRING;
o->size = max_string_size (image_emphasis_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = image_emphasis_list;
s->val[IMAGE_EMPHASIS].s = malloc (o->size);
strcpy (s->val[IMAGE_EMPHASIS].s, image_emphasis_list[0]);;
o->cap |= SANE_CAP_INACTIVE;
/* Gamma */
o = &s->opt[GAMMA_CORRECTION];
o->name = "gamma-cor";
o->title = SANE_I18N ("Gamma correction");
o->desc = SANE_I18N ("Gamma correction");
o->type = SANE_TYPE_STRING;
o->size = max_string_size (gamma_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = gamma_list;
s->val[GAMMA_CORRECTION].s = malloc (o->size);
strcpy (s->val[GAMMA_CORRECTION].s, gamma_list[0]);
o->cap |= SANE_CAP_INACTIVE;
/* Lamp color dropout */
o = &s->opt[LAMP];
o->name = "lamp-color";
o->title = SANE_I18N ("Lamp color");
o->desc = SANE_I18N ("Sets the lamp color (color dropout)");
o->type = SANE_TYPE_STRING;
o->size = max_string_size (lamp_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = lamp_list;
s->val[LAMP].s = malloc (o->size);
strcpy (s->val[LAMP].s, lamp_list[0]);
/* Inverse image */
o = &s->opt[INVERSE];
o->name = "inverse";
o->title = SANE_I18N ("Inverse Image");
o->desc = SANE_I18N ("Inverse image in B/W mode");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
o->cap |= SANE_CAP_INACTIVE;
/* Halftone pattern */
o = &s->opt[HALFTONE_PATTERN];
o->name = SANE_NAME_HALFTONE_PATTERN;
o->title = SANE_TITLE_HALFTONE_PATTERN;
o->desc = SANE_DESC_HALFTONE_PATTERN;
o->type = SANE_TYPE_STRING;
o->size = max_string_size (halftone_pattern);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = halftone_pattern;
s->val[HALFTONE_PATTERN].s = malloc (o->size);
strcpy (s->val[HALFTONE_PATTERN].s, halftone_pattern[0]);
o->cap |= SANE_CAP_INACTIVE;
/* JPEG Compression */
o = &s->opt[COMPRESSION];
o->name = "jpeg";
o->title = SANE_I18N ("JPEG compression");
o->desc =
SANE_I18N
("JPEG compression (yours application must be able to uncompress)");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
/* Compression parameter */
o = &s->opt[COMPRESSION_PAR];
o->name = "comp_arg";
o->title = "Compression Argument";
o->desc = "Compression Argument (Q parameter for JPEG)";
o->type = SANE_TYPE_INT;
o->size = sizeof (SANE_Int);
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range = &(compression_value_range);
s->val[COMPRESSION_PAR].w = 0x4b;
o->cap |= SANE_CAP_INACTIVE;
/* Stapled document */
o = &s->opt[STAPELED_DOC];
o->name = "stapeled_doc";
o->title = SANE_I18N ("Detect stapled document");
o->desc = SANE_I18N ("Detect stapled document");
o->type = SANE_TYPE_STRING;
o->size = max_string_size (stapeled_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = stapeled_list;
s->val[STAPELED_DOC].s = malloc (o->size);
strcpy (s->val[STAPELED_DOC].s, stapeled_list[0]);
if (s->id == KV_S7075C)
o->cap |= SANE_CAP_INACTIVE;
/* White level base */
o = &s->opt[WHITE_LEVEL];
o->name = SANE_NAME_WHITE_LEVEL;
o->title = SANE_TITLE_WHITE_LEVEL;
o->desc = SANE_DESC_WHITE_LEVEL;
o->type = SANE_TYPE_STRING;
o->size = max_string_size (white_level_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = white_level_list;
s->val[WHITE_LEVEL].s = malloc (o->size);
strcpy (s->val[WHITE_LEVEL].s, white_level_list[0]);
o->cap |= SANE_CAP_INACTIVE;
/* Noise reduction */
o = &s->opt[NOISE_REDUCTION];
o->name = "noise-reduction";
o->title = SANE_I18N ("Noise reduction");
o->desc = SANE_I18N ("Reduce the isolated dot noise");
o->type = SANE_TYPE_STRING;
o->size = max_string_size (noise_reduction_list);
o->constraint_type = SANE_CONSTRAINT_STRING_LIST;
o->constraint.string_list = noise_reduction_list;
s->val[NOISE_REDUCTION].s = malloc (o->size);
strcpy (s->val[NOISE_REDUCTION].s, noise_reduction_list[0]);
o->cap |= SANE_CAP_INACTIVE;
o = &s->opt[RED_CHROMA];
o->name = "red-chroma";
o->title = SANE_I18N ("chroma of red");
o->desc = SANE_I18N ("Set chroma of red");
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_NONE;
o->size = sizeof (SANE_Int);
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range = &(byte_value_range);
s->val[RED_CHROMA].w = 0;
o = &s->opt[BLUE_CHROMA];
o->name = "blue chroma";
o->title = SANE_I18N ("chroma of blue");
o->desc = SANE_I18N ("Set chroma of blue");
o->type = SANE_TYPE_INT;
o->unit = SANE_UNIT_NONE;
o->size = sizeof (SANE_Int);
o->constraint_type = SANE_CONSTRAINT_RANGE;
o->constraint.range = &(byte_value_range);
s->val[BLUE_CHROMA].w = 0;
o = &s->opt[DESKEW];
o->name = "deskew";
o->title = SANE_I18N ("Skew adjustment");
o->desc = SANE_I18N ("Skew adjustment");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[DESKEW].w = SANE_FALSE;
if (s->id != KV_S4085CL && s->id != KV_S4085CW)
o->cap |= SANE_CAP_INACTIVE;
o = &s->opt[STOP_SKEW];
o->name = "stop-skew";
o->title = SANE_I18N ("Stop scanner when a paper have been skewed");
o->desc = SANE_I18N ("Scanner will be stop when a paper have been skewed");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[STOP_SKEW].w = SANE_FALSE;
o = &s->opt[CROP];
o->name = "crop";
o->title = SANE_I18N ("Crop actual image area");
o->desc = SANE_I18N ("Scanner automatically detect image area and crop it");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[CROP].w = SANE_FALSE;
if (s->id != KV_S4085CL && s->id != KV_S4085CW)
o->cap |= SANE_CAP_INACTIVE;
o = &s->opt[MIRROR];
o->name = "mirror";
o->title = SANE_I18N ("Mirror image");
o->desc = SANE_I18N ("It is right and left reversing");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[MIRROR].w = SANE_FALSE;
o = &s->opt[TOPPOS];
o->name = "toppos";
o->title = SANE_I18N ("Addition of space in top position");
o->desc = SANE_I18N ("Addition of space in top position");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[TOPPOS].w = SANE_FALSE;
o = &s->opt[BTMPOS];
o->name = "btmpos";
o->title = SANE_I18N ("Addition of space in bottom position");
o->desc = SANE_I18N ("Addition of space in bottom position");
o->type = SANE_TYPE_BOOL;
o->unit = SANE_UNIT_NONE;
s->val[BTMPOS].w = SANE_FALSE;
}
static SANE_Status
init_options (Mustek_Usb_Scanner * s)
{
SANE_Int option;
SANE_Status status;
DBG (5, "init_options: start\n");
memset (s->opt, 0, sizeof (s->opt));
memset (s->val, 0, sizeof (s->val));
for (option = 0; option < NUM_OPTIONS; ++option)
{
s->opt[option].size = sizeof (SANE_Word);
s->opt[option].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
}
s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
/* "Mode" group: */
s->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
s->opt[OPT_MODE_GROUP].desc = "";
s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_MODE_GROUP].size = 0;
s->opt[OPT_MODE_GROUP].cap = 0;
s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* scan mode */
mode_list[0] = SANE_VALUE_SCAN_MODE_COLOR;
mode_list[1] = SANE_VALUE_SCAN_MODE_GRAY;
mode_list[2] = SANE_VALUE_SCAN_MODE_LINEART;
mode_list[3] = NULL;
s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
s->opt[OPT_MODE].type = SANE_TYPE_STRING;
s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
s->opt[OPT_MODE].size = max_string_size (mode_list);
s->opt[OPT_MODE].constraint.string_list = mode_list;
s->val[OPT_MODE].s = strdup (mode_list[1]);
/* resolution */
s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
s->opt[OPT_RESOLUTION].type = SANE_TYPE_FIXED;
s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_RESOLUTION].constraint.range = &s->hw->dpi_range;
s->val[OPT_RESOLUTION].w = s->hw->dpi_range.min;
if (s->hw->chip->scanner_type == MT_600CU)
s->hw->dpi_range.max = SANE_FIX (600);
else
s->hw->dpi_range.max = SANE_FIX (1200);
/* preview */
s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
s->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
s->val[OPT_PREVIEW].w = SANE_FALSE;
/* "Geometry" group: */
s->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
s->opt[OPT_GEOMETRY_GROUP].desc = "";
s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
s->opt[OPT_GEOMETRY_GROUP].size = 0;
s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* top-left x */
s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_TL_X].constraint.range = &s->hw->x_range;
s->val[OPT_TL_X].w = 0;
/* top-left y */
s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_TL_Y].constraint.range = &s->hw->y_range;
s->val[OPT_TL_Y].w = 0;
/* bottom-right x */
s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BR_X].constraint.range = &s->hw->x_range;
s->val[OPT_BR_X].w = s->hw->x_range.max;
/* bottom-right y */
s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BR_Y].constraint.range = &s->hw->y_range;
s->val[OPT_BR_Y].w = s->hw->y_range.max;
/* "Enhancement" group: */
s->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_ENHANCEMENT_GROUP].size = 0;
s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* threshold */
s->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
s->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
s->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
s->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
s->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_THRESHOLD].constraint.range = &u8_range;
s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
s->val[OPT_THRESHOLD].w = 128;
/* custom-gamma table */
s->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
s->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
s->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
s->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
s->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
/* gray gamma vector */
s->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
s->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
s->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
s->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT;
s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE;
s->opt[OPT_GAMMA_VECTOR].size = 256 * sizeof (SANE_Word);
s->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_GAMMA_VECTOR].constraint.range = &u8_range;
s->val[OPT_GAMMA_VECTOR].wa = &s->gray_gamma_table[0];
/* red gamma vector */
s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
s->opt[OPT_GAMMA_VECTOR_R].size = 256 * sizeof (SANE_Word);
s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
s->val[OPT_GAMMA_VECTOR_R].wa = &s->red_gamma_table[0];
/* green gamma vector */
s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
s->opt[OPT_GAMMA_VECTOR_G].size = 256 * sizeof (SANE_Word);
s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
s->val[OPT_GAMMA_VECTOR_G].wa = &s->green_gamma_table[0];
/* blue gamma vector */
s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
s->opt[OPT_GAMMA_VECTOR_B].size = 256 * sizeof (SANE_Word);
s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
s->val[OPT_GAMMA_VECTOR_B].wa = &s->blue_gamma_table[0];
RIE (calc_parameters (s));
DBG (5, "init_options: exit\n");
return SANE_STATUS_GOOD;
}
static SANE_Status
init_options (Abaton_Scanner * s)
{
int i;
memset (s->opt, 0, sizeof (s->opt));
memset (s->val, 0, sizeof (s->val));
for (i = 0; i < NUM_OPTIONS; ++i)
{
s->opt[i].size = sizeof (SANE_Word);
s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
}
s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
/* "Mode" group: */
s->opt[OPT_MODE_GROUP].title = "Scan Mode";
s->opt[OPT_MODE_GROUP].desc = "";
s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_MODE_GROUP].cap = 0;
s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
mode_list[0]=SANE_VALUE_SCAN_MODE_LINEART;
switch (s->hw->ScannerModel)
{
case ABATON_300GS:
mode_list[1]=SANE_VALUE_SCAN_MODE_HALFTONE;
mode_list[2]="Gray16";
mode_list[3]="Gray256";
mode_list[4]=NULL;
break;
case ABATON_300S:
default:
mode_list[1]=NULL;
break;
}
/* scan mode */
s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
s->opt[OPT_MODE].type = SANE_TYPE_STRING;
s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
s->opt[OPT_MODE].size = max_string_size (mode_list);
s->opt[OPT_MODE].constraint.string_list = mode_list;
s->val[OPT_MODE].s = strdup (mode_list[0]);
/* resolution - horizontal */
s->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
s->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_X_RESOLUTION;
s->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_X_RESOLUTION;
s->opt[OPT_X_RESOLUTION].type = SANE_TYPE_INT;
s->opt[OPT_X_RESOLUTION].unit = SANE_UNIT_DPI;
s->opt[OPT_X_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_X_RESOLUTION].constraint.range = &dpi_range;
s->val[OPT_X_RESOLUTION].w = 150;
/* resolution - vertical */
s->opt[OPT_Y_RESOLUTION].name = SANE_NAME_SCAN_Y_RESOLUTION;
s->opt[OPT_Y_RESOLUTION].title = SANE_TITLE_SCAN_Y_RESOLUTION;
s->opt[OPT_Y_RESOLUTION].desc = SANE_DESC_SCAN_Y_RESOLUTION;
s->opt[OPT_Y_RESOLUTION].type = SANE_TYPE_INT;
s->opt[OPT_Y_RESOLUTION].unit = SANE_UNIT_DPI;
s->opt[OPT_Y_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_Y_RESOLUTION].constraint.range = &dpi_range;
s->val[OPT_Y_RESOLUTION].w = 150;
/* constrain resolutions */
s->opt[OPT_RESOLUTION_BIND].name = SANE_NAME_RESOLUTION_BIND;
s->opt[OPT_RESOLUTION_BIND].title = SANE_TITLE_RESOLUTION_BIND;
s->opt[OPT_RESOLUTION_BIND].desc = SANE_DESC_RESOLUTION_BIND;
s->opt[OPT_RESOLUTION_BIND].type = SANE_TYPE_BOOL;
s->opt[OPT_RESOLUTION_BIND].unit = SANE_UNIT_NONE;
s->opt[OPT_RESOLUTION_BIND].constraint_type = SANE_CONSTRAINT_NONE;
/* until I fix it */
s->val[OPT_RESOLUTION_BIND].w = SANE_FALSE;
/* preview mode */
s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
s->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
s->val[OPT_PREVIEW].w = SANE_FALSE;
/* halftone pattern */
s->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
s->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
s->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
s->opt[OPT_HALFTONE_PATTERN].size = max_string_size (halftone_pattern_list);
s->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING;
s->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_STRING_LIST;
s->opt[OPT_HALFTONE_PATTERN].constraint.string_list = halftone_pattern_list;
s->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]);
/* "Geometry" group: */
s->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
s->opt[OPT_GEOMETRY_GROUP].desc = "";
s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* top-left x */
s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
s->opt[OPT_TL_X].type = SANE_TYPE_INT;
s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_TL_X].constraint.range = &x_range;
s->val[OPT_TL_X].w = 0;
/* top-left y */
s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
s->opt[OPT_TL_Y].type = SANE_TYPE_INT;
s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_TL_Y].constraint.range = &y_range;
s->val[OPT_TL_Y].w = 0;
/* bottom-right x */
s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
s->opt[OPT_BR_X].type = SANE_TYPE_INT;
s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BR_X].constraint.range = &x_range;
s->val[OPT_BR_X].w = x_range.max;
/* bottom-right y */
s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
s->opt[OPT_BR_Y].type = SANE_TYPE_INT;
s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BR_Y].constraint.range = &y_range;
s->val[OPT_BR_Y].w = y_range.max;
/* "Enhancement" group: */
s->opt[OPT_ENHANCEMENT_GROUP].title = "Enhancement";
s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
/* brightness */
s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
s->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_BRIGHTNESS].constraint.range = &enhance_range;
s->val[OPT_BRIGHTNESS].w = 150;
/* contrast */
s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
s->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
s->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE;
s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_CONTRAST].constraint.range = &enhance_range;
s->val[OPT_CONTRAST].w = 150;
/* threshold */
s->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
s->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
s->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
s->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
s->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
s->opt[OPT_THRESHOLD].constraint.range = &enhance_range;
s->val[OPT_THRESHOLD].w = 150;
/* negative */
s->opt[OPT_NEGATIVE].name = SANE_NAME_NEGATIVE;
s->opt[OPT_NEGATIVE].title = SANE_TITLE_NEGATIVE;
s->opt[OPT_NEGATIVE].desc = SANE_DESC_NEGATIVE;
s->opt[OPT_NEGATIVE].type = SANE_TYPE_BOOL;
s->opt[OPT_NEGATIVE].unit = SANE_UNIT_NONE;
s->opt[OPT_NEGATIVE].constraint_type = SANE_CONSTRAINT_NONE;
s->val[OPT_NEGATIVE].w = SANE_FALSE;
/* mirror-image */
s->opt[OPT_MIRROR].name = "mirror";
s->opt[OPT_MIRROR].title = "Mirror Image";
s->opt[OPT_MIRROR].desc = "Scan in mirror-image";
s->opt[OPT_MIRROR].type = SANE_TYPE_BOOL;
s->opt[OPT_MIRROR].unit = SANE_UNIT_NONE;
s->opt[OPT_MIRROR].constraint_type = SANE_CONSTRAINT_NONE;
s->val[OPT_MIRROR].w = SANE_FALSE;
return SANE_STATUS_GOOD;
}
static void init_options(struct device *dev)
{
int i;
for (i = 0; i < NUM_OPTIONS; i++) {
dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
dev->opt[i].size = sizeof(SANE_Word);
dev->opt[i].type = SANE_TYPE_FIXED;
dev->val[i].s = NULL;
}
dev->opt[OPT_NUMOPTIONS].name = SANE_NAME_NUM_OPTIONS;
dev->opt[OPT_NUMOPTIONS].title = SANE_TITLE_NUM_OPTIONS;
dev->opt[OPT_NUMOPTIONS].desc = SANE_DESC_NUM_OPTIONS;
dev->opt[OPT_NUMOPTIONS].type = SANE_TYPE_INT;
dev->opt[OPT_NUMOPTIONS].cap = SANE_CAP_SOFT_DETECT;
dev->val[OPT_NUMOPTIONS].w = NUM_OPTIONS;
dev->opt[OPT_GROUP_STD].name = SANE_NAME_STANDARD;
dev->opt[OPT_GROUP_STD].title = SANE_TITLE_STANDARD;
dev->opt[OPT_GROUP_STD].desc = SANE_DESC_STANDARD;
dev->opt[OPT_GROUP_STD].type = SANE_TYPE_GROUP;
dev->opt[OPT_GROUP_STD].cap = 0;
dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
dev->opt[OPT_RESOLUTION].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT;
dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
dev->opt[OPT_RESOLUTION].constraint.word_list = dev->dpi_list;
dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
dev->opt[OPT_MODE].size = max_string_size(scan_modes);
dev->opt[OPT_MODE].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT;
dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_MODE].constraint.string_list = scan_modes;
dev->opt[OPT_THRESHOLD].name = SANE_NAME_HIGHLIGHT;
dev->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
dev->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
dev->opt[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT;
dev->opt[OPT_THRESHOLD].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT;
dev->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_THRESHOLD].constraint.range = &threshold;
dev->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE;
dev->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
dev->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE;
dev->opt[OPT_SOURCE].type = SANE_TYPE_STRING;
dev->opt[OPT_SOURCE].size = max_string_size(doc_sources);
dev->opt[OPT_SOURCE].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT;
dev->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
dev->opt[OPT_SOURCE].constraint.string_list = doc_sources;
dev->opt[OPT_GROUP_GEO].name = SANE_NAME_GEOMETRY;
dev->opt[OPT_GROUP_GEO].title = SANE_TITLE_GEOMETRY;
dev->opt[OPT_GROUP_GEO].desc = SANE_DESC_GEOMETRY;
dev->opt[OPT_GROUP_GEO].type = SANE_TYPE_GROUP;
dev->opt[OPT_GROUP_GEO].cap = 0;
dev->opt[OPT_SCAN_TL_X].name = SANE_NAME_SCAN_TL_X;
dev->opt[OPT_SCAN_TL_X].title = SANE_TITLE_SCAN_TL_X;
dev->opt[OPT_SCAN_TL_X].desc = SANE_DESC_SCAN_TL_X;
dev->opt[OPT_SCAN_TL_X].unit = SANE_UNIT_MM;
dev->opt[OPT_SCAN_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_SCAN_TL_X].constraint.range = &dev->win_x_range;
dev->opt[OPT_SCAN_TL_Y].name = SANE_NAME_SCAN_TL_Y;
dev->opt[OPT_SCAN_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
dev->opt[OPT_SCAN_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
dev->opt[OPT_SCAN_TL_Y].unit = SANE_UNIT_MM;
dev->opt[OPT_SCAN_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_SCAN_TL_Y].constraint.range = &dev->win_y_range;
dev->opt[OPT_SCAN_BR_X].name = SANE_NAME_SCAN_BR_X;
dev->opt[OPT_SCAN_BR_X].title = SANE_TITLE_SCAN_BR_X;
dev->opt[OPT_SCAN_BR_X].desc = SANE_DESC_SCAN_BR_X;
dev->opt[OPT_SCAN_BR_X].unit = SANE_UNIT_MM;
dev->opt[OPT_SCAN_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_SCAN_BR_X].constraint.range = &dev->win_x_range;
dev->opt[OPT_SCAN_BR_Y].name = SANE_NAME_SCAN_BR_Y;
dev->opt[OPT_SCAN_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
dev->opt[OPT_SCAN_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
dev->opt[OPT_SCAN_BR_Y].unit = SANE_UNIT_MM;
dev->opt[OPT_SCAN_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_SCAN_BR_Y].constraint.range = &dev->win_y_range;
}
static void
initialize_options_list (AS6E_Scan * s)
{
SANE_Int option;
DBG (2, "initialize_options_list\n");
for (option = 0; option < NUM_OPTIONS; ++option)
{
s->options_list[option].size = sizeof (SANE_Word);
s->options_list[option].cap =
SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
}
s->options_list[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
s->options_list[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
s->options_list[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
s->options_list[OPT_NUM_OPTS].type = SANE_TYPE_INT;
s->options_list[OPT_NUM_OPTS].unit = SANE_UNIT_NONE;
s->options_list[OPT_NUM_OPTS].size = sizeof (SANE_Word);
s->options_list[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
s->options_list[OPT_NUM_OPTS].constraint_type = SANE_CONSTRAINT_NONE;
s->value[OPT_NUM_OPTS].w = NUM_OPTIONS;
s->options_list[OPT_MODE].name = SANE_NAME_SCAN_MODE;
s->options_list[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
s->options_list[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
s->options_list[OPT_MODE].type = SANE_TYPE_STRING;
s->options_list[OPT_MODE].size = max_string_size (mode_list);
s->options_list[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
s->options_list[OPT_MODE].constraint.string_list = mode_list;
s->value[OPT_MODE].s = strdup (mode_list[2]);
s->options_list[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
s->options_list[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
s->options_list[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
s->options_list[OPT_RESOLUTION].type = SANE_TYPE_INT;
s->options_list[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
s->options_list[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
s->options_list[OPT_RESOLUTION].constraint.word_list = resolution_list;
s->value[OPT_RESOLUTION].w = 200;
s->options_list[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
s->options_list[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
s->options_list[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
s->options_list[OPT_TL_X].type = SANE_TYPE_FIXED;
s->options_list[OPT_TL_X].unit = SANE_UNIT_MM;
s->options_list[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_TL_X].constraint.range = &x_range;
s->value[OPT_TL_X].w = s->options_list[OPT_TL_X].constraint.range->min;
s->options_list[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
s->options_list[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
s->options_list[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
s->options_list[OPT_TL_Y].type = SANE_TYPE_FIXED;
s->options_list[OPT_TL_Y].unit = SANE_UNIT_MM;
s->options_list[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_TL_Y].constraint.range = &y_range;
s->value[OPT_TL_Y].w = s->options_list[OPT_TL_Y].constraint.range->min;
s->options_list[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
s->options_list[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
s->options_list[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
s->options_list[OPT_BR_X].type = SANE_TYPE_FIXED;
s->options_list[OPT_BR_X].unit = SANE_UNIT_MM;
s->options_list[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_BR_X].constraint.range = &x_range;
s->value[OPT_BR_X].w = s->options_list[OPT_BR_X].constraint.range->max;
s->options_list[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
s->options_list[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
s->options_list[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
s->options_list[OPT_BR_Y].type = SANE_TYPE_FIXED;
s->options_list[OPT_BR_Y].unit = SANE_UNIT_MM;
s->options_list[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_BR_Y].constraint.range = &y_range;
s->value[OPT_BR_Y].w = s->options_list[OPT_BR_Y].constraint.range->max;
s->options_list[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
s->options_list[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
s->options_list[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
s->options_list[OPT_CONTRAST].type = SANE_TYPE_INT;
s->options_list[OPT_CONTRAST].unit = SANE_UNIT_NONE;
s->options_list[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_CONTRAST].constraint.range = &brightness_range;
s->value[OPT_BRIGHTNESS].w = 10;
s->options_list[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
s->options_list[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
s->options_list[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
s->options_list[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
s->options_list[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
s->options_list[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_BRIGHTNESS].constraint.range = &contrast_range;
s->value[OPT_CONTRAST].w = -32;
}
