← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rawstudio/trusty-proposed

« back to all changes in this revision

Viewing changes to src/rs-cache.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2008-04-20 10:52:00 UTC
  • mfrom: (2.1.8 upstream) (1.1.13 hardy)
  • Revision ID: james.westby@ubuntu.com-20080420105200-kaaznfiftfmz2tsc
Tags: 1.0-1
http://bugs.debian.org/476828
* New upstream release (Closes: #476828).
* Removing 01-icon-path.dpatch, not required anymore.
* Removing watch file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rs-cache.c
1
1
/*
2
 
 * Copyright (C) 2006 Anders Brander <anders@brander.dk> and 
 
2
 * Copyright (C) 2006-2008 Anders Brander <anders@brander.dk> and 
3
3
 * Anders Kvist <akv@lnxbx.dk>
4
4
 *
5
5
 * This program is free software; you can redistribute it and/or
17
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
18
18
 */
19
19
 
20
 
#include <gtk/gtk.h>
 
20
#include <glib.h>
21
21
#include <libxml/encoding.h>
22
22
#include <libxml/xmlwriter.h>
23
 
#include "matrix.h"
24
 
#include "rs-batch.h"
25
23
#include "rawstudio.h"
 
24
#include "rs-cache.h"
 
25
#include "rs-photo.h"
 
26
 
 
27
/* This will be written to XML files for making backward compatibility easier to implement */
 
28
#define CACHEVERSION 2
 
29
 
 
30
static void rs_cache_load_setting(RS_SETTINGS_DOUBLE *rss, xmlDocPtr doc, xmlNodePtr cur);
26
31
 
27
32
gchar *
28
33
rs_cache_get_name(const gchar *src)
35
40
        if (dotdir)
36
41
        {
37
42
                out = g_string_new(dotdir);
38
 
                out = g_string_append(out, "/");
 
43
                out = g_string_append(out, G_DIR_SEPARATOR_S);
39
44
                out = g_string_append(out, filename);
40
45
                out = g_string_append(out, ".cache.xml");
41
46
                ret = out->str;
47
52
}
48
53
 
49
54
void
50
 
rs_cache_init()
51
 
{
52
 
        static gboolean init=FALSE;
53
 
        if (!init)
54
 
                LIBXML_TEST_VERSION /* yep, it should look like this */
55
 
        init = TRUE;
56
 
        return;
57
 
}
58
 
 
59
 
void
60
55
rs_cache_save(RS_PHOTO *photo)
61
56
{
62
 
        gint id;
 
57
        gint id, i;
63
58
        xmlTextWriterPtr writer;
64
59
        gchar *cachename;
65
60
 
66
 
        if(!photo->active) return;
67
61
        cachename = rs_cache_get_name(photo->filename);
68
62
        if (!cachename) return;
69
63
        writer = xmlNewTextWriterFilename(cachename, 0); /* fixme, check for errors */
 
64
        xmlTextWriterSetIndent(writer, 1);
70
65
        xmlTextWriterStartDocument(writer, NULL, "ISO-8859-1", NULL);
71
66
        xmlTextWriterStartElement(writer, BAD_CAST "rawstudio-cache");
 
67
        xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "version", "%d", CACHEVERSION);
72
68
        xmlTextWriterWriteFormatElement(writer, BAD_CAST "priority", "%d",
73
69
                photo->priority);
 
70
        if (photo->exported)
 
71
                xmlTextWriterWriteFormatElement(writer, BAD_CAST "exported", "yes");
74
72
        xmlTextWriterWriteFormatElement(writer, BAD_CAST "orientation", "%d",
75
73
                photo->orientation);
 
74
        xmlTextWriterWriteFormatElement(writer, BAD_CAST "angle", "%f",
 
75
                photo->angle);
 
76
        if (photo->crop)
 
77
        {
 
78
                xmlTextWriterWriteFormatElement(writer, BAD_CAST "crop", "%d %d %d %d",
 
79
                        photo->crop->x1, photo->crop->y1,
 
80
                        photo->crop->x2, photo->crop->y2);
 
81
        }
76
82
        for(id=0;id<3;id++)
77
83
        {
78
84
                xmlTextWriterStartElement(writer, BAD_CAST "settings");
89
95
                        photo->settings[id]->warmth);
90
96
                xmlTextWriterWriteFormatElement(writer, BAD_CAST "tint", "%f",
91
97
                        photo->settings[id]->tint);
 
98
                xmlTextWriterWriteFormatElement(writer, BAD_CAST "sharpen", "%f",
 
99
                        photo->settings[id]->sharpen);
 
100
                if (photo->settings[id]->curve_nknots > 0)
 
101
                {
 
102
                        xmlTextWriterStartElement(writer, BAD_CAST "curve");
 
103
                        xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "num", "%d", photo->settings[id]->curve_nknots);
 
104
                        for(i=0;i<photo->settings[id]->curve_nknots;i++)
 
105
                                xmlTextWriterWriteFormatElement(writer, BAD_CAST "knot", "%f %f",
 
106
                                        photo->settings[id]->curve_knots[i*2+0],
 
107
                                        photo->settings[id]->curve_knots[i*2+1]);
 
108
                        xmlTextWriterEndElement(writer);
 
109
                }
92
110
                xmlTextWriterEndElement(writer);
93
111
        }
94
112
        xmlTextWriterEndDocument(writer);
97
115
        return;
98
116
}
99
117
 
100
 
void
 
118
static void
101
119
rs_cache_load_setting(RS_SETTINGS_DOUBLE *rss, xmlDocPtr doc, xmlNodePtr cur)
102
120
{
103
121
        xmlChar *val;
104
122
        gdouble *target=NULL;
 
123
        xmlNodePtr curve = NULL;
105
124
        while(cur)
106
125
        {
107
126
                target = NULL;
117
136
                        target = &rss->warmth;
118
137
                else if ((!xmlStrcmp(cur->name, BAD_CAST "tint")))
119
138
                        target = &rss->tint;
 
139
                else if ((!xmlStrcmp(cur->name, BAD_CAST "sharpen")))
 
140
                        target = &rss->sharpen;
 
141
                else if ((!xmlStrcmp(cur->name, BAD_CAST "curve")))
 
142
                {
 
143
                        gchar **vals;
 
144
                        gint num;
 
145
                        gfloat x,y;
 
146
 
 
147
                        val = xmlGetProp(cur, BAD_CAST "num");
 
148
                        if (val)
 
149
                                num = atoi((gchar *) val);
 
150
                        else
 
151
                                num = 0;
 
152
 
 
153
                        rss->curve_knots = g_new(gfloat, 2*num);
 
154
                        rss->curve_nknots = 0;
 
155
                        curve = cur->xmlChildrenNode;
 
156
                        while (curve && num)
 
157
                        {
 
158
                                if ((!xmlStrcmp(curve->name, BAD_CAST "knot")))
 
159
                                {
 
160
                                        val = xmlNodeListGetString(doc, curve->xmlChildrenNode, 1);
 
161
                                        vals = g_strsplit((gchar *)val, " ", 4);
 
162
                                        if (vals[0] && vals[1])
 
163
                                        {
 
164
                                                x = g_strtod(vals[0], NULL);
 
165
                                                y = g_strtod(vals[1], NULL);
 
166
                                                rss->curve_knots[rss->curve_nknots*2+0] = x;
 
167
                                                rss->curve_knots[rss->curve_nknots*2+1] = y;
 
168
                                                rss->curve_nknots++;
 
169
                                                num--;
 
170
                                        }
 
171
                                        g_strfreev(vals);
 
172
                                        xmlFree(val);
 
173
                                }
 
174
                                curve = curve->next;
 
175
                        }
 
176
                }
120
177
 
121
178
                if (target)
122
179
                {
136
193
        xmlChar *val;
137
194
        gchar *cachename;
138
195
        gint id;
 
196
        gint version = 0;
 
197
        RS_SETTINGS_DOUBLE *settings;
139
198
 
140
199
        cachename = rs_cache_get_name(photo->filename);
141
200
        if (!cachename) return(FALSE);
142
201
        if (!g_file_test(cachename, G_FILE_TEST_IS_REGULAR)) return FALSE;
 
202
        photo->exported = FALSE;
143
203
        doc = xmlParseFile(cachename);
144
204
        if(doc==NULL) return(FALSE);
145
205
 
146
206
        cur = xmlDocGetRootElement(doc);
147
207
 
 
208
        if ((!xmlStrcmp(cur->name, BAD_CAST "rawstudio-cache")))
 
209
        {
 
210
                val = xmlGetProp(cur, BAD_CAST "version");
 
211
                if (val)
 
212
                        version = atoi((gchar *) val);
 
213
        }
 
214
 
148
215
        cur = cur->xmlChildrenNode;
149
216
        while(cur)
150
217
        {
155
222
                        xmlFree(val);
156
223
                        if (id>2) id=0;
157
224
                        if (id<0) id=0;
158
 
                        rs_cache_load_setting(photo->settings[id], doc, cur->xmlChildrenNode);
 
225
                        settings = rs_settings_double_new();
 
226
                        rs_cache_load_setting(settings, doc, cur->xmlChildrenNode);
 
227
                        rs_photo_apply_settings_double(photo, id, settings, MASK_ALL);
 
228
                        rs_settings_double_free(settings);
159
229
                }
160
230
                else if ((!xmlStrcmp(cur->name, BAD_CAST "priority")))
161
231
                {
169
239
                        photo->orientation = atoi((gchar *) val);
170
240
                        xmlFree(val);
171
241
                }
 
242
                else if ((!xmlStrcmp(cur->name, BAD_CAST "angle")))
 
243
                {
 
244
                        val = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
 
245
                        photo->angle = g_strtod((gchar *) val, NULL);
 
246
                        xmlFree(val);
 
247
                }
 
248
                else if ((!xmlStrcmp(cur->name, BAD_CAST "exported")))
 
249
                {
 
250
                        val = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
 
251
                        if (g_ascii_strcasecmp((gchar *) val, "yes")==0)
 
252
                                photo->exported = TRUE;
 
253
                        xmlFree(val);
 
254
                }
 
255
                else if ((!xmlStrcmp(cur->name, BAD_CAST "crop")))
 
256
                {
 
257
                        RS_RECT *crop = g_new0(RS_RECT, 1);
 
258
                        gchar **vals;
 
259
 
 
260
                        val = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
 
261
                        vals = g_strsplit((gchar *)val, " ", 4);
 
262
                        if (vals[0])
 
263
                        {
 
264
                                crop->x1 = atoi((gchar *) vals[0]);
 
265
                                if (vals[1])
 
266
                                {
 
267
                                        crop->y1 = atoi((gchar *) vals[1]);
 
268
                                        if (vals[2])
 
269
                                        {
 
270
                                                crop->x2 = atoi((gchar *) vals[2]);
 
271
                                                if (vals[3])
 
272
                                                        crop->y2 = atoi((gchar *) vals[3]);
 
273
                                        }
 
274
                                }
 
275
                        }
 
276
 
 
277
                        /* If crop was done before demosaic was implemented, we should
 
278
                           double the dimensions */
 
279
                        if (version < 2)
 
280
                        {
 
281
                                crop->x1 *= 2;
 
282
                                crop->y1 *= 2;
 
283
                                crop->x2 *= 2;
 
284
                                crop->y2 *= 2;
 
285
                        }
 
286
 
 
287
                        rs_photo_set_crop(photo, crop);
 
288
                        g_free(crop);
 
289
                        g_strfreev(vals);
 
290
                        xmlFree(val);
 
291
                }
172
292
                cur = cur->next;
173
293
        }
174
 
        
 
294
 
175
295
        xmlFreeDoc(doc);
176
296
        g_free(cachename);
177
297
        return(TRUE);
178
298
}
179
299
 
180
300
void
181
 
rs_cache_load_quick(const gchar *filename, gint *priority)
 
301
rs_cache_load_quick(const gchar *filename, gint *priority, gboolean *exported)
182
302
{
183
303
        xmlDocPtr doc;
184
304
        xmlNodePtr cur;
185
305
        xmlChar *val;
186
306
        gchar *cachename;
187
307
 
 
308
        if (!filename)
 
309
                return;
 
310
 
188
311
        cachename = rs_cache_get_name(filename);
189
 
        if (!cachename) return;
190
 
        if (!g_file_test(cachename, G_FILE_TEST_IS_REGULAR)) return;
 
312
 
 
313
        if (!cachename)
 
314
                return;
 
315
 
 
316
        if (!g_file_test(cachename, G_FILE_TEST_IS_REGULAR))
 
317
        {
 
318
                g_free(cachename);
 
319
                return;
 
320
        }
 
321
 
191
322
        doc = xmlParseFile(cachename);
192
 
        if(doc==NULL) return;
 
323
        g_free(cachename);
 
324
 
 
325
        if(doc==NULL)
 
326
                return;
 
327
 
 
328
        if (exported) *exported = FALSE;
193
329
 
194
330
        cur = xmlDocGetRootElement(doc);
195
331
 
196
332
        cur = cur->xmlChildrenNode;
197
333
        while(cur)
198
334
        {
199
 
                if ((!xmlStrcmp(cur->name, BAD_CAST "priority")))
 
335
                if (priority && (!xmlStrcmp(cur->name, BAD_CAST "priority")))
200
336
                {
201
337
                        val = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
202
338
                        *priority = atoi((gchar *) val);
203
339
                        xmlFree(val);
204
340
                }
 
341
                if (exported && (!xmlStrcmp(cur->name, BAD_CAST "exported")))
 
342
                {
 
343
                        val = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
 
344
                        if (g_ascii_strcasecmp((gchar *) val, "yes")==0)
 
345
                                *exported = TRUE;
 
346
                        xmlFree(val);
 
347
                }
205
348
                cur = cur->next;
206
349
        }
207
350
        
208
351
        xmlFreeDoc(doc);
209
 
        g_free(cachename);
 
352
        return;
 
353
}
 
354
 
 
355
void
 
356
rs_cache_save_flags(const gchar *filename, const guint *priority, const gboolean *exported)
 
357
{
 
358
        RS_PHOTO *photo;
 
359
 
 
360
        g_assert(filename != NULL);
 
361
 
 
362
        if (!(priority || exported)) return;
 
363
 
 
364
        /* Aquire a "fake" RS_PHOTO */
 
365
        photo = rs_photo_new();
 
366
        photo->filename = (gchar *) filename;
 
367
 
 
368
        if (rs_cache_load(photo))
 
369
        {
 
370
                /* If we got a cache file, save as normal */
 
371
                if (priority)
 
372
                        photo->priority = *priority;
 
373
                if (exported)
 
374
                        photo->exported = *exported;
 
375
                rs_cache_save(photo);
 
376
        }
 
377
        else
 
378
        {
 
379
                /* If we're creating a new file, only save what we know */
 
380
                xmlTextWriterPtr writer;
 
381
                gchar *cachename = rs_cache_get_name(photo->filename);
 
382
 
 
383
                if (cachename)
 
384
                {
 
385
                        writer = xmlNewTextWriterFilename(cachename, 0); /* fixme, check for errors */
 
386
                        g_free(cachename);
 
387
 
 
388
                        xmlTextWriterStartDocument(writer, NULL, "ISO-8859-1", NULL);
 
389
                        xmlTextWriterStartElement(writer, BAD_CAST "rawstudio-cache");
 
390
 
 
391
                        if (priority)
 
392
                                xmlTextWriterWriteFormatElement(writer, BAD_CAST "priority", "%d",
 
393
                                        *priority);
 
394
 
 
395
                        if (exported && *exported)
 
396
                                xmlTextWriterWriteFormatElement(writer, BAD_CAST "exported", "yes");
 
397
 
 
398
                        xmlTextWriterEndDocument(writer);
 
399
                        xmlFreeTextWriter(writer);
 
400
                }
 
401
        }
 
402
 
 
403
        /* Free the photo */
 
404
        photo->filename = NULL;
 
405
        g_object_unref(photo);
 
406
 
210
407
        return;
211
408
}