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; }