← Back to branch summary

~ubuntu-branches/ubuntu/saucy/darktable/saucy

« back to all changes in this revision

Viewing changes to src/gui/presets.c

  • Committer: Bazaar Package Importer
  • Author(s): David Bremner
  • Date: 2011-04-14 23:42:12 UTC
  • Revision ID: james.westby@ubuntu.com-20110414234212-kuffcz5wiu18v6ra
Tags: upstream-0.8
Import upstream version 0.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui/presets.c
 
1
/*
 
2
    This file is part of darktable,
 
3
    copyright (c) 2009--2010 johannes hanika.
 
4
 
 
5
    darktable is free software: you can redistribute it and/or modify
 
6
    it under the terms of the GNU General Public License as published by
 
7
    the Free Software Foundation, either version 3 of the License, or
 
8
    (at your option) any later version.
 
9
 
 
10
    darktable is distributed in the hope that it will be useful,
 
11
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
    GNU General Public License for more details.
 
14
 
 
15
    You should have received a copy of the GNU General Public License
 
16
    along with darktable.  If not, see <http://www.gnu.org/licenses/>.
 
17
*/
 
18
 
 
19
#ifdef HAVE_CONFIG_H
 
20
#include "config.h"
 
21
#endif
 
22
#include "common/darktable.h"
 
23
#include "common/debug.h"
 
24
#include "gui/gtk.h"
 
25
#include <stdlib.h>
 
26
 
 
27
 
 
28
static const int   dt_gui_presets_exposure_value_cnt = 24;
 
29
static const float dt_gui_presets_exposure_value[] =
 
30
{
 
31
  0., 1./8000, 1./4000, 1./2000, 1./1000, 1./1000, 1./500, 1./250, 1./125, 1./60, 1./30, 1./15,
 
32
  1./15, 1./8, 1./4, 1./2, 1, 2, 4, 8, 15, 30, 60, FLT_MAX
 
33
};
 
34
static const char* dt_gui_presets_exposure_value_str[] =
 
35
{
 
36
  "0", "1/8000", "1/4000", "1/2000", "1/1000", "1/1000", "1/500", "1/250", "1/125", "1/60", "1/30", "1/15",
 
37
  "1/15", "1/8", "1/4", "1/2", "1\"", "2\"", "4\"", "8\"", "15\"", "30\"", "60\"", "+"
 
38
};
 
39
static const int   dt_gui_presets_aperture_value_cnt = 19;
 
40
static const float dt_gui_presets_aperture_value[] = {0, 0.5, 0.7, 1.0, 1.4, 2.0, 2.8, 4.0, 5.6, 8.0, 11.0, 16.0,
 
41
    22.0, 32.0, 45.0, 64.0, 90.0, 128.0, FLT_MAX
 
42
                                                     };
 
43
static const char* dt_gui_presets_aperture_value_str[] = {"f/0", "f/0.5", "f/0.7", "f/1.0", "f/1.4", "f/2",
 
44
    "f/2.8", "f/4", "f/5.6", "f/8", "f/11", "f/16", "f/22", "f/32", "f/45", "f/64", "f/90", "f/128", "f/+"
 
45
                                                         };
 
46
 
 
47
typedef struct dt_gui_presets_edit_dialog_t
 
48
{
 
49
  dt_iop_module_t *module;
 
50
  GtkEntry *name, *description;
 
51
  GtkCheckButton *autoapply, *filter;
 
52
  GtkBox *details;
 
53
  GtkEntry *model, *maker, *lens;
 
54
  GtkSpinButton *iso_min, *iso_max;
 
55
  GtkComboBox *exposure_min, *exposure_max;
 
56
  GtkComboBox *aperture_min, *aperture_max;
 
57
  GtkSpinButton *focal_length_min, *focal_length_max;
 
58
}
 
59
dt_gui_presets_edit_dialog_t;
 
60
 
 
61
void dt_gui_presets_init()
 
62
{
 
63
  // create table or fail if it is already there.
 
64
  sqlite3_exec(darktable.db, "create table presets "
 
65
               "(name varchar, description varchar, operation varchar, op_params blob, enabled integer, "
 
66
               "model varchar, maker varchar, lens varchar, "
 
67
               "iso_min real, iso_max real, exposure_min real, exposure_max real, aperture_min real, aperture_max real, "
 
68
               "focal_length_min real, focal_length_max real, "
 
69
               "writeprotect integer, autoapply integer, filter integer, def integer, isldr integer)", NULL, NULL, NULL);
 
70
  // remove auto generated presets from plugins, not the user included ones.
 
71
  DT_DEBUG_SQLITE3_EXEC(darktable.db, "delete from presets where writeprotect=1", NULL, NULL, NULL);
 
72
}
 
73
 
 
74
void dt_gui_presets_add_generic(const char *name, dt_dev_operation_t op, const void *params, const int32_t params_size, const int32_t enabled)
 
75
{
 
76
  sqlite3_stmt *stmt;
 
77
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "delete from presets where name=?1 and operation=?2", -1, &stmt, NULL);
 
78
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, strlen(name), SQLITE_TRANSIENT);
 
79
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, op, strlen(op), SQLITE_TRANSIENT);
 
80
  sqlite3_step(stmt);
 
81
  sqlite3_finalize(stmt);
 
82
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "insert into presets values (?1, '', ?2, ?3, ?4, '%', '%', '%', 0, 51200, 0, 10000000, 0, 100000000, 0, 1000, 1, 0, 0, 0, 0)", -1, &stmt, NULL);
 
83
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, strlen(name), SQLITE_TRANSIENT);
 
84
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, op, strlen(op), SQLITE_TRANSIENT);
 
85
  DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 3, params, params_size, SQLITE_TRANSIENT);
 
86
  DT_DEBUG_SQLITE3_BIND_INT(stmt, 4, enabled);
 
87
  sqlite3_step(stmt);
 
88
  sqlite3_finalize(stmt);
 
89
}
 
90
 
 
91
static gchar*
 
92
get_preset_name(GtkMenuItem *menuitem)
 
93
{
 
94
  const gchar *name = gtk_label_get_label(GTK_LABEL(gtk_bin_get_child(GTK_BIN(menuitem))));
 
95
  const gchar *c = name;
 
96
  // remove <-> markup tag at beginning.
 
97
  if(*c == '<')
 
98
  {
 
99
    while(*c != '>') c++;
 
100
    c++;
 
101
  }
 
102
  gchar *pn = g_strdup(c);
 
103
  gchar *c2 = pn;
 
104
  // possibly remove trailing <-> markup tag
 
105
  while(*c2 != '<' && *c2 != '\0') c2++;
 
106
  if(*c2 == '<') *c2 = '\0';
 
107
  c2 = g_strrstr(pn, _("(default)"));
 
108
  if(c2 && c2 > pn) *(c2-1) = '\0';
 
109
  return pn;
 
110
}
 
111
 
 
112
static gchar*
 
113
get_active_preset_name(dt_iop_module_t *module)
 
114
{
 
115
  sqlite3_stmt *stmt;
 
116
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "select name, op_params, writeprotect from presets where operation=?1", -1, &stmt, NULL);
 
117
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
118
  gchar *name = NULL;
 
119
  // collect all presets for op from db
 
120
  while(sqlite3_step(stmt) == SQLITE_ROW)
 
121
  {
 
122
    void *op_params = (void *)sqlite3_column_blob(stmt, 1);
 
123
    int32_t op_params_size = sqlite3_column_bytes(stmt, 1);
 
124
    if(!memcmp(module->params, op_params, MIN(op_params_size, module->params_size)))
 
125
    {
 
126
      name = g_strdup((char *)sqlite3_column_text(stmt, 0));
 
127
      break;
 
128
    }
 
129
  }
 
130
  sqlite3_finalize(stmt);
 
131
  return name;
 
132
}
 
133
 
 
134
static void
 
135
menuitem_delete_preset (GtkMenuItem *menuitem, dt_iop_module_t *module)
 
136
{
 
137
  sqlite3_stmt *stmt;
 
138
  gchar *name = get_active_preset_name(module);
 
139
  if(name == NULL) return;
 
140
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "delete from presets where name=?1 and operation=?2 and writeprotect=0", -1, &stmt, NULL);
 
141
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, strlen(name), SQLITE_TRANSIENT);
 
142
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
143
  sqlite3_step(stmt);
 
144
  sqlite3_finalize(stmt);
 
145
  g_free(name);
 
146
}
 
147
 
 
148
static void
 
149
edit_preset_response(GtkDialog *dialog, gint response_id, dt_gui_presets_edit_dialog_t *g)
 
150
{
 
151
  // commit all the user input fields
 
152
  sqlite3_stmt *stmt;
 
153
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "insert into presets values (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, 0, ?17, ?18, 0, 0)", -1, &stmt, NULL);
 
154
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, gtk_entry_get_text(g->name), strlen(gtk_entry_get_text(g->name)), SQLITE_TRANSIENT);
 
155
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, gtk_entry_get_text(g->description), strlen(gtk_entry_get_text(g->description)), SQLITE_TRANSIENT);
 
156
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, g->module->op, strlen(g->module->op), SQLITE_TRANSIENT);
 
157
  DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 4, g->module->params, g->module->params_size, SQLITE_TRANSIENT);
 
158
  DT_DEBUG_SQLITE3_BIND_INT(stmt, 5, g->module->enabled);
 
159
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 6, gtk_entry_get_text(g->model), strlen(gtk_entry_get_text(g->model)), SQLITE_TRANSIENT);
 
160
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 7, gtk_entry_get_text(g->maker), strlen(gtk_entry_get_text(g->maker)), SQLITE_TRANSIENT);
 
161
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 8, gtk_entry_get_text(g->lens), strlen(gtk_entry_get_text(g->lens)), SQLITE_TRANSIENT);
 
162
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt,  9, gtk_spin_button_get_value(g->iso_min));
 
163
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 10, gtk_spin_button_get_value(g->iso_max));
 
164
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 11, dt_gui_presets_exposure_value[gtk_combo_box_get_active(g->exposure_min)]);
 
165
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 12, dt_gui_presets_exposure_value[gtk_combo_box_get_active(g->exposure_max)]);
 
166
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 13, dt_gui_presets_aperture_value[gtk_combo_box_get_active(g->aperture_min)]);
 
167
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 14, dt_gui_presets_aperture_value[gtk_combo_box_get_active(g->aperture_max)]);
 
168
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 15, gtk_spin_button_get_value(g->focal_length_min));
 
169
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 16, gtk_spin_button_get_value(g->focal_length_max));
 
170
  DT_DEBUG_SQLITE3_BIND_INT(stmt, 17, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->autoapply)));
 
171
  DT_DEBUG_SQLITE3_BIND_INT(stmt, 18, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->filter)));
 
172
  sqlite3_step(stmt);
 
173
  sqlite3_finalize(stmt);
 
174
 
 
175
  gtk_widget_destroy(GTK_WIDGET(dialog));
 
176
  free(g);
 
177
}
 
178
 
 
179
static void
 
180
check_buttons_activated (GtkCheckButton *button, dt_gui_presets_edit_dialog_t *g)
 
181
{
 
182
  if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->autoapply)) || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->filter)))
 
183
  {
 
184
    gtk_widget_set_visible(GTK_WIDGET(g->details), TRUE);
 
185
    gtk_widget_set_no_show_all(GTK_WIDGET(g->details), FALSE);
 
186
    gtk_widget_show_all (GTK_WIDGET(g->details));
 
187
    gtk_widget_set_no_show_all(GTK_WIDGET(g->details), TRUE);
 
188
  }
 
189
  else
 
190
    gtk_widget_set_visible(GTK_WIDGET(g->details), FALSE);
 
191
}
 
192
 
 
193
static void
 
194
edit_preset (const char *name_in, dt_iop_module_t *module)
 
195
{
 
196
  gchar *name = NULL;
 
197
  if(name_in == NULL)
 
198
  {
 
199
    name = get_active_preset_name(module);
 
200
    if(name == NULL) return;
 
201
  }
 
202
  else name = g_strdup(name_in);
 
203
 
 
204
  GtkWidget *dialog;
 
205
  /* Create the widgets */
 
206
  char title[1024];
 
207
  GtkWidget *window = glade_xml_get_widget (darktable.gui->main_window, "main_window");
 
208
  snprintf(title, 1024, _("edit `%s' for module `%s'"), name, module->name());
 
209
  dialog = gtk_dialog_new_with_buttons (title,
 
210
                                        GTK_WINDOW(window),
 
211
                                        GTK_DIALOG_DESTROY_WITH_PARENT,
 
212
                                        GTK_STOCK_OK,
 
213
                                        GTK_RESPONSE_NONE,
 
214
                                        NULL);
 
215
  GtkContainer *content_area = GTK_CONTAINER(gtk_dialog_get_content_area (GTK_DIALOG (dialog)));
 
216
  GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
 
217
  gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 5, 5, 5, 5);
 
218
  gtk_container_add (content_area, alignment);
 
219
  GtkBox *box = GTK_BOX(gtk_vbox_new(FALSE, 5));
 
220
  gtk_container_add (GTK_CONTAINER(alignment), GTK_WIDGET(box));
 
221
  GtkWidget *label;
 
222
  // GtkBox *vbox1 = GTK_BOX(gtk_vbox_new(TRUE, 5));
 
223
 
 
224
  GtkBox *vbox2 = GTK_BOX(gtk_vbox_new(TRUE, 5));
 
225
  GtkBox *vbox3 = GTK_BOX(gtk_vbox_new(TRUE, 5));
 
226
  GtkBox *vbox4 = GTK_BOX(gtk_vbox_new(TRUE, 5));
 
227
 
 
228
  dt_gui_presets_edit_dialog_t *g = (dt_gui_presets_edit_dialog_t *)malloc(sizeof(dt_gui_presets_edit_dialog_t));
 
229
  g->module = module;
 
230
  g->name = GTK_ENTRY(gtk_entry_new());
 
231
  gtk_entry_set_text(g->name, name);
 
232
  gtk_box_pack_start(box, GTK_WIDGET(g->name), FALSE, FALSE, 0);
 
233
  gtk_object_set(GTK_OBJECT(g->name), "tooltip-text", _("name of the preset"), (char *)NULL);
 
234
 
 
235
  g->description = GTK_ENTRY(gtk_entry_new());
 
236
  gtk_box_pack_start(box, GTK_WIDGET(g->description), FALSE, FALSE, 0);
 
237
  gtk_object_set(GTK_OBJECT(g->description), "tooltip-text", _("description or further information"), (char *)NULL);
 
238
 
 
239
  g->autoapply = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("auto apply this preset to matching images")));
 
240
  gtk_box_pack_start(box, GTK_WIDGET(g->autoapply), FALSE, FALSE, 0);
 
241
  g->filter = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("only show this preset for matching images")));
 
242
  gtk_object_set(GTK_OBJECT(g->filter), "tooltip-text", _("be very careful with this option. this might be the last time you see your preset."), (char *)NULL);
 
243
  gtk_box_pack_start(box, GTK_WIDGET(g->filter), FALSE, FALSE, 0);
 
244
  g_signal_connect(G_OBJECT(g->autoapply), "toggled", G_CALLBACK(check_buttons_activated), g);
 
245
  g_signal_connect(G_OBJECT(g->filter),    "toggled", G_CALLBACK(check_buttons_activated), g);
 
246
 
 
247
  g->details   = GTK_BOX(gtk_hbox_new(FALSE, 0));
 
248
  GtkBox *hbox = GTK_BOX(gtk_hbox_new(TRUE, 5));
 
249
  gtk_box_pack_start(box,  GTK_WIDGET(g->details),  FALSE, FALSE, 0);
 
250
  gtk_box_pack_start(g->details, GTK_WIDGET(hbox),  FALSE, FALSE, 0);
 
251
  gtk_box_pack_start(hbox, GTK_WIDGET(vbox2), TRUE, TRUE, 0);
 
252
  gtk_box_pack_start(hbox, GTK_WIDGET(vbox3), TRUE, TRUE, 0);
 
253
  gtk_box_pack_start(hbox, GTK_WIDGET(vbox4), TRUE, TRUE, 0);
 
254
 
 
255
  // model, maker, lens
 
256
  g->model = GTK_ENTRY(gtk_entry_new());
 
257
  gtk_object_set(GTK_OBJECT(g->model), "tooltip-text", _("string to match model (use % as wildcard)"), (char *)NULL);
 
258
  label = gtk_label_new(_("model"));
 
259
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
 
260
  gtk_box_pack_start(vbox2, label, FALSE, FALSE, 0);
 
261
  gtk_box_pack_start(vbox3, GTK_WIDGET(g->model), FALSE, FALSE, 0);
 
262
  gtk_box_pack_start(vbox4, gtk_label_new(""), FALSE, FALSE, 0);
 
263
  g->maker = GTK_ENTRY(gtk_entry_new());
 
264
  gtk_object_set(GTK_OBJECT(g->maker), "tooltip-text", _("string to match maker (use % as wildcard)"), (char *)NULL);
 
265
  label = gtk_label_new(_("maker"));
 
266
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
 
267
  gtk_box_pack_start(vbox2, label, FALSE, FALSE, 0);
 
268
  gtk_box_pack_start(vbox3, GTK_WIDGET(g->maker), FALSE, FALSE, 0);
 
269
  gtk_box_pack_start(vbox4, gtk_label_new(""), FALSE, FALSE, 0);
 
270
  g->lens  = GTK_ENTRY(gtk_entry_new());
 
271
  gtk_object_set(GTK_OBJECT(g->lens), "tooltip-text", _("string to match lens (use % as wildcard)"), (char *)NULL);
 
272
  label = gtk_label_new(_("lens"));
 
273
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
 
274
  gtk_box_pack_start(vbox2, label, FALSE, FALSE, 0);
 
275
  gtk_box_pack_start(vbox3, GTK_WIDGET(g->lens), FALSE, FALSE, 0);
 
276
  gtk_box_pack_start(vbox4, gtk_label_new(""), FALSE, FALSE, 0);
 
277
 
 
278
  // iso
 
279
  label = gtk_label_new(_("iso"));
 
280
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
 
281
  gtk_box_pack_start(vbox2, label, FALSE, FALSE, 0);
 
282
  g->iso_min = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 51200, 100));
 
283
  gtk_object_set(GTK_OBJECT(g->iso_min), "tooltip-text", _("minimum iso value"), (char *)NULL);
 
284
  gtk_spin_button_set_digits(g->iso_min, 0);
 
285
  gtk_box_pack_start(vbox3, GTK_WIDGET(g->iso_min), FALSE, FALSE, 0);
 
286
  g->iso_max = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 51200, 100));
 
287
  gtk_object_set(GTK_OBJECT(g->iso_max), "tooltip-text", _("maximum iso value"), (char *)NULL);
 
288
  gtk_spin_button_set_digits(g->iso_max, 0);
 
289
  gtk_box_pack_start(vbox4, GTK_WIDGET(g->iso_max), FALSE, FALSE, 0);
 
290
 
 
291
  // exposure
 
292
  label = gtk_label_new(_("exposure"));
 
293
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
 
294
  gtk_box_pack_start(vbox2, label, FALSE, FALSE, 0);
 
295
  g->exposure_min = GTK_COMBO_BOX(gtk_combo_box_new_text());
 
296
  g->exposure_max = GTK_COMBO_BOX(gtk_combo_box_new_text());
 
297
  gtk_object_set(GTK_OBJECT(g->exposure_min), "tooltip-text", _("minimum exposure time"), (char *)NULL);
 
298
  gtk_object_set(GTK_OBJECT(g->exposure_max), "tooltip-text", _("maximum exposure time"), (char *)NULL);
 
299
  for(int k=0; k<dt_gui_presets_exposure_value_cnt; k++)
 
300
    gtk_combo_box_append_text(g->exposure_min, dt_gui_presets_exposure_value_str[k]);
 
301
  for(int k=0; k<dt_gui_presets_exposure_value_cnt; k++)
 
302
    gtk_combo_box_append_text(g->exposure_max, dt_gui_presets_exposure_value_str[k]);
 
303
  gtk_box_pack_start(vbox3, GTK_WIDGET(g->exposure_min), FALSE, FALSE, 0);
 
304
  gtk_box_pack_start(vbox4, GTK_WIDGET(g->exposure_max), FALSE, FALSE, 0);
 
305
 
 
306
  // aperture
 
307
  label = gtk_label_new(_("aperture"));
 
308
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
 
309
  gtk_box_pack_start(vbox2, label, FALSE, FALSE, 0);
 
310
  g->aperture_min = GTK_COMBO_BOX(gtk_combo_box_new_text());
 
311
  g->aperture_max = GTK_COMBO_BOX(gtk_combo_box_new_text());
 
312
  gtk_object_set(GTK_OBJECT(g->aperture_min), "tooltip-text", _("minimum aperture value"), (char *)NULL);
 
313
  gtk_object_set(GTK_OBJECT(g->aperture_max), "tooltip-text", _("maximum aperture value"), (char *)NULL);
 
314
  for(int k=0; k<dt_gui_presets_aperture_value_cnt; k++)
 
315
    gtk_combo_box_append_text(g->aperture_min, dt_gui_presets_aperture_value_str[k]);
 
316
  for(int k=0; k<dt_gui_presets_aperture_value_cnt; k++)
 
317
    gtk_combo_box_append_text(g->aperture_max, dt_gui_presets_aperture_value_str[k]);
 
318
  gtk_box_pack_start(vbox3, GTK_WIDGET(g->aperture_min), FALSE, FALSE, 0);
 
319
  gtk_box_pack_start(vbox4, GTK_WIDGET(g->aperture_max), FALSE, FALSE, 0);
 
320
 
 
321
  // focal length
 
322
  label = gtk_label_new(_("focal length"));
 
323
  gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
 
324
  gtk_box_pack_start(vbox2, label, FALSE, FALSE, 0);
 
325
  g->focal_length_min = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 1000, 10));
 
326
  gtk_spin_button_set_digits(g->focal_length_min, 0);
 
327
  gtk_box_pack_start(vbox3, GTK_WIDGET(g->focal_length_min), FALSE, FALSE, 0);
 
328
  g->focal_length_max = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 1000, 10));
 
329
  gtk_object_set(GTK_OBJECT(g->focal_length_min), "tooltip-text", _("minimum focal length"), (char *)NULL);
 
330
  gtk_object_set(GTK_OBJECT(g->focal_length_max), "tooltip-text", _("maximum focal length"), (char *)NULL);
 
331
  gtk_spin_button_set_digits(g->focal_length_max, 0);
 
332
  gtk_box_pack_start(vbox4, GTK_WIDGET(g->focal_length_max), FALSE, FALSE, 0);
 
333
 
 
334
  gtk_widget_set_no_show_all(GTK_WIDGET(g->details), TRUE);
 
335
 
 
336
  sqlite3_stmt *stmt;
 
337
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "select description, model, maker, lens, iso_min, iso_max, exposure_min, exposure_max, aperture_min, aperture_max, focal_length_min, focal_length_max, autoapply, filter from presets where name = ?1 and operation = ?2", -1, &stmt, NULL);
 
338
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, strlen(name), SQLITE_TRANSIENT);
 
339
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
340
  if(sqlite3_step(stmt) == SQLITE_ROW)
 
341
  {
 
342
    gtk_entry_set_text(g->description, (const char *)sqlite3_column_text(stmt, 0));
 
343
    gtk_entry_set_text(g->model, (const char *)sqlite3_column_text(stmt, 1));
 
344
    gtk_entry_set_text(g->maker, (const char *)sqlite3_column_text(stmt, 2));
 
345
    gtk_entry_set_text(g->lens,  (const char *)sqlite3_column_text(stmt, 3));
 
346
    gtk_spin_button_set_value(g->iso_min, sqlite3_column_double(stmt, 4));
 
347
    gtk_spin_button_set_value(g->iso_max, sqlite3_column_double(stmt, 5));
 
348
 
 
349
    float val = sqlite3_column_double(stmt, 6);
 
350
    int k=0;
 
351
    for(; k<dt_gui_presets_exposure_value_cnt&&val>dt_gui_presets_exposure_value[k]; k++);
 
352
    gtk_combo_box_set_active(g->exposure_min, k);
 
353
    val = sqlite3_column_double(stmt, 7);
 
354
    for(k=0; k<dt_gui_presets_exposure_value_cnt&&val>dt_gui_presets_exposure_value[k]; k++);
 
355
    gtk_combo_box_set_active(g->exposure_max, k);
 
356
    val = sqlite3_column_double(stmt, 8);
 
357
    for(k=0; k<dt_gui_presets_aperture_value_cnt&&val>dt_gui_presets_aperture_value[k]; k++);
 
358
    gtk_combo_box_set_active(g->aperture_min, k);
 
359
    val = sqlite3_column_double(stmt, 9);
 
360
    for(k=0; k<dt_gui_presets_aperture_value_cnt&&val>dt_gui_presets_aperture_value[k]; k++);
 
361
    gtk_combo_box_set_active(g->aperture_max, k);
 
362
    gtk_spin_button_set_value(g->focal_length_min, sqlite3_column_double(stmt, 10));
 
363
    gtk_spin_button_set_value(g->focal_length_max, sqlite3_column_double(stmt, 11));
 
364
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoapply), sqlite3_column_int(stmt, 12));
 
365
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->filter),    sqlite3_column_int(stmt, 13));
 
366
  }
 
367
  sqlite3_finalize(stmt);
 
368
 
 
369
  // now delete preset, so we can re-insert the new values:
 
370
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "delete from presets where name=?1 and operation=?2", -1, &stmt, NULL);
 
371
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, strlen(name), SQLITE_TRANSIENT);
 
372
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
373
  sqlite3_step(stmt);
 
374
  sqlite3_finalize(stmt);
 
375
 
 
376
  g_signal_connect (dialog, "response", G_CALLBACK (edit_preset_response), g);
 
377
  gtk_widget_show_all (dialog);
 
378
  g_free(name);
 
379
}
 
380
 
 
381
static void
 
382
menuitem_edit_preset (GtkMenuItem *menuitem, dt_iop_module_t *module)
 
383
{
 
384
  edit_preset (NULL, module);
 
385
}
 
386
 
 
387
static void
 
388
menuitem_new_preset (GtkMenuItem *menuitem, dt_iop_module_t *module)
 
389
{
 
390
  // add new preset
 
391
  sqlite3_stmt *stmt;
 
392
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "delete from presets where name=?1 and operation=?2", -1, &stmt, NULL);
 
393
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, _("new preset"), strlen(_("new preset")), SQLITE_STATIC);
 
394
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
395
  sqlite3_step(stmt);
 
396
  sqlite3_finalize(stmt);
 
397
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "insert into presets values (?1, '', ?2, ?3, ?4, '%', '%', '%', 0, 51200, 0, 100000000, 0, 100000000, 0, 1000, 0, 0, 0, 0, 0)", -1, &stmt, NULL);
 
398
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, _("new preset"), strlen(_("new preset")), SQLITE_STATIC);
 
399
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
400
  DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 3, module->params, module->params_size, SQLITE_TRANSIENT);
 
401
  DT_DEBUG_SQLITE3_BIND_INT(stmt, 4, module->enabled);
 
402
  sqlite3_step(stmt);
 
403
  sqlite3_finalize(stmt);
 
404
  // then show edit dialog
 
405
  edit_preset (_("new preset"), module);
 
406
}
 
407
 
 
408
static void
 
409
menuitem_pick_preset (GtkMenuItem *menuitem, dt_iop_module_t *module)
 
410
{
 
411
  gchar *name = get_preset_name(menuitem);
 
412
  sqlite3_stmt *stmt;
 
413
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "select op_params, enabled from presets where operation = ?1 and name = ?2", -1, &stmt, NULL);
 
414
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
415
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, name, strlen(name), SQLITE_TRANSIENT);
 
416
 
 
417
  if(sqlite3_step(stmt) == SQLITE_ROW)
 
418
  {
 
419
    const void *blob = sqlite3_column_blob(stmt, 0);
 
420
    int length  = sqlite3_column_bytes(stmt, 0);
 
421
    int enabled = sqlite3_column_int(stmt, 1);
 
422
    if(blob && (length == module->params_size))
 
423
    {
 
424
      memcpy(module->params, blob, length);
 
425
      module->enabled = enabled;
 
426
    }
 
427
  }
 
428
  sqlite3_finalize(stmt);
 
429
  g_free(name);
 
430
  dt_iop_gui_update(module);
 
431
  dt_dev_add_history_item(darktable.develop, module, FALSE);
 
432
  gtk_widget_queue_draw(module->widget);
 
433
}
 
434
 
 
435
static void
 
436
menuitem_store_default (GtkMenuItem *menuitem, dt_iop_module_t *module)
 
437
{
 
438
  gchar *name = get_active_preset_name(module);
 
439
  if(name == NULL) return;
 
440
  sqlite3_stmt *stmt;
 
441
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set def=0 where operation=?1", -1, &stmt, NULL);
 
442
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
443
  sqlite3_step(stmt);
 
444
  sqlite3_finalize(stmt);
 
445
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set def=1 where operation=?1 and name=?2", -1, &stmt, NULL);
 
446
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
447
  DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 2, name, strlen(name), SQLITE_TRANSIENT);
 
448
  sqlite3_step(stmt);
 
449
  sqlite3_finalize(stmt);
 
450
  dt_iop_load_default_params(module);
 
451
}
 
452
 
 
453
static void
 
454
menuitem_factory_default (GtkMenuItem *menuitem, dt_iop_module_t *module)
 
455
{
 
456
  sqlite3_stmt *stmt;
 
457
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set def=0 where operation=?1", -1, &stmt, NULL);
 
458
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
459
  sqlite3_step(stmt);
 
460
  sqlite3_finalize(stmt);
 
461
  dt_iop_load_default_params(module);
 
462
}
 
463
 
 
464
 
 
465
static void
 
466
dt_gui_presets_popup_menu_show_internal(dt_dev_operation_t op, dt_iop_params_t *params, int32_t params_size, dt_iop_module_t *module, dt_image_t *image, void (*pick_callback)(GtkMenuItem*,void*), void *callback_data)
 
467
{
 
468
  GtkMenu *menu = darktable.gui->presets_popup_menu;
 
469
  if(menu)
 
470
    gtk_widget_destroy(GTK_WIDGET(menu));
 
471
  darktable.gui->presets_popup_menu = GTK_MENU(gtk_menu_new());
 
472
  menu = darktable.gui->presets_popup_menu;
 
473
 
 
474
  GtkWidget *mi;
 
475
  int active_preset = -1, cnt = 0, writeprotect = 0, selected_default = 0;
 
476
  sqlite3_stmt *stmt;
 
477
  // order: get shipped defaults first
 
478
  if(image)
 
479
  {
 
480
    // only matching if filter is on:
 
481
    DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "select name, op_params, writeprotect, description from presets where operation=?1 and "
 
482
                                "(filter=0 or ( "
 
483
                                "?2 like model and ?3 like maker and ?4 like lens and "
 
484
                                "?5 between iso_min and iso_max and "
 
485
                                "?6 between exposure_min and exposure_max and "
 
486
                                "?7 between aperture_min and aperture_max and "
 
487
                                "?8 between focal_length_min and focal_length_max and "
 
488
                                "(isldr = 0 or isldr=?9) ) )"
 
489
                                "order by writeprotect desc, rowid", -1, &stmt, NULL);
 
490
    DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, op, strlen(op), SQLITE_TRANSIENT);
 
491
    DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, image->exif_model, strlen(image->exif_model), SQLITE_TRANSIENT);
 
492
    DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, image->exif_maker, strlen(image->exif_maker), SQLITE_TRANSIENT);
 
493
    DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, image->exif_lens,  strlen(image->exif_lens),  SQLITE_TRANSIENT);
 
494
    DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 5, image->exif_iso);
 
495
    DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 6, image->exif_exposure);
 
496
    DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 7, image->exif_aperture);
 
497
    DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 8, image->exif_focal_length);
 
498
  }
 
499
  else
 
500
  {
 
501
    // don't know for which image. show all we got:
 
502
    DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "select name, op_params, writeprotect, description from presets where operation=?1 order by writeprotect desc, rowid", -1, &stmt, NULL);
 
503
    DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, op, strlen(op), SQLITE_TRANSIENT);
 
504
  }
 
505
  // collect all presets for op from db
 
506
  while(sqlite3_step(stmt) == SQLITE_ROW)
 
507
  {
 
508
    void *op_params = (void *)sqlite3_column_blob(stmt, 1);
 
509
    int32_t op_params_size = sqlite3_column_bytes(stmt, 1);
 
510
    int32_t isdefault = 0;
 
511
    if(module && !memcmp(module->default_params, op_params, MIN(op_params_size, module->params_size))) isdefault = 1;
 
512
    if(!memcmp(params, op_params, MIN(op_params_size, params_size)))
 
513
    {
 
514
      active_preset = cnt;
 
515
      writeprotect = sqlite3_column_int(stmt, 2);
 
516
      char *markup;
 
517
      mi = gtk_menu_item_new_with_label("");
 
518
      if(isdefault)
 
519
      {
 
520
        selected_default = 1;
 
521
        markup = g_markup_printf_escaped ("<span weight=\"bold\">%s %s</span>", sqlite3_column_text(stmt, 0), _("(default)"));
 
522
      }
 
523
      else
 
524
        markup = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>", sqlite3_column_text(stmt, 0));
 
525
      gtk_label_set_markup (GTK_LABEL (gtk_bin_get_child(GTK_BIN(mi))), markup);
 
526
      g_free (markup);
 
527
    }
 
528
    else
 
529
    {
 
530
      if(isdefault)
 
531
      {
 
532
        char *markup;
 
533
        mi = gtk_menu_item_new_with_label("");
 
534
        markup = g_markup_printf_escaped ("%s %s", sqlite3_column_text(stmt, 0), _("(default)"));
 
535
        gtk_label_set_markup (GTK_LABEL (gtk_bin_get_child(GTK_BIN(mi))), markup);
 
536
        g_free (markup);
 
537
      }
 
538
      else mi = gtk_menu_item_new_with_label((const char *)sqlite3_column_text(stmt, 0));
 
539
    }
 
540
    if(module) g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_pick_preset), module);
 
541
    else if(pick_callback) g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(pick_callback), callback_data);
 
542
    gtk_object_set(GTK_OBJECT(mi), "tooltip-text", sqlite3_column_text(stmt, 3), (char *)NULL);
 
543
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
 
544
    cnt ++;
 
545
  }
 
546
  sqlite3_finalize(stmt);
 
547
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
 
548
 
 
549
  if(module)
 
550
  {
 
551
    if(active_preset >= 0)
 
552
    {
 
553
      if(!writeprotect)
 
554
      {
 
555
        mi = gtk_menu_item_new_with_label(_("edit this preset.."));
 
556
        g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_edit_preset), module);
 
557
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
 
558
 
 
559
        mi = gtk_menu_item_new_with_label(_("delete this preset"));
 
560
        g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_delete_preset), module);
 
561
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
 
562
      }
 
563
 
 
564
      if(!selected_default)
 
565
      {
 
566
        // only show if it is not the default already
 
567
        mi = gtk_menu_item_new_with_label(_("use preset as default"));
 
568
        g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_store_default), module);
 
569
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
 
570
      }
 
571
    }
 
572
    else
 
573
    {
 
574
      mi = gtk_menu_item_new_with_label(_("store new preset.."));
 
575
      g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_new_preset), module);
 
576
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
 
577
    }
 
578
 
 
579
    DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "select * from presets where operation = ?1 and def=1", -1, &stmt, NULL);
 
580
    DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, module->op, strlen(module->op), SQLITE_TRANSIENT);
 
581
    if(sqlite3_step(stmt) == SQLITE_ROW)
 
582
    {
 
583
      // only show this if presets already contains a default
 
584
      mi = gtk_menu_item_new_with_label(_("remove default"));
 
585
      g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_factory_default), module);
 
586
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
 
587
    }
 
588
    sqlite3_finalize(stmt);
 
589
  }
 
590
}
 
591
 
 
592
void dt_gui_presets_popup_menu_show_for_params(dt_dev_operation_t op, void *params, int32_t params_size, dt_image_t *image, void (*pick_callback)(GtkMenuItem*,void*), void *callback_data)
 
593
{
 
594
  dt_gui_presets_popup_menu_show_internal(op, params, params_size, NULL, image, pick_callback, callback_data);
 
595
}
 
596
 
 
597
void dt_gui_presets_popup_menu_show_for_module(dt_iop_module_t *module)
 
598
{
 
599
  dt_gui_presets_popup_menu_show_internal(module->op, module->params, module->params_size, module, module->dev->image, NULL, NULL);
 
600
}
 
601
 
 
602
void dt_gui_presets_update_mml(const char *name, dt_dev_operation_t op, const char *maker, const char *model, const char *lens)
 
603
{
 
604
  char tmp[1024];
 
605
  sqlite3_stmt *stmt;
 
606
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set maker=?1, model=?2, lens=?3 where operation=?4 and name=?5", -1, &stmt, NULL);
 
607
  snprintf(tmp, 1024, "%%%s%%", maker);
 
608
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, tmp, strlen(tmp), SQLITE_TRANSIENT);
 
609
  snprintf(tmp, 1024, "%%%s%%", model);
 
610
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, tmp, strlen(tmp), SQLITE_TRANSIENT);
 
611
  snprintf(tmp, 1024, "%%%s%%", lens);
 
612
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, tmp, strlen(tmp), SQLITE_TRANSIENT);
 
613
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, op, strlen(op), SQLITE_TRANSIENT);
 
614
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 5, name, strlen(name), SQLITE_TRANSIENT);
 
615
  sqlite3_step(stmt);
 
616
  sqlite3_finalize(stmt);
 
617
}
 
618
 
 
619
void dt_gui_presets_update_iso(const char *name, dt_dev_operation_t op, const float min, const float max)
 
620
{
 
621
  sqlite3_stmt *stmt;
 
622
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set iso_min=?1, iso_max=?2 where operation=?3 and name=?4", -1, &stmt, NULL);
 
623
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 1, min);
 
624
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 2, max);
 
625
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, op, strlen(op), SQLITE_TRANSIENT);
 
626
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, name, strlen(name), SQLITE_TRANSIENT);
 
627
  sqlite3_step(stmt);
 
628
  sqlite3_finalize(stmt);
 
629
}
 
630
 
 
631
void dt_gui_presets_update_av(const char *name, dt_dev_operation_t op, const float min, const float max)
 
632
{
 
633
  sqlite3_stmt *stmt;
 
634
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set aperture_min=?1, aperture_max=?2 where operation=?3 and name=?4", -1, &stmt, NULL);
 
635
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 1, min);
 
636
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 2, max);
 
637
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, op, strlen(op), SQLITE_TRANSIENT);
 
638
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, name, strlen(name), SQLITE_TRANSIENT);
 
639
  sqlite3_step(stmt);
 
640
  sqlite3_finalize(stmt);
 
641
}
 
642
 
 
643
void dt_gui_presets_update_tv(const char *name, dt_dev_operation_t op, const float min, const float max)
 
644
{
 
645
  sqlite3_stmt *stmt;
 
646
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set exposure_min=?1, exposure_max=?2 where operation=?3 and name=?4", -1, &stmt, NULL);
 
647
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 1, min);
 
648
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 2, max);
 
649
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, op, strlen(op), SQLITE_TRANSIENT);
 
650
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, name, strlen(name), SQLITE_TRANSIENT);
 
651
  sqlite3_step(stmt);
 
652
  sqlite3_finalize(stmt);
 
653
}
 
654
 
 
655
void dt_gui_presets_update_fl(const char *name, dt_dev_operation_t op, const float min, const float max)
 
656
{
 
657
  sqlite3_stmt *stmt;
 
658
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set focal_length_min=?1, focal_length_max=?2 where operation=?3 and name=?4", -1, &stmt, NULL);
 
659
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 1, min);
 
660
  DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 2, max);
 
661
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, op, strlen(op), SQLITE_TRANSIENT);
 
662
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, name, strlen(name), SQLITE_TRANSIENT);
 
663
  sqlite3_step(stmt);
 
664
  sqlite3_finalize(stmt);
 
665
}
 
666
 
 
667
void dt_gui_presets_update_ldr(const char *name, dt_dev_operation_t op, const int ldrflag)
 
668
{
 
669
  sqlite3_stmt *stmt;
 
670
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set isldr=?1 where operation=?2 and name=?3", -1, &stmt, NULL);
 
671
  DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, ldrflag);
 
672
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, op, strlen(op), SQLITE_TRANSIENT);
 
673
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, name, strlen(name), SQLITE_TRANSIENT);
 
674
  sqlite3_step(stmt);
 
675
  sqlite3_finalize(stmt);
 
676
}
 
677
 
 
678
void dt_gui_presets_update_autoapply(const char *name, dt_dev_operation_t op, const int autoapply)
 
679
{
 
680
  sqlite3_stmt *stmt;
 
681
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set autoapply=?1 where operation=?2 and name=?3", -1, &stmt, NULL);
 
682
  DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, autoapply);
 
683
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, op, strlen(op), SQLITE_TRANSIENT);
 
684
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, name, strlen(name), SQLITE_TRANSIENT);
 
685
  sqlite3_step(stmt);
 
686
  sqlite3_finalize(stmt);
 
687
}
 
688
 
 
689
void dt_gui_presets_update_filter(const char *name, dt_dev_operation_t op, const int filter)
 
690
{
 
691
  sqlite3_stmt *stmt;
 
692
  DT_DEBUG_SQLITE3_PREPARE_V2(darktable.db, "update presets set filter=?1 where operation=?2 and name=?3", -1, &stmt, NULL);
 
693
  DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, filter);
 
694
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, op, strlen(op), SQLITE_TRANSIENT);
 
695
  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, name, strlen(name), SQLITE_TRANSIENT);
 
696
  sqlite3_step(stmt);
 
697
  sqlite3_finalize(stmt);
 
698
}
 
699
 
 
700