static int
camera_get_config (Camera *camera, CameraWidget **window, GPContext *context)
{
CameraWidget *child;
GP_DEBUG ("*** camera_get_config");
gp_widget_new (GP_WIDGET_WINDOW,
_("Picture Frame Configuration"), window);
gp_widget_new (GP_WIDGET_TOGGLE,
_("Synchronize frame data and time with PC"), &child);
gp_widget_set_value (child, &camera->pl->syncdatetime);
gp_widget_append (*window, child);
gp_widget_new (GP_WIDGET_RADIO, _("Orientation"), &child);
gp_widget_add_choice (child, orientation_to_string (0));
gp_widget_add_choice (child, orientation_to_string (1));
gp_widget_add_choice (child, orientation_to_string (2));
gp_widget_set_value (child,
orientation_to_string (camera->pl->orientation));
gp_widget_append (*window, child);
return GP_OK;
}
static int
camera_config_get (Camera *camera, CameraWidget **window, GPContext *context)
{
CameraWidget *section, *turbo;
char buf[1024];
int val;
gp_widget_new (GP_WIDGET_WINDOW, _("Camera Configuration"), window);
gp_widget_set_name (*window, "config");
gp_widget_new (GP_WIDGET_SECTION, _("Driver Settings"), §ion);
gp_widget_set_name (section, "driver");
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_RADIO, _("Turbo mode"), &turbo);
gp_widget_set_name (turbo, "turbo");
gp_widget_add_choice (turbo,_("On"));
gp_widget_add_choice (turbo,_("Off"));
gp_widget_append (section, turbo);
if (GP_OK == gp_setting_get("topfield","turbo", buf)) {
if (!strcmp(buf,"no"))
val = 0;
else
val = 1;
} else {
val = 1; /* enabled by default */
}
gp_widget_set_value ( turbo, val?_("On"):_("Off"));
return GP_OK;
}
static int
camera_get_config (Camera *camera, CameraWidget **window, GPContext *context)
{
CameraWidget *t, *section;
char str[16];
GP_DEBUG ("camera_get_config()");
gp_widget_new (GP_WIDGET_WINDOW, _("Camera Configuration"), window);
gp_widget_new (GP_WIDGET_SECTION, _("Exposure"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_TOGGLE, _("Automatic exposure adjustment on preview"), &t);
gp_widget_set_value (t, &camera->pl->auto_exposure);
gp_widget_append (section, t);
gp_widget_new (GP_WIDGET_TEXT, _("Exposure level on preview"), &t);
sprintf(str, "%d", camera->pl->exposure);
gp_widget_set_value (t, str);
gp_widget_append (section, t);
gp_widget_new (GP_WIDGET_SECTION, _("Flash"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_TOGGLE, _("Automatic flash on capture"), &t);
gp_widget_set_value (t, &camera->pl->auto_flash);
gp_widget_append (section, t);
return GP_OK;
}
int
camera_get_config_cam_desc (Camera *camera, CameraWidget **window,
GPContext *context)
{
CameraWidget *section;
int indw, indr;
const CameraDescType *cam_desc = NULL;
GP_DEBUG ("*** camera_get_config_cam_desc");
CHECK (camera_start (camera, context));
gp_widget_new (GP_WIDGET_WINDOW, _("Camera Configuration"), window);
cam_desc = camera->pl->cam_desc;
for (indw = 0; indw < 2 /* XXX sizeof () */; indw++) {
GP_DEBUG ("%s registers", cam_desc->regset[indw].window_name);
gp_widget_new (GP_WIDGET_SECTION,
_(cam_desc->regset[indw].window_name), §ion);
gp_widget_append (*window, section);
for (indr = 0; indr < cam_desc->regset[indw].reg_cnt; indr++) {
camera_cam_desc_get_widget (camera,
&cam_desc->regset[indw].regs[indr], section,
context);
}
}
return (GP_OK);
}
static int
camera_get_config (Camera *c, CameraWidget **window, GPContext *co)
{
CameraWidget *s, *w;
const char *copyright;
time_t time;
CR (gp_widget_new (GP_WIDGET_WINDOW, _("Configuration"), window));
/* General settings */
CR (gp_widget_new (GP_WIDGET_SECTION, _("General"), &s));
CR (gp_widget_append (*window, s));
/* Copyright */
CR (gp_widget_new (GP_WIDGET_TEXT, _("Copyright"), &w));
CR (gp_widget_set_name (w, "copyright"));
CR (gp_widget_set_info (w, _("Copyright (max. 20 characters)")));
CR (gp_widget_append (s, w));
CR (ricoh_get_copyright (c, co, ©right));
CR (gp_widget_set_value (w, (void *) copyright));
/* Date */
CR (gp_widget_new (GP_WIDGET_DATE, _("Date & Time"), &w));
CRW (gp_widget_set_name (w, "date"), w);
CRW (gp_widget_set_info (w, _("Date & Time")), w);
CRW (gp_widget_append (s, w), w);
CR (ricoh_get_date (c, co, &time));
CR (gp_widget_set_value (w, &time));
/* Picture related settings */
CR (gp_widget_new (GP_WIDGET_SECTION, _("Pictures"), &s));
CRW (gp_widget_append (*window, s), w);
R_ADD_RADIO (c, co, s, RicohResolution, resolution, "Resolution")
R_ADD_RADIO (c, co, s, RicohExposure, exposure, "Exposure")
R_ADD_RADIO (c, co, s, RicohMacro, macro, "Macro")
R_ADD_RADIO (c, co, s, RicohFlash, flash, "Flash")
R_ADD_RADIO (c, co, s, RicohZoom, zoom, "Zoom")
R_ADD_RADIO (c, co, s, RicohCompression, compression, "Compression")
R_ADD_RADIO (c, co, s, RicohWhiteLevel, white_level, "White Level")
R_ADD_RADIO (c, co, s, RicohRecMode, rec_mode, "Record Mode")
return (GP_OK);
}
static int
camera_get_config (Camera *camera, CameraWidget **window, GPContext *context)
{
CameraWidget *widget;
struct tm tm;
time_t t;
FujiDate date;
const char *id;
CR (gp_widget_new (GP_WIDGET_WINDOW, _("Configuration for "
"your FUJI camera"), window));
/* Date & Time */
if (fuji_date_get (camera, &date, context) >= 0) {
CR (gp_widget_new (GP_WIDGET_DATE, _("Date & Time"), &widget));
CR (gp_widget_append (*window, widget));
memset (&tm, 0, sizeof (struct tm));
tm.tm_year = date.year;
tm.tm_mon = date.month;
tm.tm_mday = date.day;
tm.tm_hour = date.hour;
tm.tm_min = date.min;
tm.tm_sec = date.sec;
t = mktime (&tm);
CR (gp_widget_set_value (widget, &t));
}
/* ID */
if (fuji_id_get (camera, &id, context) >= 0) {
CR (gp_widget_new (GP_WIDGET_TEXT, _("ID"), &widget));
CR (gp_widget_append (*window, widget));
CR (gp_widget_set_value (widget, (void *) id));
}
return (GP_OK);
}
/*
* List all informations about the camera
*/
static int
camera_get_config (Camera* camera, CameraWidget** window, GPContext *context)
{
unsigned char cmd[2], buf[INFO_BUFFER];
int ret;
CameraWidget *widget;
CameraWidget *section;
time_t timestamp=0;
float value_float;
GP_DEBUG ("*** ENTER: camera_get_config ***");
/* get informations about camera */
cmd[0] = ESC;
cmd[1] = GETCAMINFO;
ret = gp_port_write (camera->port, (char*)cmd, sizeof(cmd));
if (ret<GP_OK)
return ret;
ret = gp_port_read (camera->port, (char*)buf, INFO_BUFFER);
if (ret<GP_OK)
return ret;
/* Informations manipulation */
timestamp = (buf[TIMESTAMP_PTR] << 24) + (buf[TIMESTAMP_PTR+1] << 16)
+ (buf[TIMESTAMP_PTR+2] << 8) + buf[TIMESTAMP_PTR+3];
/*
* This timestamp start the 1 January 1980 at 00:00
* but UNIX timestamp start the 1 January 1970 at 00:00
* so we calculate the UNIX timestamp with the camera's one
*/
timestamp += (8*365 + 2*366)*24*3600-3600;
/* Window creation */
gp_widget_new (GP_WIDGET_WINDOW, _("Konica Configuration"), window);
/************************/
/* Persistent Settings */
/************************/
gp_widget_new (GP_WIDGET_SECTION, _("Persistent Settings"), §ion);
gp_widget_append (*window, section);
/* Date */
gp_widget_new (GP_WIDGET_DATE, _("Date and Time"), &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, ×tamp);
/* Auto Off Time */
gp_widget_new (GP_WIDGET_RANGE, _("Auto Off Time"), &widget);
gp_widget_append (section, widget);
gp_widget_set_range (widget, 1, 255, 1);
value_float = ((buf[AUTO_OFF_PTR] << 8) + buf[AUTO_OFF_PTR+1]) / 60;
gp_widget_set_value (widget, &value_float);
/* Resolution */
gp_widget_new (GP_WIDGET_RADIO, _("Resolution"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Low"));
gp_widget_add_choice (widget, _("Medium"));
gp_widget_add_choice (widget, _("High"));
switch (buf[RESOLUTION_PTR]) {
case 1:
gp_widget_set_value (widget, _("High"));
break;
case 2:
gp_widget_set_value (widget, _("Low"));
break;
case 0:
gp_widget_set_value (widget, _("Medium"));
break;
}
/* LCD */
gp_widget_new (GP_WIDGET_RADIO, _("LCD"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("On"));
gp_widget_add_choice (widget, _("Off"));
switch (buf[LCD_STATE_PTR]) {
case 0:
gp_widget_set_value (widget, _("On"));
break;
case 1:
gp_widget_set_value (widget, _("Off"));
break;
}
/* Icons */
gp_widget_new (GP_WIDGET_RADIO, _("Icons"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("On"));
gp_widget_add_choice (widget, _("Off"));
switch (buf[ICON_STATE_PTR]) {
case 0:
gp_widget_set_value (widget, _("On"));
break;
case 1:
gp_widget_set_value (widget, _("Off"));
break;
}
/****************/
/* Localization */
/****************/
gp_widget_new (GP_WIDGET_SECTION, _("Localization"), §ion);
gp_widget_append (*window, section);
/* Date format */
gp_widget_new (GP_WIDGET_MENU, _("Date Format"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Month/Day/Year"));
gp_widget_add_choice (widget, _("Day/Month/Year"));
gp_widget_add_choice (widget, _("Year/Month/Day"));
switch (buf[DATE_FORMAT_PTR]) {
case 0:
gp_widget_set_value (widget, _("Month/Day/Year"));
break;
case 1:
gp_widget_set_value (widget, _("Day/Month/Year"));
break;
case 2:
gp_widget_set_value (widget, _("Year/Month/Day"));
break;
}
/********************************/
/* Session-persistent Settings */
/********************************/
gp_widget_new (GP_WIDGET_SECTION, _("Session-persistent Settings"),
§ion);
gp_widget_append (*window, section);
/* Flash */
gp_widget_new (GP_WIDGET_RADIO, _("Flash"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Off"));
gp_widget_add_choice (widget, _("On"));
gp_widget_add_choice (widget, _("On, red-eye reduction"));
gp_widget_add_choice (widget, _("Auto"));
gp_widget_add_choice (widget, _("Auto, red-eye reduction"));
switch (buf[FLASH_STATE_PTR]) {
case 2:
gp_widget_set_value (widget, _("Off"));
break;
case 1:
if (buf[RED_EYE_STATE_PTR] == 1)
gp_widget_set_value (widget,
_("On, red-eye reduction"));
else
gp_widget_set_value (widget, _("On"));
break;
case 0:
if (buf[RED_EYE_STATE_PTR] == 1)
gp_widget_set_value (widget,
_("Auto, red-eye reduction"));
else
gp_widget_set_value (widget, _("Auto"));
break;
}
/* Exposure */
gp_widget_new (GP_WIDGET_RANGE, _("Exposure"), &widget);
gp_widget_append (section, widget);
gp_widget_set_range (widget, -2, 2, 0.1);
switch(buf[EXPOSURE_TIME_PTR]) {
case 0:
value_float = 0;
break;
case 1:
value_float = 0.3;
break;
case 2:
value_float = 0.5;
break;
case 3:
value_float = 0.8;
break;
case 4:
value_float = 1.0;
break;
case 5:
value_float = 1.3;
break;
case 6:
value_float = 1.5;
break;
case 7:
value_float = 1.8;
break;
case 8:
value_float = 2.0;
break;
case 0xF8:
value_float = -2.0;
break;
case 0xF9:
value_float = -1.8;
break;
case 0xFA:
value_float = -1.5;
break;
case 0xFB:
value_float = -1.3;
break;
case 0xFC:
value_float = -1.0;
break;
case 0xFD:
value_float = -0.8;
break;
case 0xFE:
value_float = -0.5;
break;
case 0xFF:
value_float = -0.3;
break;
}
gp_widget_set_value (widget, &value_float);
/* Focus */
gp_widget_new (GP_WIDGET_RADIO, _("Focus"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("2.0 m"));
gp_widget_add_choice (widget, _("0.5 m"));
gp_widget_add_choice (widget, _("0.1 m"));
gp_widget_add_choice (widget, _("Auto"));
switch (buf[FOCUS_PTR]) {
case 0:
gp_widget_set_value (widget, _("Auto"));
break;
case 1:
gp_widget_set_value (widget, _("2.0 m"));
break;
case 2:
gp_widget_set_value (widget, _("0.5 m"));
break;
case 3:
gp_widget_set_value (widget, _("0.1 m"));
break;
}
/* white balance */
gp_widget_new (GP_WIDGET_RADIO, _("White balance"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Office"));
gp_widget_add_choice (widget, _("Daylight"));
gp_widget_add_choice (widget, _("Auto"));
switch (buf[WHITE_BALANCE_PTR]) {
case 0:
gp_widget_set_value (widget, _("Auto"));
break;
case 1:
gp_widget_set_value (widget, _("Daylight"));
break;
case 2:
gp_widget_set_value (widget, _("Office"));
break;
}
/* Sharpness */
gp_widget_new (GP_WIDGET_RADIO, _("Sharpness"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Sharp"));
gp_widget_add_choice (widget, _("Soft"));
gp_widget_add_choice (widget, _("Auto"));
switch (buf[SHARPNESS_PTR]) {
case 0:
gp_widget_set_value (widget, _("Auto"));
break;
case 1:
gp_widget_set_value (widget, _("Sharp"));
break;
case 2:
gp_widget_set_value (widget, _("Soft"));
break;
}
/* Color */
gp_widget_new (GP_WIDGET_RADIO, _("Color"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Light"));
gp_widget_add_choice (widget, _("Deep"));
gp_widget_add_choice (widget, _("Black and White"));
gp_widget_add_choice (widget, _("Sepia"));
gp_widget_add_choice (widget, _("Auto"));
switch (buf[COLOR_PTR]) {
case 0:
gp_widget_set_value (widget, _("Auto"));
break;
case 1:
gp_widget_set_value (widget, _("Light"));
break;
case 2:
gp_widget_set_value (widget, _("Deep"));
break;
case 3:
gp_widget_set_value (widget, _("Black and White"));
break;
case 4:
gp_widget_set_value (widget, _("Sepia"));
break;
}
/* Macro */
gp_widget_new (GP_WIDGET_RADIO, _("Macro"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("On"));
gp_widget_add_choice (widget, _("Off"));
switch (buf[MACRO_PTR]) {
case 0:
gp_widget_set_value (widget, _("Off"));
break;
case 1:
gp_widget_set_value (widget, _("On"));
break;
}
/* Zoom */
gp_widget_new (GP_WIDGET_RADIO, _("Zoom"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("On"));
gp_widget_add_choice (widget, _("Off"));
switch (buf[ZOOM_PTR]) {
case 0:
gp_widget_set_value (widget, _("Off"));
break;
case 1:
gp_widget_set_value (widget, _("On"));
break;
}
/* Capture */
gp_widget_new (GP_WIDGET_RADIO, _("Capture"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Single"));
gp_widget_add_choice (widget, _("Sequence 9"));
switch (buf[CAPTURE_TYPE_PTR]) {
case 0:
gp_widget_set_value (widget, _("Single"));
break;
case 1:
gp_widget_set_value (widget, _("Sequence 9"));
break;
}
/* Date display */
gp_widget_new (GP_WIDGET_RADIO, _("Date display"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Anywhere"));
gp_widget_add_choice (widget, _("Play mode"));
gp_widget_add_choice (widget, _("Record mode"));
gp_widget_add_choice (widget, _("Everywhere"));
switch (buf[REC_DATE_DISP_PTR]) {
case 0:
if (buf[PLAY_DATE_DISP_PTR] == 0)
gp_widget_set_value (widget, _("Play mode"));
else
gp_widget_set_value (widget, _("Anywhere"));
break;
case 1:
if (buf[PLAY_DATE_DISP_PTR] == 0)
gp_widget_set_value (widget, _("Everywhere"));
else
gp_widget_set_value (widget, _("Record mode"));
break;
}
/************************/
/* Volatile Settings */
/************************/
gp_widget_new (GP_WIDGET_SECTION, _("Volatile Settings"), §ion);
gp_widget_append (*window, section);
/* Self Timer */
gp_widget_new (GP_WIDGET_RADIO, _("Self Timer"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Self Timer (next picture only)"));
gp_widget_add_choice (widget, _("Normal"));
switch (buf[TIMER_PTR]) {
case 1:
gp_widget_set_value (widget, _("Self Timer ("
"next picture only)"));
break;
case 0:
gp_widget_set_value (widget, _("Normal"));
break;
}
return (GP_OK);
}
static int
camera_get_config (Camera *camera, CameraWidget **window, GPContext *context)
{
CameraWidget *section, *widget;
CameraAbilities abilities;
GPPortSettings settings;
int i;
char * wvalue;
char stringbuffer[12];
dc210_status status;
if (dc210_get_status(camera, &status) == GP_ERROR) return GP_ERROR;
gp_widget_new (GP_WIDGET_WINDOW, _("Camera Configuration"), window);
gp_widget_new (GP_WIDGET_SECTION, _("File"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_RADIO, _("File type"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("JPEG"));
gp_widget_add_choice (widget, _("FlashPix"));
switch (status.file_type){
case DC210_FILE_TYPE_JPEG:
gp_widget_set_value (widget, _("JPEG")); break;
case DC210_FILE_TYPE_FPX:
gp_widget_set_value (widget, _("FlashPix")); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_RADIO, _("File resolution"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("640 x 480"));
gp_widget_add_choice (widget, _("1152 x 864"));
switch (status.resolution){
case DC210_FILE_640:
gp_widget_set_value (widget, _("640 x 480")); break;
case DC210_FILE_1152:
gp_widget_set_value (widget, _("1152 x 864")); break;
default:
DC210_DEBUG("Undefined value for file resolution.\n"); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_MENU, _("File compression"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Low (best quality)"));
gp_widget_add_choice (widget, _("Medium (better quality)"));
gp_widget_add_choice (widget, _("High (good quality)"));
switch (status.compression_type){
case DC210_LOW_COMPRESSION:
gp_widget_set_value (widget, _("Low (best quality)")); break;
case DC210_MEDIUM_COMPRESSION:
gp_widget_set_value (widget, _("Medium (better quality)")); break;
case DC210_HIGH_COMPRESSION:
gp_widget_set_value (widget, _("High (good quality)")); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_SECTION, _("Capture"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_MENU, _("Zoom"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, "58 mm"); /* no need to translate strings with SI units! */
gp_widget_add_choice (widget, "51 mm");
gp_widget_add_choice (widget, "41 mm");
gp_widget_add_choice (widget, "34 mm");
gp_widget_add_choice (widget, "29 mm");
gp_widget_add_choice (widget, _("Macro"));
switch (status.zoom){
case DC210_ZOOM_58:
gp_widget_set_value (widget, _("58 mm")); break;
case DC210_ZOOM_51:
gp_widget_set_value (widget, _("51 mm")); break;
case DC210_ZOOM_41:
gp_widget_set_value (widget, _("41 mm")); break;
case DC210_ZOOM_34:
gp_widget_set_value (widget, _("34 mm")); break;
case DC210_ZOOM_29:
gp_widget_set_value (widget, _("29 mm")); break;
case DC210_ZOOM_MACRO:
gp_widget_set_value (widget, _("Macro")); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_MENU, _("Exposure compensation"), &widget);
gp_widget_append (section, widget);
for (i = 0; i < sizeof(exp_comp)/sizeof(*exp_comp); i++){
gp_widget_add_choice (widget, exp_comp[i]);
if (status.exp_compensation + 4 == i)
gp_widget_set_value (widget, exp_comp[i]);
};
gp_widget_new (GP_WIDGET_RADIO, _("Flash"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("Auto"));
gp_widget_add_choice (widget, _("Force"));
gp_widget_add_choice (widget, _("None"));
switch (status.flash){
case DC210_FLASH_AUTO:
gp_widget_set_value (widget, _("Auto")); break;
case DC210_FLASH_FORCE:
gp_widget_set_value (widget, _("Force")); break;
case DC210_FLASH_NONE:
gp_widget_set_value (widget, _("None")); break;
};
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_RADIO, _("Red eye flash"), &widget);
gp_widget_append (section, widget);
gp_widget_add_choice (widget, _("On"));
gp_widget_add_choice (widget, _("Off"));
if (status.preflash)
gp_widget_set_value (widget, _("On"));
else
gp_widget_set_value (widget, _("Off"));
gp_widget_get_value (widget, &wvalue);
gp_widget_new (GP_WIDGET_SECTION, _("Other"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_BUTTON, "Set time to system time", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, dc210_system_time_callback);
gp_widget_set_info (widget, _("Set clock in camera"));
gp_camera_get_abilities(camera, &abilities);
gp_port_get_settings (camera->port, &settings);
gp_widget_new (GP_WIDGET_MENU, _("Port speed"), &widget);
gp_widget_append (section, widget);
for (i = 0; i < sizeof(abilities.speed); i++){
if (abilities.speed[i] == 0) break;
snprintf(stringbuffer, 12, "%d", abilities.speed[i]);
gp_widget_add_choice (widget, stringbuffer);
if (settings.serial.speed == abilities.speed[i])
gp_widget_set_value (widget, stringbuffer);
};
gp_widget_new (GP_WIDGET_TEXT, _("Album name"), &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, status.album_name);
gp_widget_set_info (widget, _("Name to set on card when formatting."));
gp_widget_new (GP_WIDGET_BUTTON, _("Format compact flash"), &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, dc210_format_callback);
gp_widget_set_info (widget, _("Format card and set album name."));
#ifdef DEBUG
gp_widget_new (GP_WIDGET_SECTION, _("Debug"), §ion);
gp_widget_append (*window, section);
gp_widget_new (GP_WIDGET_TEXT, "Parameter 1", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, "0");
gp_widget_new (GP_WIDGET_TEXT, "Parameter 2", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, "0");
gp_widget_new (GP_WIDGET_TEXT, "Parameter 3", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, "0");
gp_widget_new (GP_WIDGET_BUTTON, "Execute debug command", &widget);
gp_widget_append (section, widget);
gp_widget_set_value (widget, dc210_debug_callback);
gp_widget_set_info (widget, _("Execute predefined command\nwith parameter values."));
#endif
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);
}
