← Back to branch summary

~ubuntu-branches/ubuntu/vivid/rawstudio/vivid

« back to all changes in this revision

Viewing changes to librawstudio/rs-lens-db-editor.c

  • Committer: Bazaar Package Importer
  • Author(s): Bernd Zeimetz
  • Date: 2011-07-28 17:36:32 UTC
  • mfrom: (2.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20110728173632-5czluz9ye3c83zc5
Tags: 2.0-1
* [3750b2cf] Merge commit 'upstream/2.0'
* [63637468] Removing Patch, not necessary anymore.
* [2fb580dc] Add new build-dependencies.
* [c57d953b] Run dh_autoreconf due to patches in configure.in
* [13febe39] Add patch to remove the libssl requirement.
* [5ae773fe] Replace libjpeg62-dev by libjpeg8-dev :)
* [1969d755] Don't build static libraries.
* [7cfe0a2e] Add a patch to fix the plugin directory path.
  As plugins are shared libraries, they need to go into /usr/lib,
  not into /usr/share.
  Thanks to Andrew McMillan
* [c1d0d9dd] Don't install .la files for all plugins and libraries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
librawstudio/rs-lens-db-editor.c
 
1
/*
 
2
 * * Copyright (C) 2006-2011 Anders Brander <anders@brander.dk>,
 
3
 * * Anders Kvist <akv@lnxbx.dk> and Klaus Post <klauspost@gmail.com>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or
 
6
 * modify it under the terms of the GNU General Public License
 
7
 * as published by the Free Software Foundation; either version 2
 
8
 * of the License, or (at your option) any later version.
 
9
 *
 
10
 * This program 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 this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
18
 */
 
19
 
 
20
/*
 
21
 * The following functions is more or less grabbed from UFraw:
 
22
 * lens_set(), lens_menu_select(), ptr_array_insert_sorted(),
 
23
 * ptr_array_find_sorted(), ptr_array_insert_index() and lens_menu_fill()
 
24
 */
 
25
 
 
26
#include <rawstudio.h>
 
27
#include <glib.h>
 
28
#include <glib/gstdio.h>
 
29
#include <gtk/gtk.h>
 
30
#include <string.h>
 
31
#include <config.h>
 
32
#include <lensfun.h>
 
33
#include <rs-lens-db.h>
 
34
#include <rs-lens.h>
 
35
#include <gettext.h>
 
36
#include <curl/curl.h>
 
37
#include <libxml/HTMLparser.h>
 
38
#include "rs-lens-db-editor.h"
 
39
 
 
40
static void fill_model(RSLensDb *lens_db, GtkTreeModel *tree_model);
 
41
static char * rs_lens_db_editor_update_lensfun(void);
 
42
GtkDialog *rs_lens_db_editor_single_lens(RSLens *lens);
 
43
 
 
44
typedef struct {
 
45
        GtkWidget *lensfun_make;
 
46
        GtkWidget *lensfun_model;
 
47
        GtkWidget *button;
 
48
        GtkWidget *checkbutton_enabled;
 
49
        RSLens *lens;
 
50
} SingleLensData;
 
51
 
 
52
typedef struct {
 
53
        /* The menu used to choose lens - either full or limited by search criteria */
 
54
        GtkWidget *LensMenu;
 
55
        /* The GtkTreeView */
 
56
        GtkTreeView *tree_view;
 
57
        SingleLensData *single_lens_data;
 
58
} lens_data;
 
59
 
 
60
gint lf_lens_sort_by_model_func(gconstpointer *a, gconstpointer *b)
 
61
{
 
62
        lfLens *first = (lfLens *) ((GPtrArray *) a)->pdata;
 
63
        lfLens *second = (lfLens *) ((GPtrArray *) b)->pdata;
 
64
 
 
65
        return g_strcmp0(first->Model, second->Model);
 
66
}
 
67
 
 
68
const lfLens **lf_lens_sort_by_model(const lfLens *const *array)
 
69
{
 
70
        if (array == NULL)
 
71
                return NULL;
 
72
 
 
73
        gint x = 0;
 
74
        GPtrArray *temp = g_ptr_array_new();
 
75
 
 
76
        while (array[x])
 
77
                g_ptr_array_add(temp, (gpointer *) array[x++]);
 
78
 
 
79
        g_ptr_array_sort(temp, (GCompareFunc) lf_lens_sort_by_model_func);
 
80
        g_ptr_array_add (temp, NULL);
 
81
        return (const lfLens **) g_ptr_array_free (temp, FALSE);
 
82
}
 
83
 
 
84
static void lens_set (lens_data *data, const lfLens *lens)
 
85
{
 
86
        if (data->single_lens_data)
 
87
        {
 
88
                /* Set Maker and Model to the selected RSLens */
 
89
                rs_lens_set_lensfun_make(data->single_lens_data->lens, lens->Maker);
 
90
                rs_lens_set_lensfun_model(data->single_lens_data->lens, lens->Model);
 
91
                rs_lens_set_lensfun_enabled(data->single_lens_data->lens, TRUE);
 
92
 
 
93
                gtk_label_set_text(GTK_LABEL(data->single_lens_data->lensfun_make), lens->Maker);
 
94
                gtk_label_set_text(GTK_LABEL(data->single_lens_data->lensfun_model), lens->Model);
 
95
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->single_lens_data->checkbutton_enabled), TRUE);
 
96
 
 
97
                gtk_widget_show(data->single_lens_data->lensfun_make);
 
98
                gtk_widget_show(data->single_lens_data->lensfun_model);
 
99
                gtk_widget_hide(data->single_lens_data->button);
 
100
 
 
101
                RSLensDb *lens_db = rs_lens_db_get_default();
 
102
 
 
103
                /* Force save of RSLensDb */
 
104
                rs_lens_db_save(lens_db);
 
105
 
 
106
                if (data)
 
107
                        g_free(data);
 
108
 
 
109
                return;
 
110
        }
 
111
 
 
112
        GtkTreeSelection *selection = gtk_tree_view_get_selection(data->tree_view);
 
113
        GtkTreeModel *model = NULL;
 
114
        GtkTreeIter iter;
 
115
 
 
116
        gtk_tree_selection_get_selected(selection, &model, &iter);
 
117
 
 
118
        /* Set Maker and Model to the tree view */
 
119
        gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 
120
                            RS_LENS_DB_EDITOR_LENS_MAKE, lens->Maker,
 
121
                            RS_LENS_DB_EDITOR_LENS_MODEL, lens->Model,
 
122
                            RS_LENS_DB_EDITOR_ENABLED_ACTIVATABLE, TRUE,
 
123
                            RS_LENS_DB_EDITOR_ENABLED, TRUE,
 
124
                            -1);
 
125
 
 
126
        RSLens *rs_lens = NULL;
 
127
        gtk_tree_model_get (model, &iter,
 
128
                            RS_LENS_DB_EDITOR_LENS, &rs_lens,
 
129
                            -1);
 
130
 
 
131
        /* Set Maker and Model to the selected RSLens */
 
132
        rs_lens_set_lensfun_make(rs_lens, lens->Maker);
 
133
        rs_lens_set_lensfun_model(rs_lens, lens->Model);
 
134
        rs_lens_set_lensfun_enabled(rs_lens, TRUE);
 
135
 
 
136
        RSLensDb *lens_db = rs_lens_db_get_default();
 
137
 
 
138
        /* Force save of RSLensDb */
 
139
        rs_lens_db_save(lens_db);
 
140
}
 
141
 
 
142
 
 
143
static void lens_menu_select (
 
144
        GtkMenuItem *menuitem, gpointer user_data)
 
145
{
 
146
        lens_data *data = (lens_data *)user_data;
 
147
        lens_set (data, (lfLens *)g_object_get_data(G_OBJECT(menuitem), "lfLens"));
 
148
}
 
149
 
 
150
int ptr_array_insert_sorted (
 
151
        GPtrArray *array, const void *item, GCompareFunc compare)
 
152
{
 
153
        int length = array->len;
 
154
        g_ptr_array_set_size (array, length + 1);
 
155
        const void **root = (const void **)array->pdata;
 
156
 
 
157
        int m = 0, l = 0, r = length - 1;
 
158
 
 
159
        // Skip trailing NULL, if any
 
160
        if (l <= r && !root [r])
 
161
                r--;
 
162
    
 
163
        while (l <= r)
 
164
        {
 
165
                m = (l + r) / 2;
 
166
                int cmp = compare (root [m], item);
 
167
 
 
168
                if (cmp == 0)
 
169
                {
 
170
                        ++m;
 
171
                        goto done;
 
172
                }
 
173
                else if (cmp < 0)
 
174
                        l = m + 1;
 
175
                else
 
176
                        r = m - 1;
 
177
        }
 
178
        if (r == m)
 
179
                m++;
 
180
 
 
181
  done:
 
182
        memmove (root + m + 1, root + m, (length - m) * sizeof (void *));
 
183
        root [m] = item;
 
184
        return m;
 
185
}
 
186
 
 
187
int ptr_array_find_sorted (
 
188
        const GPtrArray *array, const void *item, GCompareFunc compare)
 
189
{
 
190
        int length = array->len;
 
191
        void **root = array->pdata;
 
192
 
 
193
        int l = 0, r = length - 1;
 
194
        int m = 0, cmp = 0;
 
195
 
 
196
        if (!length)
 
197
                return -1;
 
198
 
 
199
        // Skip trailing NULL, if any
 
200
        if (!root [r])
 
201
                r--;
 
202
 
 
203
        while (l <= r)
 
204
        {
 
205
                m = (l + r) / 2;
 
206
                cmp = compare (root [m], item);
 
207
 
 
208
                if (cmp == 0)
 
209
                        return m;
 
210
                else if (cmp < 0)
 
211
                        l = m + 1;
 
212
                else
 
213
                        r = m - 1;
 
214
        }
 
215
    
 
216
        return -1;
 
217
}
 
218
 
 
219
 
 
220
void ptr_array_insert_index (
 
221
        GPtrArray *array, const void *item, int index)
 
222
{
 
223
        const void **root;
 
224
        int length = array->len;
 
225
        g_ptr_array_set_size (array, length + 1);
 
226
        root = (const void **)array->pdata;
 
227
        memmove (root + index + 1, root + index, (length - index) * sizeof (void *));
 
228
        root [index] = item;
 
229
}
 
230
 
 
231
 
 
232
 
 
233
static void lens_menu_fill (
 
234
        lens_data *data, const lfLens *const *lenslist_temp, const lfLens *const *full_lenslist_temp)
 
235
{
 
236
        unsigned i;
 
237
        GPtrArray *makers, *submenus, *allmakers, *allsubmenus;
 
238
 
 
239
        /* We want the two lists sorted by model */
 
240
        const lfLens **lenslist = lf_lens_sort_by_model(lenslist_temp);
 
241
        const lfLens **full_lenslist = lf_lens_sort_by_model(full_lenslist_temp);
 
242
 
 
243
        if (data->LensMenu)
 
244
        {
 
245
                /* This doesn't work, but will we be leaking GtkMenu's */
 
246
                //gtk_widget_destroy (data->LensMenu);
 
247
                data->LensMenu = NULL;
 
248
        }
 
249
 
 
250
        /* Count all existing lens makers and create a sorted list */
 
251
        makers = g_ptr_array_new ();
 
252
        submenus = g_ptr_array_new ();
 
253
 
 
254
        if (lenslist)
 
255
                for (i = 0; lenslist [i]; i++)
 
256
                {
 
257
                        GtkWidget *submenu, *item;
 
258
                        const char *m = lf_mlstr_get (lenslist [i]->Maker);
 
259
                        int idx = ptr_array_find_sorted (makers, m, (GCompareFunc)g_utf8_collate);
 
260
                        if (idx < 0)
 
261
                        {
 
262
                                /* No such maker yet, insert it into the array */
 
263
                                idx = ptr_array_insert_sorted (makers, m, (GCompareFunc)g_utf8_collate);
 
264
                                /* Create a submenu for lenses by this maker */
 
265
                                submenu = gtk_menu_new ();
 
266
                                ptr_array_insert_index (submenus, submenu, idx);
 
267
                        }
 
268
                        submenu = g_ptr_array_index (submenus, idx);
 
269
                        /* Append current lens name to the submenu */
 
270
                        item = gtk_menu_item_new_with_label (lf_mlstr_get (lenslist [i]->Model));
 
271
                        gtk_widget_show (item);
 
272
                        g_object_set_data(G_OBJECT(item), "lfLens", (void *)lenslist [i]);
 
273
                        g_signal_connect(G_OBJECT(item), "activate",
 
274
                                         G_CALLBACK(lens_menu_select), data);
 
275
                        gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
 
276
                }
 
277
 
 
278
        /* Count all existing lens makers and create a sorted list */
 
279
        allmakers = g_ptr_array_new ();
 
280
        allsubmenus = g_ptr_array_new ();
 
281
 
 
282
        for (i = 0; full_lenslist [i]; i++)
 
283
        {
 
284
                GtkWidget *allsubmenu, *allitem;
 
285
                const char *allm = lf_mlstr_get (full_lenslist [i]->Maker);
 
286
                int allidx = ptr_array_find_sorted (allmakers, allm, (GCompareFunc)g_utf8_collate);
 
287
                if (allidx < 0)
 
288
                {
 
289
                        /* No such maker yet, insert it into the array */
 
290
                        allidx = ptr_array_insert_sorted (allmakers, allm, (GCompareFunc)g_utf8_collate);
 
291
                        /* Create a submenu for lenses by this maker */
 
292
                        allsubmenu = gtk_menu_new ();
 
293
                        ptr_array_insert_index (allsubmenus, allsubmenu, allidx);
 
294
                }
 
295
                allsubmenu = g_ptr_array_index (allsubmenus, allidx);
 
296
                /* Append current lens name to the submenu */
 
297
                allitem = gtk_menu_item_new_with_label (lf_mlstr_get (full_lenslist [i]->Model));
 
298
                gtk_widget_show (allitem);
 
299
                g_object_set_data(G_OBJECT(allitem), "lfLens", (void *)full_lenslist [i]);
 
300
                g_signal_connect(G_OBJECT(allitem), "activate",
 
301
                                 G_CALLBACK(lens_menu_select), data);
 
302
                gtk_menu_shell_append (GTK_MENU_SHELL (allsubmenu), allitem);
 
303
        }
 
304
 
 
305
        data->LensMenu = gtk_menu_new ();
 
306
        for (i = 0; i < makers->len; i++)
 
307
        {
 
308
                GtkWidget *item = gtk_menu_item_new_with_label (g_ptr_array_index (makers, i));
 
309
                gtk_widget_show (item);
 
310
                gtk_menu_shell_append (GTK_MENU_SHELL (data->LensMenu), item);
 
311
                gtk_menu_item_set_submenu (
 
312
                        GTK_MENU_ITEM (item), (GtkWidget *)g_ptr_array_index (submenus, i));
 
313
        }
 
314
 
 
315
        GtkWidget *allmenu = gtk_menu_new ();
 
316
        for (i = 0; i < allmakers->len; i++)
 
317
        {
 
318
                GtkWidget *allitem = gtk_menu_item_new_with_label (g_ptr_array_index (allmakers, i));
 
319
                gtk_widget_show (allitem);
 
320
                gtk_menu_shell_append (GTK_MENU_SHELL (allmenu), allitem);
 
321
                gtk_menu_item_set_submenu (
 
322
                        GTK_MENU_ITEM (allitem), (GtkWidget *)g_ptr_array_index (allsubmenus, i));
 
323
        }
 
324
 
 
325
        GtkWidget *item = gtk_menu_item_new_with_label (_("All lenses"));
 
326
        gtk_widget_show (item);
 
327
        gtk_menu_shell_append (GTK_MENU_SHELL (data->LensMenu), item);
 
328
        gtk_menu_item_set_submenu (
 
329
                GTK_MENU_ITEM (item), allmenu);
 
330
 
 
331
        g_ptr_array_free (submenus, TRUE);
 
332
        g_ptr_array_free (makers, TRUE);
 
333
 
 
334
        g_ptr_array_free (allsubmenus, TRUE);
 
335
        g_ptr_array_free (allmakers, TRUE);
 
336
}
 
337
 
 
338
void row_clicked (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
 
339
{
 
340
        struct lfDatabase *lensdb = NULL;
 
341
        const lfCamera *camera = NULL;
 
342
        const lfCamera **cameras = NULL;
 
343
 
 
344
        lens_data *data = g_malloc(sizeof(lens_data));
 
345
        data->tree_view = tree_view;
 
346
        data->single_lens_data = NULL;
 
347
 
 
348
        lensdb = lf_db_new ();
 
349
        lf_db_load (lensdb);
 
350
 
 
351
        GtkTreeSelection *selection = gtk_tree_view_get_selection(data->tree_view);
 
352
        GtkTreeModel *model = NULL;
 
353
        GtkTreeIter iter;
 
354
 
 
355
        gboolean ret = gtk_tree_selection_get_selected(selection, &model, &iter);
 
356
        if (ret == FALSE)
 
357
                return;
 
358
 
 
359
        RSLens *rs_lens = NULL;
 
360
        gtk_tree_model_get (model, &iter,
 
361
                            RS_LENS_DB_EDITOR_LENS, &rs_lens,
 
362
                            -1);
 
363
 
 
364
        gchar *camera_make;
 
365
        gchar *camera_model;
 
366
        gdouble min_focal;
 
367
        gdouble max_focal;
 
368
 
 
369
        g_assert(RS_IS_LENS(rs_lens));
 
370
        g_object_get(rs_lens,
 
371
                     "camera-make", &camera_make,
 
372
                     "camera-model", &camera_model,
 
373
                     "min-focal", &min_focal,
 
374
                     "max-focal", &max_focal,
 
375
                     NULL);
 
376
 
 
377
        gchar *lens_search;
 
378
        if (min_focal == max_focal)
 
379
         lens_search = g_strdup_printf("%.0fmm", min_focal);
 
380
        else
 
381
         lens_search = g_strdup_printf("%.0f-%.0f", min_focal, max_focal);
 
382
 
 
383
        cameras = lf_db_find_cameras(lensdb, camera_make, camera_model);
 
384
        if (cameras)
 
385
                camera = cameras[0];
 
386
 
 
387
        if (camera)
 
388
        {
 
389
                const lfLens **lenslist = lf_db_find_lenses_hd (
 
390
                        lensdb, camera, NULL, lens_search, 0);
 
391
                const lfLens **full_lenslist = lf_db_find_lenses_hd (
 
392
                        lensdb, camera, NULL, NULL, 0);
 
393
 
 
394
                if (!lenslist && !full_lenslist)
 
395
                        return;
 
396
 
 
397
                lens_menu_fill (data, lenslist, full_lenslist);
 
398
                lf_free (lenslist);
 
399
        }
 
400
        else
 
401
        {
 
402
                const lfLens **lenslist = lf_db_find_lenses_hd (
 
403
                        lensdb, NULL, NULL, lens_search, 0);
 
404
                const lfLens *const *full_lenslist = lf_db_get_lenses (lensdb);
 
405
 
 
406
                if (!lenslist)
 
407
                        return;
 
408
                lens_menu_fill (data, lenslist, full_lenslist);
 
409
        }
 
410
 
 
411
        g_free(lens_search);
 
412
 
 
413
        gtk_menu_popup (GTK_MENU (data->LensMenu), NULL, NULL, NULL, NULL,
 
414
                        0, gtk_get_current_event_time ());
 
415
}
 
416
 
 
417
gboolean
 
418
view_on_button_pressed (GtkWidget *treeview, GdkEventButton *event, gpointer userdata)
 
419
{
 
420
        /* single click with the right mouse button? */
 
421
        if (event->type == GDK_BUTTON_PRESS  &&  event->button == 3)
 
422
        {
 
423
                GtkTreeSelection *selection;
 
424
 
 
425
                selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
 
426
 
 
427
        /* Note: gtk_tree_selection_count_selected_rows() does not
 
428
                *   exist in gtk+-2.0, only in gtk+ >= v2.2 ! */
 
429
                GtkTreePath *path;
 
430
 
 
431
                /* Get tree path for row that was clicked */
 
432
                if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview),
 
433
                        (gint) event->x, 
 
434
                         (gint) event->y,
 
435
                          &path, NULL, NULL, NULL))
 
436
                {
 
437
                        gtk_tree_selection_unselect_all(selection);
 
438
                        gtk_tree_selection_select_path(selection, path);
 
439
                        gtk_tree_path_free(path);
 
440
                }
 
441
                row_clicked(GTK_TREE_VIEW(treeview), path, NULL, userdata);
 
442
                return TRUE; /* we handled this */
 
443
        }
 
444
        return FALSE; /* we did not handle this */
 
445
}
 
446
 
 
447
gboolean
 
448
view_popupmenu (GtkWidget *treeview, gpointer userdata)
 
449
{
 
450
        GtkTreeSelection *selection;
 
451
        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
 
452
        GtkTreeModel *tree_model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
 
453
        GList* selected = gtk_tree_selection_get_selected_rows (selection, &tree_model);
 
454
 
 
455
        row_clicked(GTK_TREE_VIEW(treeview), selected->data, NULL, userdata);
 
456
 
 
457
        return TRUE; /* we handled this */
 
458
}
 
459
 
 
460
void
 
461
toggle_clicked (GtkCellRendererToggle *cell_renderer_toggle, const gchar *path, gpointer user_data)
 
462
{
 
463
        GtkTreeIter iter;
 
464
        gboolean enabled;
 
465
        GtkTreeView *tree_view = GTK_TREE_VIEW(user_data);
 
466
        GtkTreeModel *tree_model = gtk_tree_view_get_model(tree_view);
 
467
        GtkTreePath* tree_path = gtk_tree_path_new_from_string(path);
 
468
 
 
469
        gtk_tree_model_get_iter(GTK_TREE_MODEL (tree_model), &iter, tree_path);
 
470
        gtk_tree_model_get(GTK_TREE_MODEL (tree_model), &iter, RS_LENS_DB_EDITOR_ENABLED, &enabled, -1);
 
471
 
 
472
        if (enabled)
 
473
                gtk_list_store_set(GTK_LIST_STORE (tree_model), &iter, RS_LENS_DB_EDITOR_ENABLED, FALSE, -1);
 
474
        else
 
475
                gtk_list_store_set(GTK_LIST_STORE (tree_model), &iter, RS_LENS_DB_EDITOR_ENABLED, TRUE, -1);
 
476
 
 
477
        RSLens *rs_lens = NULL;
 
478
        gtk_tree_model_get (tree_model, &iter,
 
479
                            RS_LENS_DB_EDITOR_LENS, &rs_lens,
 
480
                            -1);
 
481
 
 
482
        /* Set enabled/disabled to the selected RSLens */
 
483
        rs_lens_set_lensfun_enabled(rs_lens, !enabled);
 
484
 
 
485
        RSLensDb *lens_db = rs_lens_db_get_default();
 
486
 
 
487
        /* Force save of RSLensDb */
 
488
        rs_lens_db_save(lens_db);
 
489
}
 
490
 
 
491
void
 
492
update_lensfun(GtkButton *button, gpointer user_data)
 
493
{
 
494
        GtkWidget *window = GTK_WIDGET(user_data);
 
495
        GdkCursor* cursor = gdk_cursor_new(GDK_WATCH);
 
496
        gdk_window_set_cursor(window->window, cursor);
 
497
        GTK_CATCHUP();
 
498
        gchar *error = rs_lens_db_editor_update_lensfun();
 
499
        gdk_window_set_cursor(window->window, NULL);
 
500
        GtkWidget *dialog = NULL;
 
501
 
 
502
        if (error)
 
503
                dialog = gui_dialog_make_from_text(GTK_STOCK_DIALOG_ERROR, _("Error updating lensfun database"), error);
 
504
        else
 
505
                dialog = gui_dialog_make_from_text(GTK_STOCK_DIALOG_INFO, _("Lensfun database updated"), error);
 
506
 
 
507
        gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT);
 
508
        gtk_widget_show_all(dialog);
 
509
        gtk_dialog_run(GTK_DIALOG(dialog));
 
510
        gtk_widget_destroy(dialog);
 
511
        g_free(error);
 
512
 
 
513
        rs_lens_db_editor();
 
514
}
 
515
 
 
516
gint
 
517
rs_lens_db_editor_sort(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data)
 
518
{
 
519
        gchar *a_lensfun_model;
 
520
        gchar *a_camera_model;
 
521
        gchar *a_identifier;
 
522
 
 
523
        gtk_tree_model_get(model, a, 
 
524
                                RS_LENS_DB_EDITOR_IDENTIFIER, &a_identifier,
 
525
                                RS_LENS_DB_EDITOR_LENS_MODEL, &a_lensfun_model,
 
526
                                RS_LENS_DB_EDITOR_CAMERA_MODEL, &a_camera_model,
 
527
                                -1);
 
528
 
 
529
        gchar *b_lensfun_model;
 
530
        gchar *b_camera_model;
 
531
        gchar *b_identifier;
 
532
 
 
533
        gtk_tree_model_get(model, b, 
 
534
                                RS_LENS_DB_EDITOR_IDENTIFIER, &b_identifier,
 
535
                                RS_LENS_DB_EDITOR_LENS_MODEL, &b_lensfun_model,
 
536
                                RS_LENS_DB_EDITOR_CAMERA_MODEL, &b_camera_model,
 
537
                                -1);
 
538
 
 
539
        gint ret = 0;
 
540
 
 
541
        ret = g_strcmp0(a_lensfun_model, b_lensfun_model);
 
542
        if (ret != 0)
 
543
                return ret;
 
544
 
 
545
        ret = g_strcmp0(a_camera_model, b_camera_model);
 
546
        if (ret != 0)
 
547
                return ret;
 
548
 
 
549
        ret = g_strcmp0(a_identifier, b_identifier);
 
550
        if (ret != 0)
 
551
                return ret;
 
552
 
 
553
        return ret;
 
554
}
 
555
 
 
556
void
 
557
rs_lens_db_editor(void) 
 
558
{
 
559
        GtkTreeModel *tree_model = GTK_TREE_MODEL(gtk_list_store_new(10, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_OBJECT));
 
560
 
 
561
        RSLensDb *lens_db = rs_lens_db_get_default();
 
562
        fill_model(lens_db, tree_model);
 
563
 
 
564
        GtkWidget *editor = gtk_dialog_new();
 
565
        gtk_window_set_title(GTK_WINDOW(editor), _("Rawstudio Lens Library"));
 
566
        gtk_dialog_set_has_separator (GTK_DIALOG(editor), FALSE);
 
567
        g_signal_connect_swapped(editor, "delete_event",
 
568
                                 G_CALLBACK (gtk_widget_destroy), editor);
 
569
        g_signal_connect_swapped(editor, "response",
 
570
                                 G_CALLBACK (gtk_widget_destroy), editor);
 
571
 
 
572
        GtkWidget *frame = gtk_frame_new("");
 
573
 
 
574
        GtkWidget *scroller = gtk_scrolled_window_new (NULL, NULL);
 
575
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller),
 
576
                                        GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 
577
        GtkWidget *view = gtk_tree_view_new_with_model(tree_model);
 
578
 
 
579
        gtk_tree_view_set_reorderable(GTK_TREE_VIEW(view), FALSE);
 
580
        gtk_container_add (GTK_CONTAINER (scroller), view);
 
581
 
 
582
        GtkCellRenderer *renderer_lens_make = gtk_cell_renderer_text_new();
 
583
        GtkCellRenderer *renderer_lens_model = gtk_cell_renderer_text_new();
 
584
        GtkCellRenderer *renderer_focal = gtk_cell_renderer_text_new();
 
585
        GtkCellRenderer *renderer_aperture = gtk_cell_renderer_text_new();
 
586
        GtkCellRenderer *renderer_camera_make = gtk_cell_renderer_text_new();
 
587
        GtkCellRenderer *renderer_camera_model = gtk_cell_renderer_text_new();
 
588
        GtkCellRenderer *renderer_enabled = gtk_cell_renderer_toggle_new();
 
589
 
 
590
        GtkTreeViewColumn *column_lens_make = gtk_tree_view_column_new_with_attributes (_("Lens make"),
 
591
                                                                  renderer_lens_make,
 
592
                                                                  "text", RS_LENS_DB_EDITOR_LENS_MAKE,
 
593
                                                                                   NULL);
 
594
        GtkTreeViewColumn *column_lens_model = gtk_tree_view_column_new_with_attributes (_("Lens model"),
 
595
                                                                  renderer_lens_model,
 
596
                                                                  "text", RS_LENS_DB_EDITOR_LENS_MODEL,
 
597
                                                                                   NULL);
 
598
        GtkTreeViewColumn *column_focal = gtk_tree_view_column_new_with_attributes (_("Focal"),
 
599
                                                                  renderer_focal,
 
600
                                                                  "text", RS_LENS_DB_EDITOR_HUMAN_FOCAL,
 
601
                                                                                   NULL);
 
602
        GtkTreeViewColumn *column_aperture = gtk_tree_view_column_new_with_attributes (_("Aperture"),
 
603
                                                                  renderer_aperture,
 
604
                                                                  "text", RS_LENS_DB_EDITOR_HUMAN_APERTURE,
 
605
                                                                                   NULL);
 
606
        GtkTreeViewColumn *column_camera_make = gtk_tree_view_column_new_with_attributes (_("Camera make"),
 
607
                                                                  renderer_camera_make,
 
608
                                                                  "text", RS_LENS_DB_EDITOR_CAMERA_MAKE,
 
609
                                                                                   NULL);
 
610
        GtkTreeViewColumn *column_camera_model = gtk_tree_view_column_new_with_attributes (_("Camera model"),
 
611
                                                                  renderer_camera_model,
 
612
                                                                  "text", RS_LENS_DB_EDITOR_CAMERA_MODEL,
 
613
                                                                                   NULL);
 
614
        GtkTreeViewColumn *column_enabled = gtk_tree_view_column_new_with_attributes (_("Enabled"),
 
615
                                                                  renderer_enabled,
 
616
                                                                  "active", RS_LENS_DB_EDITOR_ENABLED,
 
617
                                                                  "activatable", RS_LENS_DB_EDITOR_ENABLED_ACTIVATABLE,
 
618
                                                                                   NULL);
 
619
 
 
620
        gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(tree_model), RS_LENS_DB_EDITOR_CAMERA_MODEL, GTK_SORT_ASCENDING);
 
621
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(tree_model), RS_LENS_DB_EDITOR_CAMERA_MODEL, rs_lens_db_editor_sort, NULL, NULL);
 
622
 
 
623
        g_signal_connect(G_OBJECT(view), "row-activated",
 
624
                         G_CALLBACK(row_clicked), NULL);
 
625
 
 
626
        g_signal_connect (renderer_enabled, "toggled",
 
627
                          G_CALLBACK (toggle_clicked), view);
 
628
                g_signal_connect(G_OBJECT(view), "button-press-event", G_CALLBACK(view_on_button_pressed), NULL);
 
629
                g_signal_connect(view, "popup-menu", (GCallback) view_popupmenu, NULL);
 
630
 
 
631
        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column_lens_make);
 
632
        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column_lens_model);
 
633
        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column_focal);
 
634
        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column_aperture);
 
635
        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column_camera_make);
 
636
        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column_camera_model);
 
637
        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column_enabled);
 
638
 
 
639
        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (view), TRUE);
 
640
 
 
641
        gtk_container_add (GTK_CONTAINER (frame), scroller);
 
642
 
 
643
        gtk_window_resize(GTK_WINDOW(editor), 400, 400);
 
644
 
 
645
        gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
 
646
        gtk_container_set_border_width (GTK_CONTAINER (scroller), 6);
 
647
 
 
648
        gtk_box_pack_start (GTK_BOX (GTK_DIALOG(editor)->vbox), frame, TRUE, TRUE, 0);
 
649
 
 
650
        GtkWidget *button_update_lensfun = gtk_button_new_with_label(_("Update lensfun database"));
 
651
        g_signal_connect(button_update_lensfun, "clicked", G_CALLBACK(update_lensfun), editor);
 
652
        gtk_dialog_add_action_widget (GTK_DIALOG (editor), button_update_lensfun, GTK_RESPONSE_NONE);
 
653
 
 
654
        GtkWidget *button_close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
 
655
        gtk_dialog_add_action_widget (GTK_DIALOG (editor), button_close, GTK_RESPONSE_CLOSE);
 
656
 
 
657
        gtk_widget_show_all(GTK_WIDGET(editor));
 
658
 
 
659
}
 
660
 
 
661
static void
 
662
fill_model(RSLensDb *lens_db, GtkTreeModel *tree_model)
 
663
{
 
664
        GList *list = rs_lens_db_get_lenses(lens_db);
 
665
 
 
666
        while (list)
 
667
        {
 
668
                gchar *identifier;
 
669
                gchar *lensfun_make;
 
670
                gchar *lensfun_model;
 
671
                gdouble min_focal, max_focal, min_aperture, max_aperture;
 
672
                gchar *camera_make;
 
673
                gchar *camera_model;
 
674
                gboolean enabled;
 
675
 
 
676
                RSLens *lens = list->data;
 
677
 
 
678
                g_assert(RS_IS_LENS(lens));
 
679
                g_object_get(lens,
 
680
                             "identifier", &identifier,
 
681
                             "lensfun-make", &lensfun_make,
 
682
                             "lensfun-model", &lensfun_model,
 
683
                             "min-focal", &min_focal,
 
684
                             "max-focal", &max_focal,
 
685
                             "min-aperture", &min_aperture,
 
686
                             "max-aperture", &max_aperture,
 
687
                             "camera-make", &camera_make,
 
688
                             "camera-model", &camera_model,
 
689
                             "enabled", &enabled,
 
690
                             NULL);
 
691
 
 
692
                const gchar *human_focal = rs_human_focal(min_focal, max_focal);
 
693
                const gchar *human_aperture = rs_human_aperture(max_aperture);
 
694
 
 
695
                GtkTreeIter iter;
 
696
 
 
697
                gboolean enabled_activatable = FALSE;
 
698
                if (lensfun_make && lensfun_model)
 
699
                        enabled_activatable = TRUE;
 
700
 
 
701
                gtk_list_store_append (GTK_LIST_STORE(tree_model), &iter);
 
702
                gtk_list_store_set (GTK_LIST_STORE(tree_model), &iter,
 
703
                                    RS_LENS_DB_EDITOR_IDENTIFIER, identifier,
 
704
                                    RS_LENS_DB_EDITOR_HUMAN_FOCAL, human_focal,
 
705
                                    RS_LENS_DB_EDITOR_HUMAN_APERTURE, human_aperture,
 
706
                                    RS_LENS_DB_EDITOR_LENS_MAKE, lensfun_make,
 
707
                                    RS_LENS_DB_EDITOR_LENS_MODEL, lensfun_model,
 
708
                                    RS_LENS_DB_EDITOR_CAMERA_MAKE, camera_make,
 
709
                                    RS_LENS_DB_EDITOR_CAMERA_MODEL, camera_model,
 
710
                                    RS_LENS_DB_EDITOR_ENABLED, enabled,
 
711
                                    RS_LENS_DB_EDITOR_ENABLED_ACTIVATABLE, enabled_activatable,
 
712
                                    RS_LENS_DB_EDITOR_LENS, lens,
 
713
                                    -1);
 
714
                list = g_list_next (list);
 
715
        }
 
716
}
 
717
 
 
718
static size_t
 
719
write_callback(void *ptr, size_t size, size_t nmemb, void *userp)
 
720
{
 
721
        GString *string = (GString *) userp;
 
722
        g_string_append_len(string, (char *) ptr, size * nmemb);
 
723
        return (size * nmemb);
 
724
}
 
725
 
 
726
static gchar *
 
727
rs_lens_db_editor_update_lensfun(void)
 
728
{
 
729
        const gchar *baseurl = "http://svn.berlios.de/svnroot/repos/lensfun/trunk/data/db/";
 
730
        const gchar *target = g_strdup_printf("%s/.%u-rawstudio_lensfun/", g_get_tmp_dir(), g_random_int());
 
731
 
 
732
        g_mkdir(target, 0700);
 
733
        if (!g_file_test(target, G_FILE_TEST_IS_DIR))
 
734
                return g_strdup(_("Could not create temporary directory."));
 
735
 
 
736
        CURL *curl = curl_easy_init();
 
737
        GString *xml = g_string_new(NULL);
 
738
        gchar *filename = NULL, *url = NULL, *file = NULL;
 
739
        FILE *fp = NULL;
 
740
        CURLcode result;
 
741
 
 
742
        curl_easy_setopt(curl, CURLOPT_URL, baseurl);
 
743
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
 
744
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, xml);
 
745
        result = curl_easy_perform(curl);
 
746
        if (result != 0)
 
747
                return g_strdup_printf(_("Could not fetch list of files from %s."), baseurl);
 
748
 
 
749
        htmlDocPtr doc = htmlReadMemory(xml->str, xml->len, NULL, NULL, 0);
 
750
        htmlNodePtr cur, child;
 
751
 
 
752
        cur = xmlDocGetRootElement(doc);
 
753
        cur = cur->xmlChildrenNode;
 
754
        cur = cur->next;
 
755
        cur = cur->xmlChildrenNode;
 
756
        cur = cur->next;
 
757
        cur = cur->next;
 
758
        cur = cur->next;
 
759
        cur = cur->xmlChildrenNode;
 
760
        cur = cur->next;
 
761
        cur = cur->next;
 
762
        while (cur)
 
763
        {
 
764
                child = cur->xmlChildrenNode;
 
765
                filename =  (gchar *) xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
 
766
 
 
767
                url = g_strdup_printf("%s%s", baseurl, filename);
 
768
                file = g_build_filename(target, filename, NULL);
 
769
 
 
770
                fp = fopen(file, "w");
 
771
 
 
772
                curl_easy_reset(curl);
 
773
                curl_easy_setopt(curl, CURLOPT_URL, url);
 
774
                curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
 
775
                result = curl_easy_perform(curl);
 
776
 
 
777
                fclose(fp);
 
778
 
 
779
                g_free(filename);
 
780
                g_free(url);
 
781
                g_free(file);
 
782
 
 
783
                cur = cur->next;
 
784
                cur = cur->next;
 
785
 
 
786
                if (result != 0)
 
787
                        return g_strdup_printf(_("Could not fetch file from %s or write it to %s."), url, file);
 
788
        }
 
789
 
 
790
        const gchar *datadir = g_build_filename(g_get_user_data_dir(), "lensfun", NULL);
 
791
 
 
792
        if (!g_file_test(datadir, G_FILE_TEST_IS_DIR))
 
793
        {
 
794
                g_mkdir(datadir, 0700);
 
795
                if (!g_file_test(datadir, G_FILE_TEST_IS_DIR))
 
796
                        return g_strdup_printf(_("Could not create datadir for lensfun - %s"), datadir);
 
797
        }
 
798
 
 
799
        GDir *dir = g_dir_open(target, 0, NULL);
 
800
        const gchar *fn = NULL;
 
801
 
 
802
        while ((fn = g_dir_read_name (dir)))
 
803
        {
 
804
                GPatternSpec *ps = g_pattern_spec_new ("*.xml");
 
805
                if (g_pattern_match (ps, strlen(fn), fn, NULL))
 
806
                {
 
807
                        gchar *ffn = g_build_filename (target, fn, NULL);
 
808
                        GFile *source = g_file_new_for_path(ffn);
 
809
                        GFile *destination = g_file_new_for_path(g_build_filename(datadir, fn, NULL));
 
810
 
 
811
                        if (!g_file_copy(source, destination, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, NULL))
 
812
                                return g_strdup_printf(_("Error copying file %s to %s\n"), g_file_get_parse_name(source), g_file_get_parse_name(destination));
 
813
 
 
814
                        g_free(ffn);
 
815
                }
 
816
                g_free(ps);
 
817
        }
 
818
 
 
819
        /* FIXME: remove 'target' */
 
820
 
 
821
        g_dir_close(dir);
 
822
 
 
823
        return NULL;
 
824
}
 
825
 
 
826
void set_lens (GtkButton *button, SingleLensData *single_lens_data)
 
827
{
 
828
        struct lfDatabase *lensdb = NULL;
 
829
        const lfCamera *camera = NULL;
 
830
        const lfCamera **cameras = NULL;
 
831
 
 
832
        lens_data *data = g_malloc(sizeof(lens_data));
 
833
        data->single_lens_data = single_lens_data;
 
834
 
 
835
        lensdb = lf_db_new ();
 
836
        lf_db_load (lensdb);
 
837
 
 
838
        RSLens *rs_lens = RS_LENS(single_lens_data->lens);
 
839
 
 
840
        gchar *camera_make;
 
841
        gchar *camera_model;
 
842
        gdouble min_focal;
 
843
        gdouble max_focal;
 
844
 
 
845
        g_assert(RS_IS_LENS(rs_lens));
 
846
        g_object_get(rs_lens,
 
847
                     "camera-make", &camera_make,
 
848
                     "camera-model", &camera_model,
 
849
                     "min-focal", &min_focal,
 
850
                     "max-focal", &max_focal,
 
851
                     NULL);
 
852
 
 
853
        gchar *lens_search;
 
854
        if (min_focal == max_focal)
 
855
         lens_search = g_strdup_printf("%.0fmm", min_focal);
 
856
        else
 
857
         lens_search = g_strdup_printf("%.0f-%.0f", min_focal, max_focal);
 
858
 
 
859
        cameras = lf_db_find_cameras(lensdb, camera_make, camera_model);
 
860
        if (cameras)
 
861
                camera = cameras[0];
 
862
 
 
863
        if (camera)
 
864
        {
 
865
                const lfLens **lenslist = lf_db_find_lenses_hd (
 
866
                        lensdb, camera, NULL, lens_search, 0);
 
867
                const lfLens **full_lenslist = lf_db_find_lenses_hd (
 
868
                        lensdb, camera, NULL, NULL, 0);
 
869
 
 
870
                if (!lenslist && !full_lenslist)
 
871
                        return;
 
872
 
 
873
                lens_menu_fill (data, lenslist, full_lenslist);
 
874
                lf_free (lenslist);
 
875
        }
 
876
        else
 
877
        {
 
878
                const lfLens **lenslist = lf_db_find_lenses_hd (
 
879
                        lensdb, NULL, NULL, lens_search, 0);
 
880
                const lfLens *const *full_lenslist = lf_db_get_lenses (lensdb);
 
881
 
 
882
                if (!lenslist)
 
883
                        return;
 
884
                lens_menu_fill (data, lenslist, full_lenslist);
 
885
        }
 
886
 
 
887
        g_free(lens_search);
 
888
 
 
889
        gtk_menu_popup (GTK_MENU (data->LensMenu), NULL, NULL, NULL, NULL,
 
890
                        0, gtk_get_current_event_time ());
 
891
}
 
892
 
 
893
void
 
894
enable_lens(GtkCheckButton *checkbutton, gpointer user_data)
 
895
{
 
896
        RSLens *lens = user_data;
 
897
        rs_lens_set_lensfun_enabled(lens, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton)));
 
898
}
 
899
 
 
900
void
 
901
open_full_lens_editor(GtkCheckButton *checkbutton, gpointer user_data)
 
902
{
 
903
        rs_lens_db_editor();
 
904
}
 
905
 
 
906
static gchar* 
 
907
boldify(const gchar* text)
 
908
{
 
909
        return g_strconcat("<b>", text, "</b>", NULL);
 
910
}
 
911
 
 
912
GtkDialog *
 
913
rs_lens_db_editor_single_lens(RSLens *lens)
 
914
{
 
915
 
 
916
        gchar *identifier;
 
917
        gchar *lensfun_make;
 
918
        gchar *lensfun_model;
 
919
        gdouble min_focal, max_focal, min_aperture, max_aperture;
 
920
        gchar *camera_make;
 
921
        gchar *camera_model;
 
922
        gboolean enabled;
 
923
 
 
924
        g_assert(RS_IS_LENS(lens));
 
925
        g_object_get(lens,
 
926
                     "identifier", &identifier,
 
927
                     "lensfun-make", &lensfun_make,
 
928
                     "lensfun-model", &lensfun_model,
 
929
                     "min-focal", &min_focal,
 
930
                     "max-focal", &max_focal,
 
931
                     "min-aperture", &min_aperture,
 
932
                     "max-aperture", &max_aperture,
 
933
                     "camera-make", &camera_make,
 
934
                     "camera-model", &camera_model,
 
935
                     "enabled", &enabled,
 
936
                     NULL);
 
937
        
 
938
        GtkWidget *editor = gtk_dialog_new();
 
939
        gtk_window_set_title(GTK_WINDOW(editor), _("Rawstudio Lens Editor"));
 
940
        gtk_dialog_set_has_separator (GTK_DIALOG(editor), FALSE);
 
941
        g_signal_connect_swapped(editor, "delete_event",
 
942
                                 G_CALLBACK (gtk_widget_destroy), editor);
 
943
        g_signal_connect_swapped(editor, "response",
 
944
                                 G_CALLBACK (gtk_widget_destroy), editor);
 
945
 
 
946
        GtkWidget *frame = gtk_frame_new("");
 
947
        GtkWidget *table = gtk_table_new(2, 10, FALSE);
 
948
 
 
949
        GtkWidget *label1 = gtk_label_new("");
 
950
        gtk_label_set_markup(GTK_LABEL(label1), boldify(_("Lens Make")));
 
951
        gtk_misc_set_alignment(GTK_MISC(label1), 0, 0);
 
952
 
 
953
        GtkWidget *label2 = gtk_label_new("");
 
954
        gtk_label_set_markup(GTK_LABEL(label2), boldify(_("Lens Model")));
 
955
        gtk_misc_set_alignment(GTK_MISC(label2), 0, 0);
 
956
 
 
957
        GtkWidget *label3 = gtk_label_new("");
 
958
        gtk_label_set_markup(GTK_LABEL(label3), boldify(_("Focal Length")));
 
959
        gtk_misc_set_alignment(GTK_MISC(label3), 0, 0);
 
960
 
 
961
        GtkWidget *label4 = gtk_label_new("");
 
962
        gtk_label_set_markup(GTK_LABEL(label4), boldify(_("Aperture")));
 
963
        gtk_misc_set_alignment(GTK_MISC(label4), 0, 0);
 
964
 
 
965
        GtkWidget *label5 = gtk_label_new("");
 
966
        gtk_label_set_markup(GTK_LABEL(label5), boldify(_("Camera Make")));
 
967
        gtk_misc_set_alignment(GTK_MISC(label5), 0, 0);
 
968
 
 
969
        GtkWidget *label6 = gtk_label_new("");
 
970
        gtk_label_set_markup(GTK_LABEL(label6), boldify(_("Camera Model")));
 
971
        gtk_misc_set_alignment(GTK_MISC(label6), 0, 0);
 
972
 
 
973
//      GtkWidget *label7 = gtk_label_new("");
 
974
//      gtk_label_set_markup(GTK_LABEL(label7), "<b>Enabled</b>");
 
975
//      gtk_misc_set_alignment(GTK_MISC(label7), 0, 0);
 
976
 
 
977
        gtk_table_attach_defaults(GTK_TABLE(table), label5, 0,1,0,1);
 
978
        gtk_table_attach_defaults(GTK_TABLE(table), label6, 0,1,1,2);
 
979
        gtk_table_attach_defaults(GTK_TABLE(table), label3, 0,1,2,3);
 
980
        gtk_table_attach_defaults(GTK_TABLE(table), label4, 0,1,3,4);
 
981
//      gtk_table_attach_defaults(GTK_TABLE(table), label7, 0,1,4,5);
 
982
        gtk_table_attach_defaults(GTK_TABLE(table), label1, 0,1,6,7);
 
983
        gtk_table_attach_defaults(GTK_TABLE(table), label2, 0,1,7,8);
 
984
 
 
985
        GtkWidget *label_lensfun_make = gtk_label_new(lensfun_make);
 
986
        GtkWidget *label_lensfun_model = gtk_label_new(lensfun_model);
 
987
        GtkWidget *label_focal;
 
988
        if (min_focal == max_focal)
 
989
                label_focal = gtk_label_new(g_strdup_printf("%.0fmm", min_focal));
 
990
        else
 
991
                label_focal = gtk_label_new(g_strdup_printf("%.0f-%.0fmm", min_focal, max_focal));
 
992
        GtkWidget *label_aperture = gtk_label_new(g_strdup_printf("F/%.1f", max_aperture));
 
993
        GtkWidget *label_camera_make = gtk_label_new(camera_make);
 
994
        GtkWidget *label_camera_model = gtk_label_new(camera_model);
 
995
        GtkWidget *checkbutton_enabled = gtk_check_button_new_with_label(_("Enable this lens"));
 
996
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_enabled), rs_lens_get_lensfun_enabled(lens));
 
997
 
 
998
        GtkWidget *button_set_lens = gtk_button_new_with_label(_("Set lens"));
 
999
 
 
1000
        GtkWidget *sep1 = gtk_hseparator_new();
 
1001
        GtkWidget *sep2 = gtk_hseparator_new();
 
1002
 
 
1003
        SingleLensData *single_lens_data = g_malloc(sizeof(SingleLensData));
 
1004
        single_lens_data->lensfun_make = label_lensfun_make;
 
1005
        single_lens_data->lensfun_model = label_lensfun_model;
 
1006
        single_lens_data->lens = lens;
 
1007
        single_lens_data->button = button_set_lens;
 
1008
        single_lens_data->checkbutton_enabled = checkbutton_enabled;
 
1009
 
 
1010
        g_signal_connect(button_set_lens, "clicked", G_CALLBACK(set_lens), single_lens_data);
 
1011
 
 
1012
        gtk_misc_set_alignment(GTK_MISC(label_lensfun_make), 1, 0);
 
1013
        gtk_misc_set_alignment(GTK_MISC(label_lensfun_model), 1, 0);
 
1014
        gtk_misc_set_alignment(GTK_MISC(label_focal), 1, 0);
 
1015
        gtk_misc_set_alignment(GTK_MISC(label_aperture), 1, 0);
 
1016
        gtk_misc_set_alignment(GTK_MISC(label_camera_make), 1, 0);
 
1017
        gtk_misc_set_alignment(GTK_MISC(label_camera_model), 1, 0);
 
1018
//      gtk_button_set_alignment(GTK_BUTTON(checkbutton_enabled), 1, 0);
 
1019
 
 
1020
        gtk_table_attach_defaults(GTK_TABLE(table), label_camera_make, 1,2,0,1);
 
1021
        gtk_table_attach_defaults(GTK_TABLE(table), label_camera_model, 1,2,1,2);
 
1022
        gtk_table_attach_defaults(GTK_TABLE(table), label_focal, 1,2,2,3);
 
1023
        gtk_table_attach_defaults(GTK_TABLE(table), label_aperture, 1,2,3,4);
 
1024
        gtk_table_attach_defaults(GTK_TABLE(table), sep1, 0,2,5,6);
 
1025
        gtk_table_attach_defaults(GTK_TABLE(table), label_lensfun_make, 1,2,6,7);
 
1026
        gtk_table_attach_defaults(GTK_TABLE(table), label_lensfun_model, 1,2,7,8);
 
1027
        gtk_table_attach_defaults(GTK_TABLE(table), button_set_lens, 1,2,6,8);
 
1028
        gtk_table_attach_defaults(GTK_TABLE(table), sep2, 0,2,8,9);
 
1029
        gtk_table_attach_defaults(GTK_TABLE(table), checkbutton_enabled, 0,2,9,10);
 
1030
 
 
1031
        /* Set spacing around separator in table */
 
1032
        gtk_table_set_row_spacing(GTK_TABLE(table), 4, 10);
 
1033
        gtk_table_set_row_spacing(GTK_TABLE(table), 5, 10);
 
1034
        gtk_table_set_row_spacing(GTK_TABLE(table), 7, 10);
 
1035
        gtk_table_set_row_spacing(GTK_TABLE(table), 8, 10);
 
1036
 
 
1037
        gtk_window_resize(GTK_WINDOW(editor), 300, 1);
 
1038
 
 
1039
        gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
 
1040
        gtk_container_set_border_width (GTK_CONTAINER (table), 6);
 
1041
 
 
1042
        gtk_box_pack_start (GTK_BOX (GTK_DIALOG(editor)->vbox), frame, TRUE, TRUE, 0);
 
1043
        gtk_container_add (GTK_CONTAINER (frame), table);
 
1044
 
 
1045
        g_signal_connect(checkbutton_enabled, "toggled", G_CALLBACK(enable_lens), lens);
 
1046
 
 
1047
        /* FIXME: Put lensfun update button in editor - for this to work, we cannot close the window when updating */
 
1048
//      GtkWidget *button_update_lensfun = gtk_button_new_with_label(_("Update lensfun database"));
 
1049
//      g_signal_connect(button_update_lensfun, "clicked", G_CALLBACK(update_lensfun), NULL);
 
1050
//      gtk_dialog_add_action_widget (GTK_DIALOG (editor), button_update_lensfun, GTK_RESPONSE_NONE);
 
1051
 
 
1052
        GtkWidget *button_lens_library = gtk_button_new_with_label(_("Lens Library"));
 
1053
        g_signal_connect(button_lens_library, "clicked", G_CALLBACK(open_full_lens_editor), lens);
 
1054
        gtk_dialog_add_action_widget (GTK_DIALOG (editor), button_lens_library, GTK_RESPONSE_CLOSE);
 
1055
 
 
1056
        GtkWidget *button_close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
 
1057
        gtk_dialog_add_action_widget (GTK_DIALOG (editor), button_close, GTK_RESPONSE_CLOSE);
 
1058
 
 
1059
        gtk_widget_show_all(GTK_WIDGET(editor));
 
1060
        if (!rs_lens_get_lensfun_model(lens) || !rs_lens_get_lensfun_make(lens))
 
1061
        {
 
1062
                gtk_widget_hide(label_lensfun_make);
 
1063
                gtk_widget_hide(label_lensfun_model);
 
1064
                gtk_widget_show(button_set_lens);
 
1065
        }
 
1066
        else
 
1067
        {
 
1068
                gtk_widget_show(label_lensfun_make);
 
1069
                gtk_widget_show(label_lensfun_model);
 
1070
                gtk_widget_hide(button_set_lens);
 
1071
        }
 
1072
        return GTK_DIALOG(editor);
 
1073
}