//Set the camera's quality to a certain choice
//Current Choices are:
// 0: Large Fine JPEG
// 2: Medium Fine JPEG
int QualityControl(int quality){
char qualString[20];
if(quality == currentQuality){ //We don't want to take up cycles changing nothing
return -1; //Could define set error codes, but we don't look at them anyway
}
strncpy(qualString, "", sizeof qualString); //Debatably necessary
if(quality == 0){
strncpy(qualString, "Large Fine JPEG", sizeof qualString);
}
else if(quality == 2){
strncpy(qualString, "Medium Fine JPEG", sizeof qualString);
}
else{
return -1;
}
CameraWidget* widget,* child;
if(gp_camera_get_config(getMyCamera(), &widget, getMyContext()) != 0){ //Get our current config
free(widget);
free(child);
return -1; //If it fails, we have failed.
}
//Widgets in libgphoto act sort of as trees of settings/data
//We need to find the right child of the top level, and the right child of that, etc.
//until we get down to the appropriate quality setting widget
//I already parsed through the tree and found the right child, and so
//have hard-coded the values to get to this child here
//Check out gphoto2-widget.c for more info
gp_widget_get_child(widget, 3, &child);
widget = child;
gp_widget_get_child(widget, 0, &child);
widget = child;
//Here we change the quality value to whatever we want
//For some reason, it is saved as a string, not a choice
//Don't ask me why.
gp_widget_set_value(widget, qualString);
gp_widget_get_root(widget, &child);
if(gp_camera_set_config(getMyCamera(), child, getMyContext()) != 0){ //Set the camera's config to our new, modified config
free(widget);
free(child);
return -1;
}
free(widget);
free(child);
currentQuality = quality; //Remember what quality we currently have
return 0;
}
static int
show_section (CmdConfig *cmd_config, CameraWidget *section)
{
CameraWidget *child, *parent;
CameraWidgetType type;
CDKSCROLL *scroll = NULL;
const char *label;
char *items[100];
int count, x, selection;
char title[1024];
int show_parent = 0, show_child = 0;
/* Create the scroll list */
gp_widget_get_type (section, &type);
gp_widget_get_label (section, &label);
snprintf (title, sizeof (title), "<C></5>%s", label);
if (type == GP_WIDGET_WINDOW)
items[0] = copyChar (_("Exit"));
else
items[0] = copyChar (_("Back"));
count = gp_widget_count_children (section);
for (x = 0; x < count; x++) {
gp_widget_get_child (section, x, &child);
gp_widget_get_label (child, &label);
items[x + 1] = copyChar ((char *) label);
}
count++;
scroll = newCDKScroll (cmd_config->screen, CENTER, CENTER, RIGHT,
10, 50, title,
items, count, NUMBERS, A_REVERSE, TRUE, FALSE);
if (!scroll)
return (GP_ERROR);
selection = activateCDKScroll (scroll, 0);
if (scroll->exitType == vNORMAL) {
if (selection)
show_child = selection;
else if (type != GP_WIDGET_WINDOW)
show_parent = 1;
}
/* Clean up */
destroyCDKScroll (scroll);
if (show_parent) {
gp_widget_get_parent (section, &parent);
show_widget (cmd_config, parent);
} else if (show_child) {
gp_widget_get_child (section, show_child - 1, &child);
show_widget (cmd_config, child);
}
return (GP_OK);
}
void _camera_build_property_menu (CameraWidget *widget,GtkMenu *menu, GCallback item_activate,gpointer user_data)
{
int childs = 0;
const char *sk;
CameraWidgetType type;
/* if widget has children lets add menutitem and recurse into container */
if( ( childs = gp_widget_count_children ( widget ) ) > 0 )
{
CameraWidget *child = NULL;
for (int i = 0 ; i < childs ; i++)
{
gp_widget_get_child (widget, i, &child);
gp_widget_get_name (child, &sk);
/* Check if widget is submenu */
if ( gp_widget_count_children (child) > 0 )
{
/* create submenu item */
GtkMenuItem *item = GTK_MENU_ITEM (gtk_menu_item_new_with_label (sk));
gtk_menu_item_set_submenu (item, gtk_menu_new ());
/* recurse into submenu */
_camera_build_property_menu (child, GTK_MENU (gtk_menu_item_get_submenu (item)), item_activate, user_data);
/* add submenu item to menu if not empty*/
if (gtk_container_get_children(GTK_CONTAINER(gtk_menu_item_get_submenu (item))) != NULL)
gtk_menu_shell_append(GTK_MENU_SHELL (menu),GTK_WIDGET (item));
}
else
{
/* check widget type */
gp_widget_get_type( child, &type );
if(
type == GP_WIDGET_MENU || type == GP_WIDGET_TEXT || type == GP_WIDGET_RADIO
)
{
/* construct menu item for property */
gp_widget_get_name (child, &sk);
GtkMenuItem *item = GTK_MENU_ITEM (gtk_menu_item_new_with_label (sk));
g_signal_connect (G_OBJECT (item), "activate", item_activate, user_data);
/* add submenu item to menu */
gtk_menu_shell_append(GTK_MENU_SHELL (menu),GTK_WIDGET (item));
}
}
}
}
}
void get_all_widgets(Camera *camera,GPContext *context,CameraWidget *widget, char *prefix,widgets_list_node *first)
{
int ret, n, i;
char *newprefix;
const char *label, *name, *uselabel;
CameraWidgetType type;
gp_widget_get_label (widget, &label);
/* fprintf(stderr,"label is %s\n", label); */
ret = gp_widget_get_name (widget, &name);
/* fprintf(stderr,"name is %s\n", name); */
gp_widget_get_type (widget, &type);
if (strlen(name))
uselabel = name;
else
uselabel = label;
n = gp_widget_count_children (widget);
newprefix = malloc(strlen(prefix)+1+strlen(uselabel)+1);
if (!newprefix)
{
abort();
}
sprintf(newprefix,"%s/%s",prefix,uselabel);
if ((type != GP_WIDGET_WINDOW) && (type != GP_WIDGET_SECTION))
{
// int readonly;
// gp_widget_get_readonly(widget,&readonly);
// printf("name: %s readonly: %i \n",name,readonly);
add_widget(&first,widget);
}
for (i=0; i<n; i++)
{
CameraWidget *child;
ret = gp_widget_get_child (widget, i, &child);
if (ret != GP_OK)
continue;
get_all_widgets(camera,context,child,newprefix,first);
}
free(newprefix);
}
/**
* Write all widget descriptions to @param os.
* @return maximum of widget ID
*/
int DigitalCameraCapture::collectWidgets(std::ostream & os,
CameraWidget * widget)
{
int id = widgetDescription(os, widget);
os << lineDelimiter;
widgets[id - noOfWidgets] = widget;
CameraWidget * child;
CameraWidgetType type;
CR(gp_widget_get_type(widget, &type));
if ((type == GP_WIDGET_WINDOW) || (type == GP_WIDGET_SECTION))
{
for (int x = 0; x < gp_widget_count_children(widget); x++)
{
CR(gp_widget_get_child(widget, x, &child));
id = std::max(id, collectWidgets(os, child));
}
}
return id;
}
static void
_get_widget_names (CameraWidget *widget, CameraList *list)
{
CameraWidgetType type;
gp_widget_get_type (widget, &type);
switch (type) {
case GP_WIDGET_MENU:
case GP_WIDGET_RADIO:
case GP_WIDGET_TEXT:
case GP_WIDGET_RANGE:
case GP_WIDGET_TOGGLE:
case GP_WIDGET_DATE: {
const char *name;
gp_widget_get_name (widget, &name);
gp_list_append (list, name, NULL);
break;
}
case GP_WIDGET_SECTION:
case GP_WIDGET_WINDOW: {
int i, nrofchildren;
nrofchildren = gp_widget_count_children (widget);
for (i = 0; i < nrofchildren; i++) {
CameraWidget *child;
gp_widget_get_child (widget, i, &child);
_get_widget_names (child, list);
}
break;
}
case GP_WIDGET_BUTTON:
default:
break;
}
}
void _camera_configuration_merge(const dt_camctl_t *c,const dt_camera_t *camera,CameraWidget *source, CameraWidget *destination, gboolean notify_all)
{
int childs = 0;
const char *sk;
const char *stv;
CameraWidget *dw;
const char *dtv;
CameraWidgetType type;
// If source widget has childs let's recurse into each children
if( ( childs = gp_widget_count_children ( source ) ) > 0 )
{
CameraWidget *child = NULL;
for( int i = 0 ; i < childs ; i++)
{
gp_widget_get_child( source, i, &child );
//gp_widget_get_name( source, &sk );
_camera_configuration_merge( c, camera,child, destination, notify_all );
}
}
else
{
gboolean changed = TRUE;
gp_widget_get_type( source, &type );
// Get the two keys to compare
gp_widget_get_name( source, &sk );
gp_widget_get_child_by_name ( destination, sk, &dw);
//
// First of all check if widget has change accessibility
//
/// TODO: Resolve this 2.4.8 libgphoto2 dependency
/*
int sa,da;
gp_widget_get_readonly( source, &sa );
gp_widget_get_readonly( dw, &da );
if( notify_all || ( sa != da ) ) {
// update destination widget to new accessibility if differ then notify of the change
if( ( sa != da ) )
gp_widget_set_readonly( dw, sa );
_dispatch_camera_property_accessibility_changed(c, camera,sk, ( sa == 1 ) ? TRUE: FALSE) ;
}
*/
//
// Lets compare values and notify on change or by notifyAll flag
//
if(
type == GP_WIDGET_MENU || type == GP_WIDGET_TEXT || type == GP_WIDGET_RADIO
)
{
// Get source and destination value to be compared
gp_widget_get_value( source, &stv );
gp_widget_get_value( dw, &dtv );
if( ( ( stv && dtv ) && strcmp( stv, dtv ) != 0 ) && ( changed = TRUE ) )
{
gp_widget_set_value( dw, stv );
// Dont flag this change as changed, otherwise a read-only widget might get tried
// to update the camera configuration...
gp_widget_set_changed( dw, 0 );
}
if( ( stv && dtv ) && ( notify_all || changed ) )
_dispatch_camera_property_value_changed(c,camera,sk,stv);
}
}
}
/**
* @brief QTLCamera::_getWidgets
* @param widgetList
* @param widget
* @param prefix
*/
void QTLCamera::_getWidgets(vector<QTLWidget> *widgetList, CameraWidget *widget,
char *prefix) {
int rc, n;
char *newprefix;
const char *label, *name, *uselabel;
CameraWidgetType type;
CameraWidget *rootConfig, *child;
QTLWidget qtlWidget;
gp_widget_get_label(widget, &label);
gp_widget_get_name(widget, &name);
gp_widget_get_type(widget, &type);
if (strlen(name)) {
uselabel = name;
} else {
uselabel = label;
}
n = gp_widget_count_children(widget);
newprefix = new char[strlen(prefix) + 1 + strlen(uselabel) + 1];
if (!newprefix) {
return;
}
sprintf(newprefix, "%s/%s", prefix, uselabel);
//XXX Was this supposed to be a conditional for the whole section?
// Assuming yes due to indenting.
qDebug() << "\tDetected widget: " << uselabel;
if ((type != GP_WIDGET_WINDOW) && (type != GP_WIDGET_SECTION)) {
rc = findWidgetByName(uselabel, &child, &rootConfig);
rc = gp_widget_get_type(child, &type);
rc = gp_widget_get_label(child, &label);
if (type == GP_WIDGET_RADIO) {
int count, i;
char *current;
rc = gp_widget_get_value(child, ¤t);
if (rc == GP_OK) {
count = gp_widget_count_choices(child);
if (type == GP_WIDGET_MENU) {
} else {
for (i=0; i<count; i++) {
const char *choice;
rc = gp_widget_get_choice(child, i, &choice);
qtlWidget.choices.push_back(choice);
qDebug() << "\t\tDetected choice: " << choice;
}
qtlWidget.title = label;
qtlWidget.name = name;
qtlWidget.defaultChoice = current;
qtlWidget.choiceLabel = uselabel;
params->widgetList->push_back(qtlWidget);
}
}
}
}
for (int i = 0; i < n; i++) {
CameraWidget *child;
rc = gp_widget_get_child(widget, i, &child);
if (rc != GP_OK) {
continue;
}
_getWidgets(widgetList, child, newprefix);
}
free(newprefix);
}
void GPConfigDlg::appendWidget(QWidget* parent, CameraWidget* widget)
{
QWidget* newParent = parent;
CameraWidgetType widget_type;
const char* widget_name;
const char* widget_info;
const char* widget_label;
float widget_value_float;
int widget_value_int;
const char* widget_value_string;
gp_widget_get_type(widget, &widget_type);
gp_widget_get_label(widget, &widget_label);
gp_widget_get_info(widget, &widget_info);
gp_widget_get_name(widget, &widget_name);
// gphoto2 doesn't seem to have any standard for i18n
QString whats_this = QString::fromLocal8Bit(widget_info);
// Add this widget to parent
switch (widget_type)
{
case GP_WIDGET_WINDOW:
{
setCaption(widget_label);
break;
}
case GP_WIDGET_SECTION:
{
if (!d->tabWidget)
{
d->tabWidget = new QTabWidget(parent);
parent->layout()->addWidget(d->tabWidget);
}
QWidget* tab = new QWidget(d->tabWidget);
// widgets are to be aligned vertically in the tab
QVBoxLayout* tabLayout = new QVBoxLayout(tab, marginHint(),
spacingHint());
d->tabWidget->insertTab(tab, widget_label);
KVBox* tabContainer = new KVBox(tab);
tabContainer->setSpacing(spacingHint());
tabLayout->addWidget(tabContainer);
newParent = tabContainer;
tabLayout->addStretch();
break;
}
case GP_WIDGET_TEXT:
{
gp_widget_get_value(widget, &widget_value_string);
Q3Grid* grid = new Q3Grid(2, Qt::Horizontal, parent);
parent->layout()->addWidget(grid);
grid->setSpacing(spacingHint());
new QLabel(QString::fromLocal8Bit(widget_label) + ':', grid);
QLineEdit* lineEdit = new QLineEdit(widget_value_string, grid);
d->wmap.insert(widget, lineEdit);
if (!whats_this.isEmpty())
{
grid->setWhatsThis(whats_this);
}
break;
}
case GP_WIDGET_RANGE:
{
float widget_low;
float widget_high;
float widget_increment;
gp_widget_get_range(widget, &widget_low, &widget_high, &widget_increment);
gp_widget_get_value(widget, &widget_value_float);
Q3GroupBox* groupBox = new Q3GroupBox(1, Qt::Horizontal, widget_label, parent);
parent->layout()->addWidget(groupBox);
QSlider* slider = new QSlider(
(int)widget_low,
(int)widget_high,
(int)widget_increment,
(int)widget_value_float,
Qt::Horizontal,
groupBox);
d->wmap.insert(widget, slider);
if (!whats_this.isEmpty())
{
groupBox->setWhatsThis(whats_this);
}
break;
}
case GP_WIDGET_TOGGLE:
{
gp_widget_get_value(widget, &widget_value_int);
QCheckBox* checkBox = new QCheckBox(widget_label, parent);
parent->layout()->addWidget(checkBox);
checkBox->setChecked(widget_value_int);
d->wmap.insert(widget, checkBox);
if (!whats_this.isEmpty())
{
checkBox->setWhatsThis(whats_this);
}
break;
}
case GP_WIDGET_RADIO:
{
gp_widget_get_value(widget, &widget_value_string);
int count = gp_widget_count_choices(widget);
// for less than 5 options, align them horizontally
Q3ButtonGroup* buttonGroup;
if (count > 4)
{
buttonGroup = new Q3VButtonGroup(widget_label, parent);
}
else
{
buttonGroup = new Q3HButtonGroup(widget_label, parent);
}
parent->layout()->addWidget(buttonGroup);
for (int i = 0; i < count; ++i)
{
const char* widget_choice;
gp_widget_get_choice(widget, i, &widget_choice);
new QRadioButton(widget_choice, buttonGroup);
if (!strcmp(widget_value_string, widget_choice))
{
buttonGroup->setButton(i);
}
}
d->wmap.insert(widget, buttonGroup);
if (!whats_this.isEmpty())
{
buttonGroup->setWhatsThis(whats_this);
}
break;
}
case GP_WIDGET_MENU:
{
gp_widget_get_value(widget, &widget_value_string);
QComboBox* comboBox = new KComboBox(parent);
parent->layout()->addWidget(comboBox);
comboBox->clear();
for (int i = 0; i < gp_widget_count_choices(widget); ++i)
{
const char* widget_choice;
gp_widget_get_choice(widget, i, &widget_choice);
comboBox->insertItem(widget_choice);
if (!strcmp(widget_value_string, widget_choice))
{
comboBox->setCurrentItem(i);
}
}
d->wmap.insert(widget, comboBox);
if (!whats_this.isEmpty())
{
comboBox->setWhatsThis(whats_this);
}
break;
}
case GP_WIDGET_BUTTON:
{
// TODO
// I can't see a way of implementing this. Since there is
// no way of telling which button sent you a signal, we
// can't map to the appropriate widget->callback
QLabel* label = new QLabel(i18n("Button (not supported by KControl)"), parent);
parent->layout()->addWidget(label);
break;
}
case GP_WIDGET_DATE:
{
// TODO
QLabel* label = new QLabel(i18n("Date (not supported by KControl)"), parent);
parent->layout()->addWidget(label);
break;
}
default:
return;
}
// Append all this widgets children
for (int i = 0; i < gp_widget_count_children(widget); ++i)
{
CameraWidget* widget_child;
gp_widget_get_child(widget, i, &widget_child);
appendWidget(newParent, widget_child);
}
// Things that must be done after all children were added
/*
switch (widget_type) {
case GP_WIDGET_SECTION:
{
tabLayout->addItem( new QSpacerItem(0, 0, QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding) );
break;
}
}
*/
}
void GPConfigDlg::updateWidgetValue(CameraWidget* widget)
{
CameraWidgetType widget_type;
gp_widget_get_type(widget, &widget_type);
switch (widget_type)
{
case GP_WIDGET_WINDOW:
// nothing to do
break;
case GP_WIDGET_SECTION:
// nothing to do
break;
case GP_WIDGET_TEXT:
{
QLineEdit* lineEdit = static_cast<QLineEdit*>(d->wmap[widget]);
gp_widget_set_value(widget, (void*)lineEdit->text().toLocal8Bit().data());
break;
}
case GP_WIDGET_RANGE:
{
QSlider* slider = static_cast<QSlider*>(d->wmap[widget]);
float value_float = slider->value();
gp_widget_set_value(widget, (void*)&value_float);
break;
}
case GP_WIDGET_TOGGLE:
{
QCheckBox* checkBox = static_cast<QCheckBox*>(d->wmap[widget]);
int value_int = checkBox->isChecked() ? 1 : 0;
gp_widget_set_value(widget, (void*)&value_int);
break;
}
case GP_WIDGET_RADIO:
{
Q3ButtonGroup* buttonGroup = static_cast<Q3VButtonGroup*>(d->wmap[widget]);
gp_widget_set_value(widget, (void*)buttonGroup->selected()->text().toLocal8Bit().data());
break;
}
case GP_WIDGET_MENU:
{
QComboBox* comboBox = static_cast<QComboBox*>(d->wmap[widget]);
gp_widget_set_value(widget, (void*)comboBox->currentText().toLocal8Bit().data());
break;
}
case GP_WIDGET_BUTTON:
// nothing to do
break;
case GP_WIDGET_DATE:
{
// not implemented
break;
}
}
// Copy child widget values
for (int i = 0; i < gp_widget_count_children(widget); ++i)
{
CameraWidget* widget_child;
gp_widget_get_child(widget, i, &widget_child);
updateWidgetValue(widget_child);
}
}
