static int
camera_set_config (Camera *camera, CameraWidget *window, GPContext *context)
{
CameraWidget *widget;
FujiDate date;
time_t t;
struct tm *tm;
const char *id;
/* Date & Time */
if ((gp_widget_get_child_by_label (window, _("Date & Time"),
&widget) >= 0) &&
gp_widget_changed (widget)) {
CR (gp_widget_get_value (widget, &t));
tm = localtime (&t);
date.year = tm->tm_year;
date.month = tm->tm_mon;
date.day = tm->tm_mday;
date.hour = tm->tm_hour;
date.min = tm->tm_min;
date.sec = tm->tm_sec;
CR (fuji_date_set (camera, date, context));
}
/* ID */
if ((gp_widget_get_child_by_label (window, _("ID"), &widget) >= 0) &&
gp_widget_changed (widget)) {
CR (gp_widget_get_value (widget, &id));
CR (fuji_id_set (camera, id, context));
}
return (GP_OK);
}
static int
camera_set_config (Camera *camera, CameraWidget *window, GPContext *context)
{
CameraWidget *w;
char *wvalue;
int val;
char str[16];
GP_DEBUG ("camera_set_config()");
gp_widget_get_child_by_label (window, _("Exposure level on preview"), &w);
if (gp_widget_changed (w)) {
gp_widget_get_value (w, &wvalue);
camera->pl->exposure = MAX(MIN_EXPOSURE,MIN(MAX_EXPOSURE,atoi(wvalue)));
gp_setting_set ("dimera3500", "exposure", wvalue);
GP_DEBUG ("set exposure");
}
gp_widget_get_child_by_label (window, _("Automatic exposure adjustment on preview"), &w);
if (gp_widget_changed (w)) {
gp_widget_get_value (w, &val);
camera->pl->auto_exposure = val;
sprintf(str, "%d", val);
gp_setting_set ("dimera3500", "auto_exposure", str);
GP_DEBUG ("set auto_exposure");
}
gp_widget_get_child_by_label (window, _("Automatic flash on capture"), &w);
if (gp_widget_changed (w)) {
gp_widget_get_value (w, &val);
camera->pl->auto_flash = val;
sprintf(str, "%d", val);
gp_setting_set ("dimera3500", "auto_flash", str);
GP_DEBUG ("set auto_flash");
}
GP_DEBUG ("done configuring driver.");
return GP_OK;
}
static int
camera_set_config (Camera *c, CameraWidget *window, GPContext *co)
{
CameraWidget *w;
const char *v_char;
time_t time;
RicohMode mode;
/* We need to be in record mode to set settings. */
CR (ricoh_get_mode (c, co, &mode));
if (mode != RICOH_MODE_RECORD)
CR (ricoh_set_mode (c, co, RICOH_MODE_RECORD));
/* Copyright */
CR (gp_widget_get_child_by_name (window, "copyright", &w));
if (gp_widget_changed (w)) {
CR (gp_widget_get_value (w, &v_char));
CR (ricoh_set_copyright (c, co, v_char));
}
/* Date */
CR (gp_widget_get_child_by_name (window, "date", &w));
if (gp_widget_changed (w)) {
CR (gp_widget_get_value (w, &time));
CR (ricoh_set_date (c, co, time));
}
R_CHECK_RADIO (c, co, window, resolution, N_("Resolution"))
R_CHECK_RADIO (c, co, window, exposure, N_("Exposure"))
R_CHECK_RADIO (c, co, window, white_level, N_("White level"))
R_CHECK_RADIO (c, co, window, macro, N_("Macro"))
R_CHECK_RADIO (c, co, window, zoom, N_("Zoom"))
R_CHECK_RADIO (c, co, window, flash, N_("Flash"))
R_CHECK_RADIO (c, co, window, rec_mode, N_("Record Mode"))
R_CHECK_RADIO (c, co, window, compression, N_("Compression"))
return (GP_OK);
}
static int
camera_config_set (Camera *camera, CameraWidget *window, GPContext *context)
{
int ret;
CameraWidget *turbo;
ret = gp_widget_get_child_by_name (window, "turbo", &turbo);
if (ret != GP_OK) {
gp_log (GP_LOG_ERROR, "camera_config_set", "did not find turbo menu entry?\n");
return GP_OK;
}
if (gp_widget_changed (turbo)) {
const char* val;
int ival;
ret = gp_widget_get_value (turbo, &val);
if (ret == GP_OK) {
ival = !strcmp (val, _("On"));
gp_log (GP_LOG_DEBUG, "camera_config_set", "val %s, ival %d\n", val, ival);
gp_setting_set ("topfield", "turbo", ival?"yes":"no");
}
}
return GP_OK;
}
static int
camera_set_config (Camera *camera, CameraWidget *window, GPContext *context)
{
CameraWidget *w, *w2;
char *wvalue, *w2value;
int i;
gp_widget_get_child_by_label (window, _("File type"), &w);
if (gp_widget_changed (w)) {
gp_widget_get_value (w, &wvalue);
if (wvalue[0] == 'J')
dc210_set_file_type(camera, DC210_FILE_TYPE_JPEG);
else
dc210_set_file_type(camera, DC210_FILE_TYPE_FPX);
};
gp_widget_get_child_by_label (window, _("File resolution"), &w);
if (gp_widget_changed (w)) {
gp_widget_get_value (w, &wvalue);
switch(wvalue[0]){
case '6':
dc210_set_resolution(camera, DC210_FILE_640);
break;
case '1':
dc210_set_resolution(camera, DC210_FILE_1152);
break;
};
};
gp_widget_get_child_by_label (window, _("File compression"), &w);
if (gp_widget_changed (w)) {
gp_widget_get_value (w, &wvalue);
switch(wvalue[0]){
case 'L':
dc210_set_compression(camera, DC210_LOW_COMPRESSION);
break;
case 'M':
dc210_set_compression(camera, DC210_MEDIUM_COMPRESSION);
break;
case 'H':
dc210_set_compression(camera, DC210_HIGH_COMPRESSION);
};
};
gp_widget_get_child_by_label (window, _("Zoom"), &w);
if (gp_widget_changed (w)) {
gp_widget_get_value (w, &wvalue);
switch(wvalue[0]){
case '5':
if (wvalue[1] == '8')
dc210_set_zoom(camera, DC210_ZOOM_58);
else
dc210_set_zoom(camera, DC210_ZOOM_51);
break;
case '4':
dc210_set_zoom(camera, DC210_ZOOM_41);
break;
case '3':
dc210_set_zoom(camera, DC210_ZOOM_34);
break;
case '2':
dc210_set_zoom(camera, DC210_ZOOM_29);
break;
case 'M':
dc210_set_zoom(camera, DC210_ZOOM_MACRO);
break;
};
};
gp_widget_get_child_by_label (window, _("Exposure compensation"), &w);
if (gp_widget_changed (w)) {
gp_widget_get_value (w, &wvalue);
for (i = 0; i < sizeof(exp_comp)/sizeof(*exp_comp); i++){
if (strncmp(wvalue, exp_comp[i], 4) == 0){
dc210_set_exp_compensation(camera, i - 4);
break;
};
};
};
gp_widget_get_child_by_label (window, _("Port speed"), &w);
if (gp_widget_changed (w)) {
gp_widget_get_value (w, &wvalue);
dc210_set_speed(camera, atoi(wvalue));
};
gp_widget_get_child_by_label (window, _("Flash"), &w);
gp_widget_get_child_by_label (window, _("Red eye flash"), &w2);
if (gp_widget_changed (w) || gp_widget_changed(w2)) {
gp_widget_get_value (w, &wvalue);
gp_widget_get_value (w2, &w2value);
switch(wvalue[0]){
case 'A':
dc210_set_flash(camera, DC210_FLASH_AUTO,
w2value[1] == 'n' ? 1 : 0);
break;
case 'F':
dc210_set_flash(camera, DC210_FLASH_FORCE,
w2value[1] == 'n' ? 1 : 0);
break;
case 'N':
dc210_set_flash(camera, DC210_FLASH_NONE, 0);
gp_widget_set_value(w2, _("Off"));
break;
};
};
return GP_OK;
}
static int
camera_cam_desc_set_widget (Camera *camera, CameraRegisterType *reg_p,
CameraWidget *window, GPContext *context)
{
int ind, vind, ret;
union value_in {
char *charp;
int val;
float flt;
} value_in;
CameraWidget *child;
RegisterDescriptorType *reg_desc_p;
GP_DEBUG ("register %d", reg_p->reg_number);
for (ind = 0; ind < reg_p->reg_desc_cnt; ind++) {
reg_desc_p = ®_p->reg_desc[ind];
GP_DEBUG ("window name is %s", reg_desc_p->regs_long_name);
if ((gp_widget_get_child_by_label (window,
_(reg_desc_p->regs_long_name), &child) >= 0) &&
gp_widget_changed (child)) {
gp_widget_get_value (child, &value_in);
for (vind = 0; vind < reg_desc_p->reg_val_name_cnt;
vind++) {
ret = camera_cam_desc_set_value (camera, reg_p,
reg_desc_p,
®_desc_p->regs_value_names[vind],
&value_in, context);
if (ret == GP_OK) {
/*
* Something got set, mark the
* widget as changed, so the user
* can repeat any actions - like
* going to the "next" picture by
* repeatedly hitting apply while
* in operation play mode.
*
* This has the side affect of
* changing whatever was just set
* twice when using the apply in
* gtkam - once when applied and
* once when OK.
*/
gp_widget_set_changed (child, 1);
}
if (ret <= 0) {
/*
* Value was set (GP_OK is 0), or
* some an error occurred (< 0),
* don't bother checking any other
* value/name pairs.
*/
break;
}
}
}
}
return (GP_OK);
}
static int
camera_cam_desc_get_widget (Camera *camera, CameraRegisterType *reg_p,
CameraWidget *section, GPContext *context)
{
int ind, vind, ret, value;
int mask;
char buff[1024];
CameraWidget *child;
RegisterDescriptorType *reg_desc_p;
GP_DEBUG ("register %d", reg_p->reg_number);
if (reg_p->reg_len == 0) {
/*
* This is 0 for GP_WIDGET_BUTTON (callbacks), since is no
* register for call backs. Frontends "get" the value, and
* call the function directly.
*/
ret = GP_OK;
} else if (reg_p->reg_len == 4) {
int rval;
ret = sierra_get_int_register (camera, reg_p->reg_number,
&rval,
context);
reg_p->reg_value = rval;
} else if (reg_p->reg_len == 8) {
/*
* reg_value is 8 bytes maximum. If you need a bigger
* value, change the reg_value size, or allocate space on
* the fly and make a union with reg_value and a void*.
*/
ret = sierra_get_string_register (camera, reg_p->reg_number,
-1, NULL, (unsigned char *)buff, (unsigned int *)&value, context);
if ((ret == GP_OK) && value != reg_p->reg_len) {
GP_DEBUG ("Bad length result %d", value);
return (GP_ERROR);
}
memcpy (®_p->reg_value, buff, reg_p->reg_len);
} else {
GP_DEBUG ("Bad register length %d", reg_p->reg_number);
return (GP_ERROR);
}
GP_DEBUG ("... '%s'.", gp_result_as_string (ret));
if (ret < 0) {
return (ret);
}
for (ind = 0; ind < reg_p->reg_desc_cnt; ind++) {
reg_desc_p = ®_p->reg_desc[ind];
mask = reg_desc_p->regs_mask;
GP_DEBUG ("window name is %s", reg_desc_p->regs_long_name);
gp_widget_new (reg_desc_p->reg_widget_type,
_(reg_desc_p->regs_long_name), &child);
gp_widget_set_name (child, reg_desc_p->regs_short_name);
/*
* Setting the info for the preference settings does not
* make sense like it does for an icon button. This is
* used as the tool-tip field (mouse over hint that pops
* up after a second in gtkam). We don't want this used
* at all; setting it to space doesn't work well, so just
* set it to the same as regs_long_name.
*/
gp_widget_set_info (child, _(reg_desc_p->regs_long_name));
GP_DEBUG ("reg_value 0x%016llx", (long long unsigned)reg_p->reg_value);
for (vind = 0; vind < reg_desc_p->reg_val_name_cnt; vind++) {
camera_cam_desc_get_value (®_desc_p->regs_value_names[vind],
reg_desc_p->reg_widget_type, reg_p->reg_len,
(char*) ®_p->reg_value, mask, child);
}
/*
* For radio and menu values: if there has been no change, it
* means the value was not set, and so it is unknown.
*/
if (((reg_desc_p->reg_widget_type == GP_WIDGET_RADIO) ||
(reg_desc_p->reg_widget_type == GP_WIDGET_MENU)) &&
!gp_widget_changed (child)) {
sprintf (buff, _("%lld (unknown)"), (long long)reg_p->reg_value);
gp_widget_add_choice (child, buff);
gp_widget_set_value (child, buff);
}
gp_widget_append (section, child);
}
return (GP_OK);
}
