aboutsummaryrefslogtreecommitdiff
path: root/src/plugins/fs/meta.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/fs/meta.c')
-rw-r--r--src/plugins/fs/meta.c887
1 files changed, 413 insertions, 474 deletions
diff --git a/src/plugins/fs/meta.c b/src/plugins/fs/meta.c
index c1665251..b5861ebf 100644
--- a/src/plugins/fs/meta.c
+++ b/src/plugins/fs/meta.c
@@ -31,602 +31,541 @@
31#include "fs.h" 31#include "fs.h"
32#include <extractor.h> 32#include <extractor.h>
33 33
34static int publishMetaData(EXTRACTOR_KeywordType type, 34static int
35 const char * data, 35publishMetaData (EXTRACTOR_KeywordType type, const char *data, void *cls)
36 void * cls) { 36{
37 GtkListStore * store = cls; 37 GtkListStore *store = cls;
38 const char * stype; 38 const char *stype;
39 GtkTreeIter iter; 39 GtkTreeIter iter;
40 40
41 stype = EXTRACTOR_getKeywordTypeAsString(type); 41 stype = EXTRACTOR_getKeywordTypeAsString (type);
42 if (stype == NULL) /* wrong LE version!? */ 42 if (stype == NULL) /* wrong LE version!? */
43 stype = _("unknown"); 43 stype = _("unknown");
44 gtk_list_store_append(store, 44 gtk_list_store_append (store, &iter);
45 &iter); 45 gtk_list_store_set (store,
46 gtk_list_store_set(store, 46 &iter,
47 &iter, 47 META_TYPE, type,
48 META_TYPE, type, 48 META_STYPE, stype, META_VALUE, data, -1);
49 META_STYPE, stype,
50 META_VALUE, data,
51 -1);
52 return OK; 49 return OK;
53} 50}
54 51
55void createMetaDataListTreeView(GladeXML * xml, 52void
56 const char * name, 53createMetaDataListTreeView (GladeXML * xml,
57 const char * previewName, 54 const char *name,
58 const struct ECRS_MetaData * init) { 55 const char *previewName,
59 GtkTreeView * metaList; 56 const struct ECRS_MetaData *init)
60 GtkListStore * metamodel; 57{
61 GtkCellRenderer * renderer; 58 GtkTreeView *metaList;
62 GtkWidget * preview; 59 GtkListStore *metamodel;
63 GdkPixbuf * pixbuf; 60 GtkCellRenderer *renderer;
64 GdkPixbufLoader * loader; 61 GtkWidget *preview;
65 unsigned char * thumb; 62 GdkPixbuf *pixbuf;
63 GdkPixbufLoader *loader;
64 unsigned char *thumb;
66 size_t ts; 65 size_t ts;
67 GtkTreeViewColumn * column; 66 GtkTreeViewColumn *column;
68 int col; 67 int col;
69 68
70 DEBUG_BEGIN(); 69 DEBUG_BEGIN ();
71 metamodel 70 metamodel
72 = gtk_list_store_new(META_NUM, 71 = gtk_list_store_new (META_NUM, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
73 G_TYPE_INT, 72 metaList = GTK_TREE_VIEW (glade_xml_get_widget (xml, name));
74 G_TYPE_STRING, 73 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (metaList),
75 G_TYPE_STRING); 74 GTK_SELECTION_MULTIPLE);
76 metaList = GTK_TREE_VIEW(glade_xml_get_widget(xml, 75 renderer = gtk_cell_renderer_text_new ();
77 name)); 76 col = gtk_tree_view_insert_column_with_attributes (metaList,
78 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(metaList), 77 -1,
79 GTK_SELECTION_MULTIPLE); 78 _("Category"),
80 renderer = gtk_cell_renderer_text_new(); 79 renderer,
81 col = gtk_tree_view_insert_column_with_attributes(metaList, 80 "text", META_STYPE,
82 -1, 81 NULL);
83 _("Category"), 82 column = gtk_tree_view_get_column (metaList, col - 1);
84 renderer, 83 gtk_tree_view_column_set_resizable (column, TRUE);
85 "text", META_STYPE, 84 gtk_tree_view_column_set_clickable (column, TRUE);
86 NULL); 85 gtk_tree_view_column_set_reorderable (column, TRUE);
87 column = gtk_tree_view_get_column(metaList, 86 gtk_tree_view_column_set_sort_column_id (column, META_STYPE);
88 col - 1); 87 renderer = gtk_cell_renderer_text_new ();
89 gtk_tree_view_column_set_resizable(column, TRUE); 88 col = gtk_tree_view_insert_column_with_attributes (metaList,
90 gtk_tree_view_column_set_clickable(column, TRUE); 89 -1,
91 gtk_tree_view_column_set_reorderable(column, TRUE); 90 _("Value"),
92 gtk_tree_view_column_set_sort_column_id(column, META_STYPE); 91 renderer,
93 renderer = gtk_cell_renderer_text_new(); 92 "text", META_VALUE,
94 col = gtk_tree_view_insert_column_with_attributes(metaList, 93 NULL);
95 -1, 94 column = gtk_tree_view_get_column (metaList, col - 1);
96 _("Value"), 95 gtk_tree_view_column_set_resizable (column, TRUE);
97 renderer, 96 gtk_tree_view_column_set_clickable (column, TRUE);
98 "text", META_VALUE, 97 gtk_tree_view_column_set_reorderable (column, TRUE);
99 NULL); 98 gtk_tree_view_column_set_sort_column_id (column, META_VALUE);
100 column = gtk_tree_view_get_column(metaList, 99 gtk_tree_view_set_model (metaList, GTK_TREE_MODEL (metamodel));
101 col - 1);
102 gtk_tree_view_column_set_resizable(column, TRUE);
103 gtk_tree_view_column_set_clickable(column, TRUE);
104 gtk_tree_view_column_set_reorderable(column, TRUE);
105 gtk_tree_view_column_set_sort_column_id(column, META_VALUE);
106 gtk_tree_view_set_model(metaList,
107 GTK_TREE_MODEL(metamodel));
108 100
109 if (init != NULL) 101 if (init != NULL)
110 ECRS_getMetaData(init, 102 ECRS_getMetaData (init, &publishMetaData, metamodel);
111 &publishMetaData, 103 if ((previewName == NULL) || (init == NULL))
112 metamodel);
113 if ( (previewName == NULL) ||
114 (init == NULL) )
115 return; 104 return;
116 preview = glade_xml_get_widget(xml, 105 preview = glade_xml_get_widget (xml, previewName);
117 previewName);
118 106
119 thumb = NULL; 107 thumb = NULL;
120 ts = ECRS_getThumbnailFromMetaData(init, 108 ts = ECRS_getThumbnailFromMetaData (init, &thumb);
121 &thumb); 109 preview = glade_xml_get_widget (xml, previewName);
122 preview = glade_xml_get_widget(xml, 110 if (ts != 0)
123 previewName); 111 {
124 if (ts != 0) { 112 loader = gdk_pixbuf_loader_new ();
125 loader = gdk_pixbuf_loader_new(); 113 gdk_pixbuf_loader_write (loader, (const guchar *) thumb, ts, NULL);
126 gdk_pixbuf_loader_write(loader, 114 pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
127 (const guchar*) thumb, 115 g_object_ref (pixbuf);
128 ts, 116 gdk_pixbuf_loader_close (loader, NULL);
129 NULL); 117 if (pixbuf != NULL)
130 pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); 118 {
131 g_object_ref(pixbuf); 119 gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf);
132 gdk_pixbuf_loader_close(loader, 120 g_object_unref (pixbuf);
133 NULL); 121 }
134 if (pixbuf != NULL) { 122 UNREF (loader);
135 gtk_image_set_from_pixbuf(GTK_IMAGE(preview),
136 pixbuf);
137 g_object_unref(pixbuf);
138 } 123 }
139 UNREF(loader); 124 DEBUG_END ();
140 }
141 DEBUG_END();
142} 125}
143 126
144static int publishKeyword(const char * data, 127static int
145 void * cls) { 128publishKeyword (const char *data, void *cls)
146 GtkListStore * store = cls; 129{
130 GtkListStore *store = cls;
147 GtkTreeIter iter; 131 GtkTreeIter iter;
148 132
149 DEBUG_BEGIN(); 133 DEBUG_BEGIN ();
150 gtk_list_store_append(store, 134 gtk_list_store_append (store, &iter);
151 &iter); 135 gtk_list_store_set (store, &iter, 0, data, -1);
152 gtk_list_store_set(store, 136 DEBUG_END ();
153 &iter,
154 0, data,
155 -1);
156 DEBUG_END();
157 return OK; 137 return OK;
158} 138}
159 139
160void createKeywordListTreeView(GladeXML * xml, 140void
161 const char * name, 141createKeywordListTreeView (GladeXML * xml,
162 const struct ECRS_URI * init) { 142 const char *name, const struct ECRS_URI *init)
163 GtkTreeView * keywordList; 143{
164 GtkListStore * keymodel; 144 GtkTreeView *keywordList;
165 GtkCellRenderer * renderer; 145 GtkListStore *keymodel;
166 GtkTreeViewColumn * column; 146 GtkCellRenderer *renderer;
167 147 GtkTreeViewColumn *column;
168 DEBUG_BEGIN(); 148
169 keymodel 149 DEBUG_BEGIN ();
170 = gtk_list_store_new(1, 150 keymodel = gtk_list_store_new (1, G_TYPE_STRING);
171 G_TYPE_STRING); 151 keywordList = GTK_TREE_VIEW (glade_xml_get_widget (xml, name));
172 keywordList = GTK_TREE_VIEW(glade_xml_get_widget(xml, 152 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (keywordList),
173 name)); 153 GTK_SELECTION_MULTIPLE);
174 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(keywordList), 154 renderer = gtk_cell_renderer_text_new ();
175 GTK_SELECTION_MULTIPLE); 155 gtk_tree_view_insert_column_with_attributes (keywordList,
176 renderer = gtk_cell_renderer_text_new(); 156 -1,
177 gtk_tree_view_insert_column_with_attributes(keywordList, 157 _("Keyword"),
178 -1, 158 renderer, "text", 0, NULL);
179 _("Keyword"), 159 column = gtk_tree_view_get_column (keywordList, 0);
180 renderer, 160 gtk_tree_view_column_set_resizable (column, TRUE);
181 "text", 0, 161 gtk_tree_view_column_set_clickable (column, TRUE);
182 NULL); 162 gtk_tree_view_column_set_reorderable (column, TRUE);
183 column = gtk_tree_view_get_column(keywordList, 163 gtk_tree_view_column_set_sort_column_id (column, 0);
184 0); 164 gtk_tree_view_set_model (keywordList, GTK_TREE_MODEL (keymodel));
185 gtk_tree_view_column_set_resizable(column, TRUE);
186 gtk_tree_view_column_set_clickable(column, TRUE);
187 gtk_tree_view_column_set_reorderable(column, TRUE);
188 gtk_tree_view_column_set_sort_column_id(column, 0);
189 gtk_tree_view_set_model(keywordList,
190 GTK_TREE_MODEL(keymodel));
191 if (init != NULL) 165 if (init != NULL)
192 ECRS_getKeywordsFromUri(init, 166 ECRS_getKeywordsFromUri (init, &publishKeyword, keymodel);
193 &publishKeyword, 167 DEBUG_END ();
194 keymodel);
195 DEBUG_END();
196} 168}
197 169
198void createMetaTypeComboBox(GladeXML * xml, 170void
199 const char * name) { 171createMetaTypeComboBox (GladeXML * xml, const char *name)
200 const char * stype; 172{
201 GtkWidget * metaType; 173 const char *stype;
202 GtkCellRenderer * renderer; 174 GtkWidget *metaType;
203 GtkListStore * keywordTypeModel; 175 GtkCellRenderer *renderer;
176 GtkListStore *keywordTypeModel;
204 GtkTreeIter iter; 177 GtkTreeIter iter;
205 EXTRACTOR_KeywordType type; 178 EXTRACTOR_KeywordType type;
206 179
207 DEBUG_BEGIN(); 180 DEBUG_BEGIN ();
208 keywordTypeModel 181 keywordTypeModel
209 = gtk_list_store_new(KTYPE_NUM, 182 = gtk_list_store_new (KTYPE_NUM, G_TYPE_STRING, G_TYPE_INT);
210 G_TYPE_STRING, 183 metaType = glade_xml_get_widget (xml, name);
211 G_TYPE_INT); 184 gtk_combo_box_set_model (GTK_COMBO_BOX (metaType),
212 metaType = glade_xml_get_widget(xml, 185 GTK_TREE_MODEL (keywordTypeModel));
213 name); 186 for (type = 0; type < EXTRACTOR_getHighestKeywordTypeNumber (); type++)
214 gtk_combo_box_set_model(GTK_COMBO_BOX(metaType), 187 {
215 GTK_TREE_MODEL(keywordTypeModel)); 188 stype = EXTRACTOR_getKeywordTypeAsString (type);
216 for (type=0;type<EXTRACTOR_getHighestKeywordTypeNumber();type++) { 189 gtk_list_store_append (keywordTypeModel, &iter);
217 stype = EXTRACTOR_getKeywordTypeAsString(type); 190 gtk_list_store_set (keywordTypeModel,
218 gtk_list_store_append(keywordTypeModel, 191 &iter, KTYPE_STRING, stype, KTYPE_TYPE, type, -1);
219 &iter); 192 }
220 gtk_list_store_set(keywordTypeModel, 193 renderer = gtk_cell_renderer_text_new ();
221 &iter, 194 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (metaType), renderer, FALSE);
222 KTYPE_STRING, stype, 195 gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (metaType),
223 KTYPE_TYPE, type, 196 renderer, "text", KTYPE_STRING);
224 -1); 197 gtk_combo_box_set_active (GTK_COMBO_BOX (metaType), 0);
225 } 198 DEBUG_END ();
226 renderer = gtk_cell_renderer_text_new();
227 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(metaType),
228 renderer,
229 FALSE);
230 gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(metaType),
231 renderer,
232 "text", KTYPE_STRING);
233 gtk_combo_box_set_active(GTK_COMBO_BOX(metaType),
234 0);
235 DEBUG_END();
236} 199}
237 200
238void handleKeywordListUpdate(GladeXML * xml, 201void
239 const char * inputLineName, 202handleKeywordListUpdate (GladeXML * xml,
240 const char * keywordListName) { 203 const char *inputLineName,
241 const char * keyword; 204 const char *keywordListName)
242 GtkWidget * keywordList; 205{
243 GtkWidget * entryLine; 206 const char *keyword;
244 GtkListStore * keymodel; 207 GtkWidget *keywordList;
208 GtkWidget *entryLine;
209 GtkListStore *keymodel;
245 GtkTreeIter iter; 210 GtkTreeIter iter;
246 211
247 DEBUG_BEGIN(); 212 DEBUG_BEGIN ();
248 keywordList = glade_xml_get_widget(xml, 213 keywordList = glade_xml_get_widget (xml, keywordListName);
249 keywordListName);
250 keymodel 214 keymodel
251 = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(keywordList))); 215 = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (keywordList)));
252 216
253 entryLine = glade_xml_get_widget(xml, 217 entryLine = glade_xml_get_widget (xml, inputLineName);
254 inputLineName); 218 keyword = gtk_entry_get_text (GTK_ENTRY (entryLine));
255 keyword = gtk_entry_get_text(GTK_ENTRY(entryLine)); 219 gtk_list_store_append (keymodel, &iter);
256 gtk_list_store_append(keymodel, 220 gtk_list_store_set (keymodel, &iter, 0, keyword, -1);
257 &iter); 221 gtk_entry_set_text (GTK_ENTRY (entryLine), "");
258 gtk_list_store_set(keymodel, 222 DEBUG_END ();
259 &iter,
260 0, keyword,
261 -1);
262 gtk_entry_set_text(GTK_ENTRY(entryLine), "");
263 DEBUG_END();
264} 223}
265 224
266void handleMetaDataListUpdate(GladeXML * xml, 225void
267 const char * typeInputLineName, 226handleMetaDataListUpdate (GladeXML * xml,
268 const char * valueInputLineName, 227 const char *typeInputLineName,
269 const char * metaDataListName) { 228 const char *valueInputLineName,
270 const char * value; 229 const char *metaDataListName)
271 GtkWidget * metaList; 230{
272 GtkWidget * entryLine; 231 const char *value;
273 GtkWidget * typeCB; 232 GtkWidget *metaList;
233 GtkWidget *entryLine;
234 GtkWidget *typeCB;
274 EXTRACTOR_KeywordType type; 235 EXTRACTOR_KeywordType type;
275 GtkListStore * metamodel; 236 GtkListStore *metamodel;
276 GtkListStore * typemodel; 237 GtkListStore *typemodel;
277 GtkTreeIter iter; 238 GtkTreeIter iter;
278 char * stype; 239 char *stype;
279 240
280 DEBUG_BEGIN(); 241 DEBUG_BEGIN ();
281 metaList = glade_xml_get_widget(xml, 242 metaList = glade_xml_get_widget (xml, metaDataListName);
282 metaDataListName);
283 metamodel 243 metamodel
284 = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(metaList))); 244 = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (metaList)));
285 245
286 entryLine = glade_xml_get_widget(xml, 246 entryLine = glade_xml_get_widget (xml, valueInputLineName);
287 valueInputLineName); 247 value = gtk_entry_get_text (GTK_ENTRY (entryLine));
288 value = gtk_entry_get_text(GTK_ENTRY(entryLine)); 248 if ((value == NULL) || (strlen (value) == 0))
289 if ( (value == NULL) || (strlen(value) == 0) )
290 return; 249 return;
291 typeCB = glade_xml_get_widget(xml, 250 typeCB = glade_xml_get_widget (xml, typeInputLineName);
292 typeInputLineName);
293 typemodel 251 typemodel
294 = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(typeCB))); 252 = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (typeCB)));
295 if (! gtk_combo_box_get_active_iter(GTK_COMBO_BOX(typeCB), 253 if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (typeCB), &iter))
296 &iter)) 254 return; /* oops */
297 return; /* oops */ 255 gtk_tree_model_get (GTK_TREE_MODEL (typemodel),
298 gtk_tree_model_get(GTK_TREE_MODEL(typemodel), 256 &iter, KTYPE_STRING, &stype, KTYPE_TYPE, &type, -1);
299 &iter, 257 gtk_list_store_append (metamodel, &iter);
300 KTYPE_STRING, &stype, 258 gtk_list_store_set (metamodel,
301 KTYPE_TYPE, &type, 259 &iter,
302 -1); 260 META_TYPE, type,
303 gtk_list_store_append(metamodel, 261 META_STYPE, stype, META_VALUE, value, -1);
304 &iter); 262 gtk_entry_set_text (GTK_ENTRY (entryLine), "");
305 gtk_list_store_set(metamodel, 263 FREENONNULL (stype);
306 &iter, 264 DEBUG_END ();
307 META_TYPE, type,
308 META_STYPE, stype,
309 META_VALUE, value,
310 -1);
311 gtk_entry_set_text(GTK_ENTRY(entryLine), "");
312 FREENONNULL(stype);
313 DEBUG_END();
314} 265}
315 266
316static void removeRow(GtkTreeModel * model, 267static void
317 GtkTreePath * path, 268removeRow (GtkTreeModel * model,
318 GtkTreeIter * iter, 269 GtkTreePath * path, GtkTreeIter * iter, gpointer unused)
319 gpointer unused) { 270{
320 gtk_list_store_remove(GTK_LIST_STORE(model), 271 gtk_list_store_remove (GTK_LIST_STORE (model), iter);
321 iter);
322} 272}
323 273
324void handleListRemove(GladeXML * xml, 274void
325 const char * listName) { 275handleListRemove (GladeXML * xml, const char *listName)
326 GtkWidget * list; 276{
277 GtkWidget *list;
327 278
328 list = glade_xml_get_widget(xml, 279 list = glade_xml_get_widget (xml, listName);
329 listName);
330 ggc_tree_selection_selected_foreach 280 ggc_tree_selection_selected_foreach
331 (gtk_tree_view_get_selection(GTK_TREE_VIEW(list)), 281 (gtk_tree_view_get_selection (GTK_TREE_VIEW (list)), &removeRow, NULL);
332 &removeRow,
333 NULL);
334} 282}
335 283
336#define THUMBSIZE 128 284#define THUMBSIZE 128
337 285
338 286
339struct ECRS_MetaData * getMetaDataFromList(GladeXML * xml, 287struct ECRS_MetaData *
340 const char * name, 288getMetaDataFromList (GladeXML * xml,
341 const char * previewName) { 289 const char *name, const char *previewName)
342 GtkWidget * metaList; 290{
343 GtkWidget * preview; 291 GtkWidget *metaList;
344 GtkTreeModel * metamodel; 292 GtkWidget *preview;
293 GtkTreeModel *metamodel;
345 GtkTreeIter iter; 294 GtkTreeIter iter;
346 struct ECRS_MetaData * meta; 295 struct ECRS_MetaData *meta;
347 EXTRACTOR_KeywordType type; 296 EXTRACTOR_KeywordType type;
348 GdkPixbuf * pixbuf; 297 GdkPixbuf *pixbuf;
349 GdkPixbuf * out; 298 GdkPixbuf *out;
350 char * mvalue; 299 char *mvalue;
351 size_t length; 300 size_t length;
352 unsigned long width; 301 unsigned long width;
353 unsigned long height; 302 unsigned long height;
354 char * thumb; 303 char *thumb;
355 304
356 metaList = glade_xml_get_widget(xml, 305 metaList = glade_xml_get_widget (xml, name);
357 name); 306 metamodel = gtk_tree_view_get_model (GTK_TREE_VIEW (metaList));
358 metamodel = gtk_tree_view_get_model(GTK_TREE_VIEW(metaList)); 307 meta = ECRS_createMetaData ();
359 meta = ECRS_createMetaData(); 308 if (gtk_tree_model_get_iter_first (metamodel, &iter))
360 if (gtk_tree_model_get_iter_first(metamodel, 309 {
361 &iter)) { 310 do
362 do { 311 {
363 gtk_tree_model_get(metamodel, 312 gtk_tree_model_get (metamodel,
364 &iter, 313 &iter,
365 META_TYPE, &type, 314 META_TYPE, &type, META_VALUE, &mvalue, -1);
366 META_VALUE, &mvalue, 315 ECRS_addToMetaData (meta, type, mvalue);
367 -1); 316 FREENONNULL (mvalue);
368 ECRS_addToMetaData(meta, 317 }
369 type, 318 while (gtk_tree_model_iter_next (metamodel, &iter));
370 mvalue); 319 }
371 FREENONNULL(mvalue);
372 } while (gtk_tree_model_iter_next(metamodel,
373 &iter));
374 }
375 if (previewName == NULL) 320 if (previewName == NULL)
376 return meta; 321 return meta;
377 322
378 preview = glade_xml_get_widget(xml, 323 preview = glade_xml_get_widget (xml, previewName);
379 previewName); 324
380 325 if (GTK_IMAGE_PIXBUF == gtk_image_get_storage_type (GTK_IMAGE (preview)))
381 if (GTK_IMAGE_PIXBUF == 326 {
382 gtk_image_get_storage_type(GTK_IMAGE(preview))) { 327 pixbuf = gtk_image_get_pixbuf (GTK_IMAGE (preview));
383 pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(preview)); 328 if (pixbuf == NULL)
384 if (pixbuf == NULL) 329 return meta;
385 return meta; 330 height = gdk_pixbuf_get_height (pixbuf);
386 height = gdk_pixbuf_get_height(pixbuf); 331 width = gdk_pixbuf_get_width (pixbuf);
387 width = gdk_pixbuf_get_width(pixbuf); 332 if ((height > THUMBSIZE) || (width > THUMBSIZE))
388 if ( (height > THUMBSIZE) || 333 {
389 (width > THUMBSIZE) ) { 334 if (height > THUMBSIZE)
390 if (height > THUMBSIZE) { 335 {
391 width = width * THUMBSIZE / height; 336 width = width * THUMBSIZE / height;
392 height = THUMBSIZE; 337 height = THUMBSIZE;
393 } 338 }
394 if (width > THUMBSIZE) { 339 if (width > THUMBSIZE)
395 height = height * THUMBSIZE / width; 340 {
396 width = THUMBSIZE; 341 height = height * THUMBSIZE / width;
397 } 342 width = THUMBSIZE;
398 out = gdk_pixbuf_scale_simple(pixbuf, 343 }
399 width, 344 out = gdk_pixbuf_scale_simple (pixbuf,
400 height, 345 width, height, GDK_INTERP_BILINEAR);
401 GDK_INTERP_BILINEAR); 346 g_object_unref (pixbuf);
402 g_object_unref(pixbuf); 347 pixbuf = out;
403 pixbuf = out; 348 }
349 if (pixbuf != NULL)
350 {
351 thumb = NULL;
352 if (gdk_pixbuf_save_to_buffer (pixbuf,
353 &thumb, &length, "png", NULL, NULL))
354 {
355 char *binary;
356
357 binary = EXTRACTOR_binaryEncode ((const unsigned char *) thumb,
358 length);
359 free (thumb);
360 ECRS_addToMetaData (meta, EXTRACTOR_THUMBNAIL_DATA, binary);
361 FREE (binary);
362 }
363 }
404 } 364 }
405 if (pixbuf != NULL) {
406 thumb = NULL;
407 if (gdk_pixbuf_save_to_buffer(pixbuf,
408 &thumb,
409 &length,
410 "png",
411 NULL,
412 NULL)) {
413 char * binary;
414
415 binary = EXTRACTOR_binaryEncode((const unsigned char*)thumb,
416 length);
417 free(thumb);
418 ECRS_addToMetaData(meta,
419 EXTRACTOR_THUMBNAIL_DATA,
420 binary);
421 FREE(binary);
422 }
423 }
424 }
425 return meta; 365 return meta;
426} 366}
427 367
428struct ECRS_URI * getKeywordURIFromList(GladeXML * xml, 368struct ECRS_URI *
429 const char * name) { 369getKeywordURIFromList (GladeXML * xml, const char *name)
430 GtkTreeModel * keymodel; 370{
431 GtkTreeView * keyList; 371 GtkTreeModel *keymodel;
372 GtkTreeView *keyList;
432 GtkTreeIter iter; 373 GtkTreeIter iter;
433 struct ECRS_URI * keywordURI; 374 struct ECRS_URI *keywordURI;
434 char * mvalue; 375 char *mvalue;
435 char ** keywords; 376 char **keywords;
436 unsigned int kpos; 377 unsigned int kpos;
437 unsigned int ksize; 378 unsigned int ksize;
438 379
439 DEBUG_BEGIN(); 380 DEBUG_BEGIN ();
440 keyList = GTK_TREE_VIEW(glade_xml_get_widget(xml, 381 keyList = GTK_TREE_VIEW (glade_xml_get_widget (xml, name));
441 name)); 382 keymodel = gtk_tree_view_get_model (keyList);
442 keymodel = gtk_tree_view_get_model(keyList);
443 383
444 keywords = NULL; 384 keywords = NULL;
445 ksize = 0; 385 ksize = 0;
446 GROW(keywords, 386 GROW (keywords, ksize, 64);
447 ksize,
448 64);
449 kpos = 0; 387 kpos = 0;
450 if (gtk_tree_model_get_iter_first(keymodel, 388 if (gtk_tree_model_get_iter_first (keymodel, &iter))
451 &iter)) { 389 {
452 do { 390 do
453 gtk_tree_model_get(keymodel, 391 {
454 &iter, 392 gtk_tree_model_get (keymodel, &iter, 0, &mvalue, -1);
455 0, &mvalue, 393 keywords[kpos++] = mvalue;
456 -1); 394 if (kpos == ksize)
457 keywords[kpos++] = mvalue; 395 GROW (keywords, ksize, kpos * 2);
458 if (kpos == ksize) 396 }
459 GROW(keywords, 397 while (gtk_tree_model_iter_next (keymodel, &iter));
460 ksize, 398 }
461 kpos*2);
462 } while (gtk_tree_model_iter_next(keymodel,
463 &iter));
464 }
465 keywords[kpos] = NULL; 399 keywords[kpos] = NULL;
466 400
467 keywordURI = ECRS_keywordsToUri((const char**)keywords); 401 keywordURI = ECRS_keywordsToUri ((const char **) keywords);
468 while (kpos > 0) 402 while (kpos > 0)
469 FREE(keywords[--kpos]); 403 FREE (keywords[--kpos]);
470 GROW(keywords, 404 GROW (keywords, ksize, 0);
471 ksize, 405 DEBUG_END ();
472 0);
473 DEBUG_END();
474 return keywordURI; 406 return keywordURI;
475} 407}
476 408
477char * updateIntervalToString(TIME_T interval) { 409char *
410updateIntervalToString (TIME_T interval)
411{
478 if (interval == ECRS_SBLOCK_UPDATE_SPORADIC) 412 if (interval == ECRS_SBLOCK_UPDATE_SPORADIC)
479 return strdup(_("--sporadic update--")); 413 return strdup (_("--sporadic update--"));
480 if (interval == ECRS_SBLOCK_UPDATE_NONE) 414 if (interval == ECRS_SBLOCK_UPDATE_NONE)
481 return strdup(_("--no update--")); 415 return strdup (_("--no update--"));
482 return string_get_fancy_time_interval(interval * cronSECONDS); 416 return string_get_fancy_time_interval (interval * cronSECONDS);
483} 417}
484 418
485int parseTimeInterval(const char * timeSpec, 419int
486 TIME_T * interval) { 420parseTimeInterval (const char *timeSpec, TIME_T * interval)
421{
487 if (timeSpec == NULL) 422 if (timeSpec == NULL)
488 return SYSERR; 423 return SYSERR;
489 if (0 == strcmp(_("--sporadic update--"), 424 if (0 == strcmp (_("--sporadic update--"), timeSpec))
490 timeSpec))
491 *interval = ECRS_SBLOCK_UPDATE_SPORADIC; 425 *interval = ECRS_SBLOCK_UPDATE_SPORADIC;
492 else if (0 == strcmp(_("--no update--"), 426 else if (0 == strcmp (_("--no update--"), timeSpec))
493 timeSpec))
494 *interval = ECRS_SBLOCK_UPDATE_NONE; 427 *interval = ECRS_SBLOCK_UPDATE_NONE;
495 else 428 else
496 return parseTime(timeSpec, 429 return parseTime (timeSpec, interval);
497 interval);
498 return OK; 430 return OK;
499} 431}
500 432
501int tryParseTimeInterval(GladeXML * xml, 433int
502 const char * intervalComboBoxEntry, 434tryParseTimeInterval (GladeXML * xml,
503 TIME_T * interval) { 435 const char *intervalComboBoxEntry, TIME_T * interval)
504 return parseTimeInterval(getEntryLineValue(xml, 436{
505 intervalComboBoxEntry), 437 return parseTimeInterval (getEntryLineValue (xml,
506 interval); 438 intervalComboBoxEntry),
439 interval);
507} 440}
508 441
509unsigned int getSpinButtonValue(GladeXML * xml, 442unsigned int
510 const char * spinButtonName) { 443getSpinButtonValue (GladeXML * xml, const char *spinButtonName)
511 GtkWidget * spin; 444{
445 GtkWidget *spin;
512 446
513 spin = glade_xml_get_widget(xml, 447 spin = glade_xml_get_widget (xml, spinButtonName);
514 spinButtonName); 448 return gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin));
515 return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
516} 449}
517 450
518 451
519 452
520char * getMimeTypeFromMetaData(const struct ECRS_MetaData * meta) { 453char *
521 char * mime; 454getMimeTypeFromMetaData (const struct ECRS_MetaData *meta)
455{
456 char *mime;
522 457
523 mime = ECRS_getFromMetaData(meta, 458 mime = ECRS_getFromMetaData (meta, EXTRACTOR_MIMETYPE);
524 EXTRACTOR_MIMETYPE);
525 if (mime == NULL) 459 if (mime == NULL)
526 mime = STRDUP(_("unknown")); 460 mime = STRDUP (_("unknown"));
527 return validate_utf8(mime); 461 return validate_utf8 (mime);
528} 462}
529 463
530char * getFileNameFromMetaData(const struct ECRS_MetaData * meta) { 464char *
531 char * name; 465getFileNameFromMetaData (const struct ECRS_MetaData *meta)
532 466{
533 name = ECRS_getFirstFromMetaData(meta, 467 char *name;
534 EXTRACTOR_FILENAME, 468
535 EXTRACTOR_TITLE, 469 name = ECRS_getFirstFromMetaData (meta,
536 EXTRACTOR_ARTIST, 470 EXTRACTOR_FILENAME,
537 EXTRACTOR_AUTHOR, 471 EXTRACTOR_TITLE,
538 EXTRACTOR_PUBLISHER, 472 EXTRACTOR_ARTIST,
539 EXTRACTOR_CREATOR, 473 EXTRACTOR_AUTHOR,
540 EXTRACTOR_PRODUCER, 474 EXTRACTOR_PUBLISHER,
541 EXTRACTOR_UNKNOWN, 475 EXTRACTOR_CREATOR,
542 -1); 476 EXTRACTOR_PRODUCER,
543 if (name == NULL) { 477 EXTRACTOR_UNKNOWN, -1);
544 name = STRDUP(_("no name given")); 478 if (name == NULL)
545 } else { 479 {
546 char * dotdot; 480 name = STRDUP (_("no name given"));
547 481 }
548 while (NULL != (dotdot = strstr(name, ".."))) 482 else
549 dotdot[0] = dotdot[1] = '_'; 483 {
550 } 484 char *dotdot;
551 return validate_utf8(name); 485
486 while (NULL != (dotdot = strstr (name, "..")))
487 dotdot[0] = dotdot[1] = '_';
488 }
489 return validate_utf8 (name);
552} 490}
553 491
554char * getDescriptionFromMetaData(const struct ECRS_MetaData * meta) { 492char *
555 char * desc; 493getDescriptionFromMetaData (const struct ECRS_MetaData *meta)
556 494{
557 desc = ECRS_getFirstFromMetaData(meta, 495 char *desc;
558 EXTRACTOR_DESCRIPTION, 496
559 EXTRACTOR_GENRE, 497 desc = ECRS_getFirstFromMetaData (meta,
560 EXTRACTOR_ALBUM, 498 EXTRACTOR_DESCRIPTION,
561 EXTRACTOR_COMMENT, 499 EXTRACTOR_GENRE,
562 EXTRACTOR_SUBJECT, 500 EXTRACTOR_ALBUM,
563 EXTRACTOR_FORMAT, 501 EXTRACTOR_COMMENT,
564 EXTRACTOR_SIZE, 502 EXTRACTOR_SUBJECT,
565 EXTRACTOR_KEYWORDS, 503 EXTRACTOR_FORMAT,
566 -1); 504 EXTRACTOR_SIZE, EXTRACTOR_KEYWORDS, -1);
567 if (desc == NULL) 505 if (desc == NULL)
568 desc = STRDUP(""); 506 desc = STRDUP ("");
569 return validate_utf8(desc); 507 return validate_utf8 (desc);
570} 508}
571 509
572GdkPixbuf * getThumbnailFromMetaData(const struct ECRS_MetaData * meta) { 510GdkPixbuf *
573 GdkPixbuf * pixbuf; 511getThumbnailFromMetaData (const struct ECRS_MetaData * meta)
574 GdkPixbufLoader * loader; 512{
513 GdkPixbuf *pixbuf;
514 GdkPixbufLoader *loader;
575 size_t ts; 515 size_t ts;
576 unsigned char * thumb; 516 unsigned char *thumb;
577 517
578 thumb = NULL; 518 thumb = NULL;
579 ts = ECRS_getThumbnailFromMetaData(meta, 519 ts = ECRS_getThumbnailFromMetaData (meta, &thumb);
580 &thumb); 520 if (ts != 0)
581 if (ts != 0) { 521 {
582 loader = gdk_pixbuf_loader_new(); 522 loader = gdk_pixbuf_loader_new ();
583 gdk_pixbuf_loader_write(loader, 523 gdk_pixbuf_loader_write (loader, (const guchar *) thumb, ts, NULL);
584 (const guchar*) thumb, 524 pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
585 ts, 525 gdk_pixbuf_loader_close (loader, NULL);
586 NULL); 526 if (pixbuf != NULL)
587 pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); 527 g_object_ref (pixbuf);
588 gdk_pixbuf_loader_close(loader, 528 UNREF (loader);
589 NULL); 529 }
590 if (pixbuf != NULL) 530 else
591 g_object_ref(pixbuf); 531 {
592 UNREF(loader); 532 pixbuf = NULL;
593 } else { 533 }
594 pixbuf = NULL; 534 FREENONNULL (thumb);
595 }
596 FREENONNULL(thumb);
597 return pixbuf; 535 return pixbuf;
598} 536}
599 537
600GtkWidget * 538GtkWidget *
601extractMainWidgetFromWindow(GladeXML * xml, 539extractMainWidgetFromWindow (GladeXML * xml, const char *windowName)
602 const char * windowName) { 540{
603 GtkContainer * window; 541 GtkContainer *window;
604 GtkWidget * ret; 542 GtkWidget *ret;
605 543
606 window = GTK_CONTAINER(glade_xml_get_widget(xml, 544 window = GTK_CONTAINER (glade_xml_get_widget (xml, windowName));
607 windowName)); 545 ret = gtk_bin_get_child (GTK_BIN (window));
608 ret = gtk_bin_get_child(GTK_BIN(window)); 546 gtk_widget_ref (ret);
609 gtk_widget_ref(ret); 547 gtk_container_remove (window, ret);
610 gtk_container_remove(window, ret); 548 gtk_widget_destroy (GTK_WIDGET (window));
611 gtk_widget_destroy(GTK_WIDGET(window));
612 return ret; 549 return ret;
613} 550}
614 551
615int getToggleButtonValue(GladeXML * xml, 552int
616 const char * widgetName) { 553getToggleButtonValue (GladeXML * xml, const char *widgetName)
617 return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(xml, 554{
618 widgetName))); 555 return
556 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
557 (glade_xml_get_widget (xml, widgetName)));
619} 558}
620 559
621const char * getEntryLineValue(GladeXML * xml, 560const char *
622 const char * widgetName) { 561getEntryLineValue (GladeXML * xml, const char *widgetName)
623 GtkBin * line; 562{
624 GtkEntry * entry; 563 GtkBin *line;
564 GtkEntry *entry;
625 565
626 line = GTK_BIN(glade_xml_get_widget(xml, 566 line = GTK_BIN (glade_xml_get_widget (xml, widgetName));
627 widgetName)); 567 entry = GTK_ENTRY (gtk_bin_get_child (line));
628 entry = GTK_ENTRY(gtk_bin_get_child(line)); 568 return gtk_entry_get_text (entry);
629 return gtk_entry_get_text(entry);
630} 569}
631 570
632/* end of meta.c */ 571/* end of meta.c */
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-25 03:02:03 +0000