diff options
-rw-r--r-- | src/plugins/fs/Makefile.am | 1 | ||||
-rw-r--r-- | src/plugins/fs/collection.c | 143 | ||||
-rw-r--r-- | src/plugins/fs/meta.c | 412 | ||||
-rw-r--r-- | src/plugins/fs/meta.h | 63 | ||||
-rw-r--r-- | src/plugins/fs/namespace.c | 231 | ||||
-rw-r--r-- | src/plugins/fs/upload.c | 334 |
6 files changed, 548 insertions, 636 deletions
diff --git a/src/plugins/fs/Makefile.am b/src/plugins/fs/Makefile.am index 494a47c9..6a1c3b93 100644 --- a/src/plugins/fs/Makefile.am +++ b/src/plugins/fs/Makefile.am | |||
@@ -13,6 +13,7 @@ libgnunetgtkmodule_fs_la_SOURCES = \ | |||
13 | collection.c collection.h \ | 13 | collection.c collection.h \ |
14 | download.c download.h \ | 14 | download.c download.h \ |
15 | fs.c fs.h \ | 15 | fs.c fs.h \ |
16 | meta.c meta.h \ | ||
16 | namespace.c namespace.h \ | 17 | namespace.c namespace.h \ |
17 | search.c search.h \ | 18 | search.c search.h \ |
18 | upload.c upload.h | 19 | upload.c upload.h |
diff --git a/src/plugins/fs/collection.c b/src/plugins/fs/collection.c index f7bf5793..53e51e47 100644 --- a/src/plugins/fs/collection.c +++ b/src/plugins/fs/collection.c | |||
@@ -27,82 +27,32 @@ | |||
27 | #include "platform.h" | 27 | #include "platform.h" |
28 | #include "gnunetgtk_common.h" | 28 | #include "gnunetgtk_common.h" |
29 | #include "fs.h" | 29 | #include "fs.h" |
30 | #include "meta.h" | ||
30 | #include "collection.h" | 31 | #include "collection.h" |
31 | #include <extractor.h> | 32 | #include <extractor.h> |
32 | 33 | ||
33 | static GladeXML * metaXML; | 34 | static GladeXML * metaXML; |
34 | 35 | ||
35 | 36 | void on_collectionDialogMetaDataAddButton_clicked(gpointer dummy, | |
36 | 37 | GtkWidget * uploadButton) { | |
37 | /** | 38 | handleMetaDataListUpdate(metaXML, |
38 | * FIXME: somehow this function is not called | 39 | "collectionMetaDataTypeComboBox", |
39 | * when the button is clicked. | 40 | "collectionMetaDataValueEntry", |
40 | */ | 41 | "collectionMetaDataTreeView"); |
41 | void | ||
42 | on_collectionDialogMetaDataAddButton_clicked(gpointer dummy, | ||
43 | GtkWidget * uploadButton) { | ||
44 | GtkWidget * metaList; | ||
45 | GtkWidget * entryLine; | ||
46 | GtkWidget * typeCB; | ||
47 | const char * value; | ||
48 | EXTRACTOR_KeywordType type; | ||
49 | GtkListStore * metamodel; | ||
50 | GtkListStore * typemodel; | ||
51 | GtkTreeIter iter; | ||
52 | char * stype; | ||
53 | |||
54 | metaList = glade_xml_get_widget(metaXML, | ||
55 | "collectionMetaDataTreeView"); | ||
56 | metamodel | ||
57 | = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(metaList))); | ||
58 | |||
59 | entryLine = glade_xml_get_widget(metaXML, | ||
60 | "collectionMetaDataValueEntry"); | ||
61 | value = gtk_entry_get_text(GTK_ENTRY(entryLine)); | ||
62 | typeCB = glade_xml_get_widget(metaXML, | ||
63 | "collectionMetaDataTypeComboBox"); | ||
64 | typemodel | ||
65 | = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(typeCB))); | ||
66 | if (! gtk_combo_box_get_active_iter(GTK_COMBO_BOX(typeCB), | ||
67 | &iter)) | ||
68 | return; /* oops */ | ||
69 | gtk_tree_model_get(GTK_TREE_MODEL(typemodel), | ||
70 | &iter, | ||
71 | KTYPE_STRING, &stype, | ||
72 | KTYPE_TYPE, &type, | ||
73 | -1); | ||
74 | gtk_list_store_append(metamodel, | ||
75 | &iter); | ||
76 | gtk_list_store_set(metamodel, | ||
77 | &iter, | ||
78 | META_TYPE, type, | ||
79 | META_STYPE, stype, | ||
80 | META_VALUE, value, | ||
81 | -1); | ||
82 | gtk_entry_set_text(GTK_ENTRY(entryLine), ""); | ||
83 | } | 42 | } |
84 | 43 | ||
85 | 44 | ||
86 | void createCollection_clicked(GtkWidget * dummy1, | 45 | void createCollection_clicked(GtkWidget * dummy1, |
87 | GtkWidget * dummy2) { | 46 | GtkWidget * dummy2) { |
88 | GtkWidget * w; | ||
89 | const char * collectionName; | 47 | const char * collectionName; |
48 | const char * updateIntervalString; | ||
49 | GtkWidget * w; | ||
90 | GtkWidget * nameLine; | 50 | GtkWidget * nameLine; |
91 | GtkWidget * metaList; | ||
92 | GtkWidget * dialog; | 51 | GtkWidget * dialog; |
93 | GtkWidget * metaType; | ||
94 | GtkWidget * spin; | 52 | GtkWidget * spin; |
95 | GtkListStore * metamodel; | ||
96 | GtkCellRenderer * renderer; | ||
97 | GtkListStore * keywordTypeModel; | ||
98 | GtkTreeIter iter; | ||
99 | struct ECRS_MetaData * meta; | 53 | struct ECRS_MetaData * meta; |
100 | EXTRACTOR_KeywordType type; | ||
101 | const char * stype; | ||
102 | char * mvalue; | ||
103 | struct ECRS_URI * root; | 54 | struct ECRS_URI * root; |
104 | cron_t updateInterval; | 55 | cron_t updateInterval; |
105 | const char * updateIntervalString; | ||
106 | 56 | ||
107 | metaXML | 57 | metaXML |
108 | = glade_xml_new(getGladeFileName(), | 58 | = glade_xml_new(getGladeFileName(), |
@@ -111,75 +61,18 @@ void createCollection_clicked(GtkWidget * dummy1, | |||
111 | connectGladeWithPlugins(metaXML); | 61 | connectGladeWithPlugins(metaXML); |
112 | dialog = glade_xml_get_widget(metaXML, | 62 | dialog = glade_xml_get_widget(metaXML, |
113 | "createCollectionDialog"); | 63 | "createCollectionDialog"); |
114 | metamodel | 64 | createMetaDataListTreeView(metaXML, |
115 | = gtk_list_store_new(META_NUM, | 65 | "collectionMetaDataTreeView", |
116 | G_TYPE_INT, | 66 | NULL, |
117 | G_TYPE_STRING, | 67 | NULL); |
118 | G_TYPE_STRING); | 68 | createMetaTypeComboBox(metaXML, |
119 | metaList = glade_xml_get_widget(metaXML, | 69 | "collectionMetaTypeComboBox"); |
120 | "collectionMetaDataTreeView"); | ||
121 | renderer = gtk_cell_renderer_text_new(); | ||
122 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(metaList), | ||
123 | -1, | ||
124 | _("Category"), | ||
125 | renderer, | ||
126 | "text", META_STYPE, | ||
127 | NULL); | ||
128 | renderer = gtk_cell_renderer_text_new(); | ||
129 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(metaList), | ||
130 | -1, | ||
131 | _("Value"), | ||
132 | renderer, | ||
133 | "text", META_VALUE, | ||
134 | NULL); | ||
135 | gtk_tree_view_set_model(GTK_TREE_VIEW(metaList), | ||
136 | GTK_TREE_MODEL(metamodel)); | ||
137 | keywordTypeModel | ||
138 | = gtk_list_store_new(KTYPE_NUM, | ||
139 | G_TYPE_STRING, | ||
140 | G_TYPE_INT); | ||
141 | metaType | ||
142 | = glade_xml_get_widget(metaXML, | ||
143 | "collectionMetaTypeComboBox"); | ||
144 | gtk_combo_box_set_model(GTK_COMBO_BOX(metaType), | ||
145 | GTK_TREE_MODEL(keywordTypeModel)); | ||
146 | for (type=0;type<EXTRACTOR_getHighestKeywordTypeNumber();type++) { | ||
147 | stype = EXTRACTOR_getKeywordTypeAsString(type); | ||
148 | gtk_list_store_append(keywordTypeModel, | ||
149 | &iter); | ||
150 | gtk_list_store_set(keywordTypeModel, | ||
151 | &iter, | ||
152 | KTYPE_STRING, stype, | ||
153 | KTYPE_TYPE, type, | ||
154 | -1); | ||
155 | } | ||
156 | renderer = gtk_cell_renderer_text_new(); | ||
157 | gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(metaType), | ||
158 | renderer, | ||
159 | FALSE); | ||
160 | gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(metaType), | ||
161 | renderer, | ||
162 | "text", KTYPE_STRING); | ||
163 | gtk_combo_box_set_active(GTK_COMBO_BOX(metaType), | ||
164 | 0); | ||
165 | gtk_dialog_set_default_response(GTK_DIALOG(dialog), | 70 | gtk_dialog_set_default_response(GTK_DIALOG(dialog), |
166 | GTK_RESPONSE_OK); | 71 | GTK_RESPONSE_OK); |
167 | if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { | 72 | if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { |
168 | meta = ECRS_createMetaData(); | 73 | meta = getMetaDataFromList(metaXML, |
169 | if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(metamodel), | 74 | "collectionMetaDataTreeView", |
170 | &iter)) { | 75 | NULL); |
171 | do { | ||
172 | gtk_tree_model_get(GTK_TREE_MODEL(metamodel), | ||
173 | &iter, | ||
174 | META_TYPE, &type, | ||
175 | META_VALUE, &mvalue, | ||
176 | -1); | ||
177 | ECRS_addToMetaData(meta, | ||
178 | type, | ||
179 | mvalue); | ||
180 | } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(metamodel), | ||
181 | &iter)); | ||
182 | } | ||
183 | spin = glade_xml_get_widget(metaXML, | 76 | spin = glade_xml_get_widget(metaXML, |
184 | "collectionAnonymityLevel"); | 77 | "collectionAnonymityLevel"); |
185 | nameLine | 78 | nameLine |
diff --git a/src/plugins/fs/meta.c b/src/plugins/fs/meta.c new file mode 100644 index 00000000..044e9d82 --- /dev/null +++ b/src/plugins/fs/meta.c | |||
@@ -0,0 +1,412 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | (C) 2005 Christian Grothoff (and other contributing authors) | ||
4 | |||
5 | GNUnet is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published | ||
7 | by the Free Software Foundation; either version 2, or (at your | ||
8 | option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with GNUnet; see the file COPYING. If not, write to the | ||
17 | Free Software Foundation, Inc., 59 Temple Place - Suite 330, | ||
18 | Boston, MA 02111-1307, USA. | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file src/plugins/fs/meta.c | ||
23 | * @brief code for dealing with meta and keyword tree views | ||
24 | * @author Christian Grothoff | ||
25 | */ | ||
26 | |||
27 | #include "platform.h" | ||
28 | #include "meta.h" | ||
29 | #include "fs.h" | ||
30 | #include <extractor.h> | ||
31 | |||
32 | static int publishMetaData(EXTRACTOR_KeywordType type, | ||
33 | const char * data, | ||
34 | void * cls) { | ||
35 | GtkListStore * store = cls; | ||
36 | const char * stype; | ||
37 | GtkTreeIter iter; | ||
38 | |||
39 | stype = EXTRACTOR_getKeywordTypeAsString(type); | ||
40 | GNUNET_ASSERT(stype != NULL); | ||
41 | gtk_list_store_append(store, | ||
42 | &iter); | ||
43 | gtk_list_store_set(store, | ||
44 | &iter, | ||
45 | META_TYPE, type, | ||
46 | META_STYPE, stype, | ||
47 | META_VALUE, data, | ||
48 | -1); | ||
49 | return OK; | ||
50 | } | ||
51 | |||
52 | void createMetaDataListTreeView(GladeXML * xml, | ||
53 | const char * name, | ||
54 | const char * previewName, | ||
55 | const struct ECRS_MetaData * init) { | ||
56 | GtkWidget * metaList; | ||
57 | GtkListStore * metamodel; | ||
58 | GtkCellRenderer * renderer; | ||
59 | GtkWidget * preview; | ||
60 | GdkPixbuf * pixbuf; | ||
61 | GdkPixbufLoader * loader; | ||
62 | unsigned char * thumb; | ||
63 | size_t ts; | ||
64 | |||
65 | metamodel | ||
66 | = gtk_list_store_new(META_NUM, | ||
67 | G_TYPE_INT, | ||
68 | G_TYPE_STRING, | ||
69 | G_TYPE_STRING); | ||
70 | metaList = glade_xml_get_widget(xml, | ||
71 | name); | ||
72 | renderer = gtk_cell_renderer_text_new(); | ||
73 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(metaList), | ||
74 | -1, | ||
75 | _("Category"), | ||
76 | renderer, | ||
77 | "text", META_STYPE, | ||
78 | NULL); | ||
79 | renderer = gtk_cell_renderer_text_new(); | ||
80 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(metaList), | ||
81 | -1, | ||
82 | _("Value"), | ||
83 | renderer, | ||
84 | "text", META_VALUE, | ||
85 | NULL); | ||
86 | gtk_tree_view_set_model(GTK_TREE_VIEW(metaList), | ||
87 | GTK_TREE_MODEL(metamodel)); | ||
88 | if (init != NULL) | ||
89 | ECRS_getMetaData(init, | ||
90 | &publishMetaData, | ||
91 | metamodel); | ||
92 | if (previewName == NULL) | ||
93 | return; | ||
94 | preview = glade_xml_get_widget(xml, | ||
95 | previewName); | ||
96 | |||
97 | thumb = NULL; | ||
98 | ts = ECRS_getThumbnailFromMetaData(init, | ||
99 | &thumb); | ||
100 | preview = glade_xml_get_widget(xml, | ||
101 | previewName); | ||
102 | if (ts != 0) { | ||
103 | loader = gdk_pixbuf_loader_new(); | ||
104 | gdk_pixbuf_loader_write(loader, | ||
105 | (const guchar*) thumb, | ||
106 | ts, | ||
107 | NULL); | ||
108 | pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); | ||
109 | gdk_pixbuf_loader_close(loader, | ||
110 | NULL); | ||
111 | gtk_image_set_from_pixbuf(GTK_IMAGE(preview), | ||
112 | pixbuf); | ||
113 | g_object_unref(pixbuf); | ||
114 | } | ||
115 | } | ||
116 | |||
117 | static int publishKeyword(const char * data, | ||
118 | void * cls) { | ||
119 | GtkListStore * store = cls; | ||
120 | GtkTreeIter iter; | ||
121 | |||
122 | gtk_list_store_append(store, | ||
123 | &iter); | ||
124 | gtk_list_store_set(store, | ||
125 | &iter, | ||
126 | 0, data, | ||
127 | -1); | ||
128 | return OK; | ||
129 | } | ||
130 | |||
131 | void createKeywordListTreeView(GladeXML * xml, | ||
132 | const char * name, | ||
133 | const struct ECRS_URI * init) { | ||
134 | GtkWidget * keywordList; | ||
135 | GtkListStore * keymodel; | ||
136 | GtkCellRenderer * renderer; | ||
137 | |||
138 | keymodel | ||
139 | = gtk_list_store_new(1, | ||
140 | G_TYPE_STRING); | ||
141 | keywordList = glade_xml_get_widget(xml, | ||
142 | name); | ||
143 | renderer = gtk_cell_renderer_text_new(); | ||
144 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(keywordList), | ||
145 | -1, | ||
146 | _("Keyword"), | ||
147 | renderer, | ||
148 | "text", 0, | ||
149 | NULL); | ||
150 | gtk_tree_view_set_model(GTK_TREE_VIEW(keywordList), | ||
151 | GTK_TREE_MODEL(keymodel)); | ||
152 | if (init != NULL) | ||
153 | ECRS_getKeywordsFromUri(init, | ||
154 | &publishKeyword, | ||
155 | keymodel); | ||
156 | } | ||
157 | |||
158 | void createMetaTypeComboBox(GladeXML * xml, | ||
159 | const char * name) { | ||
160 | const char * stype; | ||
161 | GtkWidget * metaType; | ||
162 | GtkCellRenderer * renderer; | ||
163 | GtkListStore * keywordTypeModel; | ||
164 | GtkTreeIter iter; | ||
165 | EXTRACTOR_KeywordType type; | ||
166 | |||
167 | keywordTypeModel | ||
168 | = gtk_list_store_new(KTYPE_NUM, | ||
169 | G_TYPE_STRING, | ||
170 | G_TYPE_INT); | ||
171 | metaType = glade_xml_get_widget(xml, | ||
172 | name); | ||
173 | gtk_combo_box_set_model(GTK_COMBO_BOX(metaType), | ||
174 | GTK_TREE_MODEL(keywordTypeModel)); | ||
175 | for (type=0;type<EXTRACTOR_getHighestKeywordTypeNumber();type++) { | ||
176 | stype = EXTRACTOR_getKeywordTypeAsString(type); | ||
177 | gtk_list_store_append(keywordTypeModel, | ||
178 | &iter); | ||
179 | gtk_list_store_set(keywordTypeModel, | ||
180 | &iter, | ||
181 | KTYPE_STRING, stype, | ||
182 | KTYPE_TYPE, type, | ||
183 | -1); | ||
184 | } | ||
185 | renderer = gtk_cell_renderer_text_new(); | ||
186 | gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(metaType), | ||
187 | renderer, | ||
188 | FALSE); | ||
189 | gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(metaType), | ||
190 | renderer, | ||
191 | "text", KTYPE_STRING); | ||
192 | gtk_combo_box_set_active(GTK_COMBO_BOX(metaType), | ||
193 | 0); | ||
194 | } | ||
195 | |||
196 | void handleKeywordListUpdate(GladeXML * xml, | ||
197 | const char * inputLineName, | ||
198 | const char * keywordListName) { | ||
199 | const char * keyword; | ||
200 | GtkWidget * keywordList; | ||
201 | GtkWidget * entryLine; | ||
202 | GtkListStore * keymodel; | ||
203 | GtkTreeIter iter; | ||
204 | |||
205 | keywordList = glade_xml_get_widget(xml, | ||
206 | keywordListName); | ||
207 | keymodel | ||
208 | = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(keywordList))); | ||
209 | |||
210 | entryLine = glade_xml_get_widget(xml, | ||
211 | inputLineName); | ||
212 | keyword = gtk_entry_get_text(GTK_ENTRY(entryLine)); | ||
213 | gtk_list_store_append(keymodel, | ||
214 | &iter); | ||
215 | gtk_list_store_set(keymodel, | ||
216 | &iter, | ||
217 | 0, keyword, | ||
218 | -1); | ||
219 | gtk_entry_set_text(GTK_ENTRY(entryLine), ""); | ||
220 | } | ||
221 | |||
222 | void handleMetaDataListUpdate(GladeXML * xml, | ||
223 | const char * typeInputLineName, | ||
224 | const char * valueInputLineName, | ||
225 | const char * metaDataListName) { | ||
226 | const char * value; | ||
227 | GtkWidget * metaList; | ||
228 | GtkWidget * entryLine; | ||
229 | GtkWidget * typeCB; | ||
230 | EXTRACTOR_KeywordType type; | ||
231 | GtkListStore * metamodel; | ||
232 | GtkListStore * typemodel; | ||
233 | GtkTreeIter iter; | ||
234 | char * stype; | ||
235 | |||
236 | metaList = glade_xml_get_widget(xml, | ||
237 | metaDataListName); | ||
238 | metamodel | ||
239 | = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(metaList))); | ||
240 | |||
241 | entryLine = glade_xml_get_widget(xml, | ||
242 | valueInputLineName); | ||
243 | value = gtk_entry_get_text(GTK_ENTRY(entryLine)); | ||
244 | if ( (value == NULL) || (strlen(value) == 0) ) | ||
245 | return; | ||
246 | typeCB = glade_xml_get_widget(xml, | ||
247 | typeInputLineName); | ||
248 | typemodel | ||
249 | = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(typeCB))); | ||
250 | if (! gtk_combo_box_get_active_iter(GTK_COMBO_BOX(typeCB), | ||
251 | &iter)) | ||
252 | return; /* oops */ | ||
253 | gtk_tree_model_get(GTK_TREE_MODEL(typemodel), | ||
254 | &iter, | ||
255 | KTYPE_STRING, &stype, | ||
256 | KTYPE_TYPE, &type, | ||
257 | -1); | ||
258 | gtk_list_store_append(metamodel, | ||
259 | &iter); | ||
260 | gtk_list_store_set(metamodel, | ||
261 | &iter, | ||
262 | META_TYPE, type, | ||
263 | META_STYPE, stype, | ||
264 | META_VALUE, value, | ||
265 | -1); | ||
266 | gtk_entry_set_text(GTK_ENTRY(entryLine), ""); | ||
267 | } | ||
268 | |||
269 | struct ECRS_MetaData * getMetaDataFromList(GladeXML * xml, | ||
270 | const char * name, | ||
271 | const char * previewName) { | ||
272 | GtkWidget * metaList; | ||
273 | GtkWidget * preview; | ||
274 | GtkTreeModel * metamodel; | ||
275 | GtkTreeIter iter; | ||
276 | struct ECRS_MetaData * meta; | ||
277 | EXTRACTOR_KeywordType type; | ||
278 | GdkPixbuf * pixbuf; | ||
279 | char * mvalue; | ||
280 | |||
281 | metaList = glade_xml_get_widget(xml, | ||
282 | name); | ||
283 | metamodel = gtk_tree_view_get_model(GTK_TREE_VIEW(metaList)); | ||
284 | meta = ECRS_createMetaData(); | ||
285 | if (gtk_tree_model_get_iter_first(metamodel, | ||
286 | &iter)) { | ||
287 | do { | ||
288 | gtk_tree_model_get(metamodel, | ||
289 | &iter, | ||
290 | META_TYPE, &type, | ||
291 | META_VALUE, &mvalue, | ||
292 | -1); | ||
293 | ECRS_addToMetaData(meta, | ||
294 | type, | ||
295 | mvalue); | ||
296 | } while (gtk_tree_model_iter_next(metamodel, | ||
297 | &iter)); | ||
298 | } | ||
299 | if (previewName == NULL) | ||
300 | return meta; | ||
301 | |||
302 | preview = glade_xml_get_widget(xml, | ||
303 | previewName); | ||
304 | |||
305 | if (GTK_IMAGE_PIXBUF == | ||
306 | gtk_image_get_storage_type(GTK_IMAGE(preview))) { | ||
307 | size_t length; | ||
308 | char * thumb; | ||
309 | |||
310 | pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(preview)); | ||
311 | if (pixbuf != NULL) { | ||
312 | thumb = NULL; | ||
313 | if (gdk_pixbuf_save_to_buffer(pixbuf, | ||
314 | &thumb, | ||
315 | &length, | ||
316 | "png", | ||
317 | NULL, | ||
318 | NULL)) { | ||
319 | char * binary; | ||
320 | size_t pos; | ||
321 | size_t end; | ||
322 | size_t wpos; | ||
323 | size_t i; | ||
324 | unsigned int markers[8]; /* 256 bits */ | ||
325 | unsigned char marker; | ||
326 | |||
327 | /* encode! */ | ||
328 | binary = MALLOC(2 + length + (length+256) / 254); | ||
329 | pos = 0; | ||
330 | wpos = 0; | ||
331 | while (pos < length) { | ||
332 | /* find unused value between 1 and 255 in | ||
333 | the next 254 bytes */ | ||
334 | end = pos + 254; | ||
335 | if (end < pos) | ||
336 | break; /* integer overflow! */ | ||
337 | if (end > length) | ||
338 | end = length; | ||
339 | memset(markers, 0, sizeof(markers)); | ||
340 | for (i=pos;i<end;i++) | ||
341 | markers[thumb[i]&7] |= 1 << (thumb[i] >> 3); | ||
342 | marker = 1; | ||
343 | while (markers[marker&7] & (1 << (marker >> 3))) { | ||
344 | marker++; | ||
345 | GNUNET_ASSERT(marker != 0); | ||
346 | } | ||
347 | /* recode */ | ||
348 | binary[wpos++] = marker; | ||
349 | for (i=pos;i<end;i++) | ||
350 | binary[wpos++] = thumb[i] == 0 ? marker : thumb[i]; | ||
351 | pos = end; | ||
352 | } | ||
353 | binary[wpos++] = 0; /* 0-termination! */ | ||
354 | free(thumb); | ||
355 | ECRS_addToMetaData(meta, | ||
356 | EXTRACTOR_THUMBNAIL_DATA, | ||
357 | binary); | ||
358 | FREE(binary); | ||
359 | } | ||
360 | } | ||
361 | } | ||
362 | return meta; | ||
363 | } | ||
364 | |||
365 | struct ECRS_URI * getKeywordURIFromList(GladeXML * xml, | ||
366 | const char * name) { | ||
367 | GtkTreeModel * keymodel; | ||
368 | GtkTreeView * keyList; | ||
369 | GtkTreeIter iter; | ||
370 | struct ECRS_URI * keywordURI; | ||
371 | char * mvalue; | ||
372 | char ** keywords; | ||
373 | unsigned int kpos; | ||
374 | unsigned int ksize; | ||
375 | |||
376 | keyList = GTK_TREE_VIEW(glade_xml_get_widget(xml, | ||
377 | name)); | ||
378 | keymodel = gtk_tree_view_get_model(keyList); | ||
379 | |||
380 | keywords = NULL; | ||
381 | ksize = 0; | ||
382 | GROW(keywords, | ||
383 | ksize, | ||
384 | 64); | ||
385 | kpos = 0; | ||
386 | if (gtk_tree_model_get_iter_first(keymodel, | ||
387 | &iter)) { | ||
388 | do { | ||
389 | gtk_tree_model_get(keymodel, | ||
390 | &iter, | ||
391 | 0, &mvalue, | ||
392 | -1); | ||
393 | keywords[kpos++] = mvalue; | ||
394 | if (kpos == ksize) | ||
395 | GROW(keywords, | ||
396 | ksize, | ||
397 | kpos*2); | ||
398 | } while (gtk_tree_model_iter_next(keymodel, | ||
399 | &iter)); | ||
400 | } | ||
401 | keywords[kpos] = NULL; | ||
402 | |||
403 | keywordURI = ECRS_keywordsToUri((const char**)keywords); | ||
404 | while (kpos > 0) | ||
405 | FREE(keywords[--kpos]); | ||
406 | GROW(keywords, | ||
407 | ksize, | ||
408 | 0); | ||
409 | return keywordURI; | ||
410 | } | ||
411 | |||
412 | /* end of meta.c */ | ||
diff --git a/src/plugins/fs/meta.h b/src/plugins/fs/meta.h new file mode 100644 index 00000000..745d8944 --- /dev/null +++ b/src/plugins/fs/meta.h | |||
@@ -0,0 +1,63 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | (C) 2005 Christian Grothoff (and other contributing authors) | ||
4 | |||
5 | GNUnet is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published | ||
7 | by the Free Software Foundation; either version 2, or (at your | ||
8 | option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with GNUnet; see the file COPYING. If not, write to the | ||
17 | Free Software Foundation, Inc., 59 Temple Place - Suite 330, | ||
18 | Boston, MA 02111-1307, USA. | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file src/plugins/fs/meta.h | ||
23 | * @brief code for dealing with meta and keyword tree views | ||
24 | * @author Christian Grothoff | ||
25 | */ | ||
26 | |||
27 | #ifndef GTK_META_H | ||
28 | #define GTK_META_H | ||
29 | |||
30 | #include "gnunetgtk_common.h" | ||
31 | #include <GNUnet/gnunet_ecrs_lib.h> | ||
32 | |||
33 | void createMetaDataListTreeView(GladeXML * xml, | ||
34 | const char * name, | ||
35 | const char * previewName, | ||
36 | const struct ECRS_MetaData * init); | ||
37 | |||
38 | void createKeywordListTreeView(GladeXML * xml, | ||
39 | const char * name, | ||
40 | const struct ECRS_URI * init); | ||
41 | |||
42 | void createMetaTypeComboBox(GladeXML * xml, | ||
43 | const char * name); | ||
44 | |||
45 | void handleKeywordListUpdate(GladeXML * xml, | ||
46 | const char * inputLineName, | ||
47 | const char * keywordListName); | ||
48 | |||
49 | void handleMetaDataListUpdate(GladeXML * xml, | ||
50 | const char * typeInputLineName, | ||
51 | const char * valueInputLineName, | ||
52 | const char * metaDataListName); | ||
53 | |||
54 | struct ECRS_MetaData * getMetaDataFromList(GladeXML * xml, | ||
55 | const char * name, | ||
56 | const char * preview); | ||
57 | |||
58 | struct ECRS_URI * getKeywordURIFromList(GladeXML * xml, | ||
59 | const char * name); | ||
60 | |||
61 | |||
62 | /* end of meta.h */ | ||
63 | #endif | ||
diff --git a/src/plugins/fs/namespace.c b/src/plugins/fs/namespace.c index aeaf0a79..cd8238d4 100644 --- a/src/plugins/fs/namespace.c +++ b/src/plugins/fs/namespace.c | |||
@@ -27,6 +27,7 @@ | |||
27 | #include "platform.h" | 27 | #include "platform.h" |
28 | #include "gnunetgtk_common.h" | 28 | #include "gnunetgtk_common.h" |
29 | #include "fs.h" | 29 | #include "fs.h" |
30 | #include "meta.h" | ||
30 | #include "namespace.h" | 31 | #include "namespace.h" |
31 | #include <extractor.h> | 32 | #include <extractor.h> |
32 | 33 | ||
@@ -372,112 +373,29 @@ static int addTabForNamespace(void * unused, | |||
372 | return OK; | 373 | return OK; |
373 | } | 374 | } |
374 | 375 | ||
375 | /** | 376 | void on_namespacemetaDataDialogKeywordAddButton_clicked(gpointer dummy, |
376 | * FIXME: somehow this function is not called | 377 | GtkWidget * uploadButton) { |
377 | * when the button is clicked. | 378 | handleKeywordListUpdate(metaXML, |
378 | */ | 379 | "namespaceKeywordEntry", |
379 | void | 380 | "namespaceMetaDataDialogKeywordList"); |
380 | on_namespacemetaDataDialogKeywordAddButton_clicked(gpointer dummy, | ||
381 | GtkWidget * uploadButton) { | ||
382 | GtkWidget * keywordList; | ||
383 | GtkWidget * entryLine; | ||
384 | const char * keyword; | ||
385 | GtkListStore * keymodel; | ||
386 | GtkTreeIter iter; | ||
387 | |||
388 | keywordList = glade_xml_get_widget(metaXML, | ||
389 | "namespaceMetaDataDialogKeywordList"); | ||
390 | keymodel | ||
391 | = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(keywordList))); | ||
392 | |||
393 | entryLine = glade_xml_get_widget(metaXML, | ||
394 | "namespaceKeywordEntry"); | ||
395 | keyword = gtk_entry_get_text(GTK_ENTRY(entryLine)); | ||
396 | gtk_list_store_append(keymodel, | ||
397 | &iter); | ||
398 | gtk_list_store_set(keymodel, | ||
399 | &iter, | ||
400 | 0, keyword, | ||
401 | -1); | ||
402 | gtk_entry_set_text(GTK_ENTRY(entryLine), ""); | ||
403 | } | 381 | } |
404 | 382 | ||
405 | /** | 383 | void on_namespacemetaDataDialogMetaDataAddButton_clicked(gpointer dummy, |
406 | * FIXME: somehow this function is not called | 384 | GtkWidget * uploadButton) { |
407 | * when the button is clicked. | 385 | handleMetaDataListUpdate(metaXML, |
408 | */ | 386 | "namespaceMetaDataDialogMetaTypeComboBox", |
409 | void | 387 | "namespaceMetaDataValueEntry", |
410 | on_namespacemetaDataDialogMetaDataAddButton_clicked(gpointer dummy, | 388 | "namespaceMetaDataDialogMetaDataList"); |
411 | GtkWidget * uploadButton) { | ||
412 | GtkWidget * metaList; | ||
413 | GtkWidget * entryLine; | ||
414 | GtkWidget * typeCB; | ||
415 | const char * value; | ||
416 | EXTRACTOR_KeywordType type; | ||
417 | GtkListStore * metamodel; | ||
418 | GtkListStore * typemodel; | ||
419 | GtkTreeIter iter; | ||
420 | char * stype; | ||
421 | |||
422 | metaList = glade_xml_get_widget(metaXML, | ||
423 | "namespaceMetaDataDialogMetaDataList"); | ||
424 | metamodel | ||
425 | = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(metaList))); | ||
426 | |||
427 | entryLine = glade_xml_get_widget(metaXML, | ||
428 | "namespaceMetaDataValueEntry"); | ||
429 | value = gtk_entry_get_text(GTK_ENTRY(entryLine)); | ||
430 | typeCB = glade_xml_get_widget(metaXML, | ||
431 | "namespaceMetaDataDialogMetaTypeComboBox"); | ||
432 | typemodel | ||
433 | = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(typeCB))); | ||
434 | if (! gtk_combo_box_get_active_iter(GTK_COMBO_BOX(typeCB), | ||
435 | &iter)) | ||
436 | return; /* oops */ | ||
437 | gtk_tree_model_get(GTK_TREE_MODEL(typemodel), | ||
438 | &iter, | ||
439 | KTYPE_STRING, &stype, | ||
440 | KTYPE_TYPE, &type, | ||
441 | -1); | ||
442 | gtk_list_store_append(metamodel, | ||
443 | &iter); | ||
444 | gtk_list_store_set(metamodel, | ||
445 | &iter, | ||
446 | META_TYPE, type, | ||
447 | META_STYPE, stype, | ||
448 | META_VALUE, value, | ||
449 | -1); | ||
450 | gtk_entry_set_text(GTK_ENTRY(entryLine), ""); | ||
451 | } | 389 | } |
452 | 390 | ||
453 | |||
454 | |||
455 | /** | ||
456 | * CLEANUP: refactor code to share keyword/metadata list | ||
457 | * and model creation with upload and collection! | ||
458 | */ | ||
459 | void create_namespace_clicked(GtkWidget * dummy1, | 391 | void create_namespace_clicked(GtkWidget * dummy1, |
460 | GtkWidget * dummy2) { | 392 | GtkWidget * dummy2) { |
461 | const char * namespaceName; | 393 | const char * namespaceName; |
462 | GtkWidget * nameLine; | 394 | GtkWidget * nameLine; |
463 | GtkWidget * metaList; | ||
464 | GtkWidget * keywordList; | ||
465 | GtkWidget * dialog; | 395 | GtkWidget * dialog; |
466 | GtkWidget * metaType; | ||
467 | GtkWidget * spin; | 396 | GtkWidget * spin; |
468 | GtkListStore * metamodel; | ||
469 | GtkListStore * keymodel; | ||
470 | GtkCellRenderer * renderer; | ||
471 | GtkListStore * keywordTypeModel; | ||
472 | GtkTreeIter iter; | ||
473 | struct ECRS_MetaData * meta; | 397 | struct ECRS_MetaData * meta; |
474 | EXTRACTOR_KeywordType type; | ||
475 | struct ECRS_URI * keywordURI; | 398 | struct ECRS_URI * keywordURI; |
476 | const char * stype; | ||
477 | char * mvalue; | ||
478 | char ** keywords; | ||
479 | unsigned int kpos; | ||
480 | unsigned int ksize; | ||
481 | struct ECRS_URI * root; | 399 | struct ECRS_URI * root; |
482 | HashCode512 namespaceId; | 400 | HashCode512 namespaceId; |
483 | HashCode512 rootEntry; | 401 | HashCode512 rootEntry; |
@@ -489,118 +407,25 @@ void create_namespace_clicked(GtkWidget * dummy1, | |||
489 | connectGladeWithPlugins(metaXML); | 407 | connectGladeWithPlugins(metaXML); |
490 | dialog = glade_xml_get_widget(metaXML, | 408 | dialog = glade_xml_get_widget(metaXML, |
491 | "namespaceMetaDataDialog"); | 409 | "namespaceMetaDataDialog"); |
492 | metamodel | 410 | createMetaDataListTreeView(metaXML, |
493 | = gtk_list_store_new(META_NUM, | 411 | "namespaceMetaDataDialogMetaDataList", |
494 | G_TYPE_INT, | 412 | NULL, |
495 | G_TYPE_STRING, | 413 | NULL); |
496 | G_TYPE_STRING); | 414 | createKeywordListTreeView(metaXML, |
497 | metaList = glade_xml_get_widget(metaXML, | 415 | "namespaceMetaDataDialogKeywordList", |
498 | "namespaceMetaDataDialogMetaDataList"); | 416 | NULL); |
499 | renderer = gtk_cell_renderer_text_new(); | 417 | createMetaTypeComboBox(metaXML, |
500 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(metaList), | 418 | "namespaceMetaDataDialogMetaTypeComboBox"); |
501 | -1, | ||
502 | _("Category"), | ||
503 | renderer, | ||
504 | "text", META_STYPE, | ||
505 | NULL); | ||
506 | renderer = gtk_cell_renderer_text_new(); | ||
507 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(metaList), | ||
508 | -1, | ||
509 | _("Value"), | ||
510 | renderer, | ||
511 | "text", META_VALUE, | ||
512 | NULL); | ||
513 | gtk_tree_view_set_model(GTK_TREE_VIEW(metaList), | ||
514 | GTK_TREE_MODEL(metamodel)); | ||
515 | keymodel | ||
516 | = gtk_list_store_new(1, | ||
517 | G_TYPE_STRING); | ||
518 | keywordList = glade_xml_get_widget(metaXML, | ||
519 | "namespaceMetaDataDialogKeywordList"); | ||
520 | renderer = gtk_cell_renderer_text_new(); | ||
521 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(keywordList), | ||
522 | -1, | ||
523 | _("Keyword"), | ||
524 | renderer, | ||
525 | "text", 0, | ||
526 | NULL); | ||
527 | gtk_tree_view_set_model(GTK_TREE_VIEW(keywordList), | ||
528 | GTK_TREE_MODEL(keymodel)); | ||
529 | keywordTypeModel | ||
530 | = gtk_list_store_new(KTYPE_NUM, | ||
531 | G_TYPE_STRING, | ||
532 | G_TYPE_INT); | ||
533 | metaType | ||
534 | = glade_xml_get_widget(metaXML, | ||
535 | "namespaceMetaDataDialogMetaTypeComboBox"); | ||
536 | gtk_combo_box_set_model(GTK_COMBO_BOX(metaType), | ||
537 | GTK_TREE_MODEL(keywordTypeModel)); | ||
538 | for (type=0;type<EXTRACTOR_getHighestKeywordTypeNumber();type++) { | ||
539 | stype = EXTRACTOR_getKeywordTypeAsString(type); | ||
540 | gtk_list_store_append(keywordTypeModel, | ||
541 | &iter); | ||
542 | gtk_list_store_set(keywordTypeModel, | ||
543 | &iter, | ||
544 | KTYPE_STRING, stype, | ||
545 | KTYPE_TYPE, type, | ||
546 | -1); | ||
547 | } | ||
548 | renderer = gtk_cell_renderer_text_new(); | ||
549 | gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(metaType), | ||
550 | renderer, | ||
551 | FALSE); | ||
552 | gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(metaType), | ||
553 | renderer, | ||
554 | "text", KTYPE_STRING); | ||
555 | gtk_combo_box_set_active(GTK_COMBO_BOX(metaType), | ||
556 | 0); | ||
557 | gtk_dialog_set_default_response(GTK_DIALOG(dialog), | 419 | gtk_dialog_set_default_response(GTK_DIALOG(dialog), |
558 | GTK_RESPONSE_OK); | 420 | GTK_RESPONSE_OK); |
559 | if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { | 421 | if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { |
560 | meta = ECRS_createMetaData(); | 422 | meta |
561 | if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(metamodel), | 423 | = getMetaDataFromList(metaXML, |
562 | &iter)) { | 424 | "namespaceMetaDataDialogMetaDataList", |
563 | do { | 425 | NULL); |
564 | gtk_tree_model_get(GTK_TREE_MODEL(metamodel), | 426 | keywordURI |
565 | &iter, | 427 | = getKeywordURIFromList(metaXML, |
566 | META_TYPE, &type, | 428 | "namespaceMetaDataDialogKeywordList"); |
567 | META_VALUE, &mvalue, | ||
568 | -1); | ||
569 | ECRS_addToMetaData(meta, | ||
570 | type, | ||
571 | mvalue); | ||
572 | } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(metamodel), | ||
573 | &iter)); | ||
574 | } | ||
575 | keywords = NULL; | ||
576 | ksize = 0; | ||
577 | GROW(keywords, | ||
578 | ksize, | ||
579 | 64); | ||
580 | kpos = 0; | ||
581 | if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keymodel), | ||
582 | &iter)) { | ||
583 | do { | ||
584 | gtk_tree_model_get(GTK_TREE_MODEL(keymodel), | ||
585 | &iter, | ||
586 | 0, &mvalue, | ||
587 | -1); | ||
588 | keywords[kpos++] = mvalue; | ||
589 | if (kpos == ksize) | ||
590 | GROW(keywords, | ||
591 | ksize, | ||
592 | kpos*2); | ||
593 | } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(keymodel), | ||
594 | &iter)); | ||
595 | } | ||
596 | keywords[kpos] = NULL; | ||
597 | |||
598 | keywordURI = ECRS_keywordsToUri((const char**)keywords); | ||
599 | while (kpos > 0) | ||
600 | FREE(keywords[--kpos]); | ||
601 | GROW(keywords, | ||
602 | ksize, | ||
603 | 0); | ||
604 | spin = glade_xml_get_widget(metaXML, | 429 | spin = glade_xml_get_widget(metaXML, |
605 | "namespaceAnonymityspinbutton"); | 430 | "namespaceAnonymityspinbutton"); |
606 | nameLine = glade_xml_get_widget(metaXML, | 431 | nameLine = glade_xml_get_widget(metaXML, |
diff --git a/src/plugins/fs/upload.c b/src/plugins/fs/upload.c index 9ff8ca1e..971e6749 100644 --- a/src/plugins/fs/upload.c +++ b/src/plugins/fs/upload.c | |||
@@ -29,6 +29,7 @@ | |||
29 | #include "search.h" | 29 | #include "search.h" |
30 | #include "upload.h" | 30 | #include "upload.h" |
31 | #include "fs.h" | 31 | #include "fs.h" |
32 | #include "meta.h" | ||
32 | #include <extractor.h> | 33 | #include <extractor.h> |
33 | 34 | ||
34 | #ifdef MINGW | 35 | #ifdef MINGW |
@@ -243,38 +244,6 @@ void displayUploadComplete(const char * mainName, | |||
243 | } | 244 | } |
244 | 245 | ||
245 | 246 | ||
246 | static int publishMetaData(EXTRACTOR_KeywordType type, | ||
247 | const char * data, | ||
248 | GtkListStore * store) { | ||
249 | const char * stype; | ||
250 | GtkTreeIter iter; | ||
251 | |||
252 | stype = EXTRACTOR_getKeywordTypeAsString(type); | ||
253 | GNUNET_ASSERT(stype != NULL); | ||
254 | gtk_list_store_append(store, | ||
255 | &iter); | ||
256 | gtk_list_store_set(store, | ||
257 | &iter, | ||
258 | META_TYPE, type, | ||
259 | META_STYPE, stype, | ||
260 | META_VALUE, data, | ||
261 | -1); | ||
262 | return OK; | ||
263 | } | ||
264 | |||
265 | static int publishKeyword(const char * data, | ||
266 | GtkListStore * store) { | ||
267 | GtkTreeIter iter; | ||
268 | |||
269 | gtk_list_store_append(store, | ||
270 | &iter); | ||
271 | gtk_list_store_set(store, | ||
272 | &iter, | ||
273 | 0, data, | ||
274 | -1); | ||
275 | return OK; | ||
276 | } | ||
277 | |||
278 | void on_selectAlternativePreviewButton_selection_changed(GtkWidget * preview, | 247 | void on_selectAlternativePreviewButton_selection_changed(GtkWidget * preview, |
279 | GtkWidget * fileChooser) { | 248 | GtkWidget * fileChooser) { |
280 | char * fn; | 249 | char * fn; |
@@ -297,108 +266,34 @@ void on_selectAlternativePreviewButton_selection_changed(GtkWidget * preview, | |||
297 | 266 | ||
298 | void on_metaDataDialogKeywordAddButton_clicked(gpointer dummy, | 267 | void on_metaDataDialogKeywordAddButton_clicked(gpointer dummy, |
299 | GtkWidget * uploadButton) { | 268 | GtkWidget * uploadButton) { |
300 | GtkWidget * keywordList; | 269 | handleKeywordListUpdate(metaXML, |
301 | GtkWidget * entryLine; | 270 | "fileInformationKeywordEntry", |
302 | const char * keyword; | 271 | "metaDataDialogKeywordList"); |
303 | GtkListStore * keymodel; | ||
304 | GtkTreeIter iter; | ||
305 | |||
306 | keywordList = glade_xml_get_widget(metaXML, | ||
307 | "metaDataDialogKeywordList"); | ||
308 | keymodel | ||
309 | = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(keywordList))); | ||
310 | |||
311 | entryLine = glade_xml_get_widget(metaXML, | ||
312 | "fileInformationKeywordEntry"); | ||
313 | keyword = gtk_entry_get_text(GTK_ENTRY(entryLine)); | ||
314 | gtk_list_store_append(keymodel, | ||
315 | &iter); | ||
316 | gtk_list_store_set(keymodel, | ||
317 | &iter, | ||
318 | 0, keyword, | ||
319 | -1); | ||
320 | gtk_entry_set_text(GTK_ENTRY(entryLine), ""); | ||
321 | } | 272 | } |
322 | 273 | ||
323 | void on_metaDataDialogMetaDataAddButton_clicked(gpointer dummy, | 274 | void on_metaDataDialogMetaDataAddButton_clicked(gpointer dummy, |
324 | GtkWidget * uploadButton) { | 275 | GtkWidget * uploadButton) { |
325 | GtkWidget * metaList; | 276 | handleMetaDataListUpdate(metaXML, |
326 | GtkWidget * entryLine; | 277 | "metaDataDialogMetaTypeComboBox", |
327 | GtkWidget * typeCB; | 278 | "metaDataDialogValueEntry", |
328 | const char * value; | 279 | "metaDataDialogMetaDataList"); |
329 | EXTRACTOR_KeywordType type; | ||
330 | GtkListStore * metamodel; | ||
331 | GtkListStore * typemodel; | ||
332 | GtkTreeIter iter; | ||
333 | char * stype; | ||
334 | |||
335 | metaList = glade_xml_get_widget(metaXML, | ||
336 | "metaDataDialogMetaDataList"); | ||
337 | metamodel | ||
338 | = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(metaList))); | ||
339 | |||
340 | entryLine = glade_xml_get_widget(metaXML, | ||
341 | "metaDataDialogValueEntry"); | ||
342 | value = gtk_entry_get_text(GTK_ENTRY(entryLine)); | ||
343 | if ( (value == NULL) || (strlen(value) == 0) ) | ||
344 | return; | ||
345 | typeCB = glade_xml_get_widget(metaXML, | ||
346 | "metaDataDialogMetaTypeComboBox"); | ||
347 | typemodel | ||
348 | = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(typeCB))); | ||
349 | if (! gtk_combo_box_get_active_iter(GTK_COMBO_BOX(typeCB), | ||
350 | &iter)) | ||
351 | return; /* oops */ | ||
352 | gtk_tree_model_get(GTK_TREE_MODEL(typemodel), | ||
353 | &iter, | ||
354 | KTYPE_STRING, &stype, | ||
355 | KTYPE_TYPE, &type, | ||
356 | -1); | ||
357 | gtk_list_store_append(metamodel, | ||
358 | &iter); | ||
359 | gtk_list_store_set(metamodel, | ||
360 | &iter, | ||
361 | META_TYPE, type, | ||
362 | META_STYPE, stype, | ||
363 | META_VALUE, value, | ||
364 | -1); | ||
365 | gtk_entry_set_text(GTK_ENTRY(entryLine), ""); | ||
366 | } | 280 | } |
367 | 281 | ||
368 | void on_fsinsertuploadbutton_clicked(gpointer dummy, | 282 | void on_fsinsertuploadbutton_clicked(gpointer dummy, |
369 | GtkWidget * uploadButton) { | 283 | GtkWidget * uploadButton) { |
370 | const char * filename; | 284 | const char * filename; |
285 | const char * filenamerest; | ||
371 | GtkWidget * uploadLine; | 286 | GtkWidget * uploadLine; |
372 | GtkWidget * metaList; | ||
373 | GtkWidget * keywordList; | ||
374 | GtkWidget * entry; | 287 | GtkWidget * entry; |
375 | GtkWidget * dialog; | 288 | GtkWidget * dialog; |
376 | GtkWidget * preview; | ||
377 | GtkWidget * metaType; | ||
378 | GtkWidget * recBut; | 289 | GtkWidget * recBut; |
379 | GtkWidget * idxBut; | 290 | GtkWidget * idxBut; |
380 | GtkWidget * spin; | 291 | GtkWidget * spin; |
381 | GtkListStore * metamodel; | ||
382 | GtkListStore * keymodel; | ||
383 | GtkCellRenderer * renderer; | ||
384 | GtkListStore * keywordTypeModel; | ||
385 | GtkTreeIter iter; | ||
386 | struct ECRS_MetaData * meta; | 292 | struct ECRS_MetaData * meta; |
387 | EXTRACTOR_ExtractorList * extractors; | 293 | EXTRACTOR_ExtractorList * extractors; |
388 | EXTRACTOR_KeywordType type; | ||
389 | char * config; | 294 | char * config; |
390 | struct ECRS_URI * keywordURI; | 295 | struct ECRS_URI * keywordURI; |
391 | struct ECRS_URI * gkeywordURI; | 296 | struct ECRS_URI * gkeywordURI; |
392 | const char * stype; | ||
393 | GdkPixbuf * pixbuf; | ||
394 | GdkPixbufLoader * loader; | ||
395 | unsigned char * thumb; | ||
396 | size_t ts; | ||
397 | char * mvalue; | ||
398 | char ** keywords; | ||
399 | unsigned int kpos; | ||
400 | unsigned int ksize; | ||
401 | const char * filenamerest; | ||
402 | 297 | ||
403 | extractors = EXTRACTOR_loadDefaultLibraries(); | 298 | extractors = EXTRACTOR_loadDefaultLibraries(); |
404 | config = getConfigurationString("FS", | 299 | config = getConfigurationString("FS", |
@@ -421,45 +316,6 @@ void on_fsinsertuploadbutton_clicked(gpointer dummy, | |||
421 | connectGladeWithPlugins(metaXML); | 316 | connectGladeWithPlugins(metaXML); |
422 | dialog = glade_xml_get_widget(metaXML, | 317 | dialog = glade_xml_get_widget(metaXML, |
423 | "metaDataDialog"); | 318 | "metaDataDialog"); |
424 | metamodel | ||
425 | = gtk_list_store_new(META_NUM, | ||
426 | G_TYPE_INT, | ||
427 | G_TYPE_STRING, | ||
428 | G_TYPE_STRING); | ||
429 | metaList = glade_xml_get_widget(metaXML, | ||
430 | "metaDataDialogMetaDataList"); | ||
431 | renderer = gtk_cell_renderer_text_new(); | ||
432 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(metaList), | ||
433 | -1, | ||
434 | _("Category"), | ||
435 | renderer, | ||
436 | "text", META_STYPE, | ||
437 | NULL); | ||
438 | renderer = gtk_cell_renderer_text_new(); | ||
439 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(metaList), | ||
440 | -1, | ||
441 | _("Value"), | ||
442 | renderer, | ||
443 | "text", META_VALUE, | ||
444 | NULL); | ||
445 | gtk_tree_view_set_model(GTK_TREE_VIEW(metaList), | ||
446 | GTK_TREE_MODEL(metamodel)); | ||
447 | |||
448 | |||
449 | keymodel | ||
450 | = gtk_list_store_new(1, | ||
451 | G_TYPE_STRING); | ||
452 | keywordList = glade_xml_get_widget(metaXML, | ||
453 | "metaDataDialogKeywordList"); | ||
454 | renderer = gtk_cell_renderer_text_new(); | ||
455 | gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(keywordList), | ||
456 | -1, | ||
457 | _("Keyword"), | ||
458 | renderer, | ||
459 | "text", 0, | ||
460 | NULL); | ||
461 | gtk_tree_view_set_model(GTK_TREE_VIEW(keywordList), | ||
462 | GTK_TREE_MODEL(keymodel)); | ||
463 | meta = ECRS_createMetaData(); | 319 | meta = ECRS_createMetaData(); |
464 | ECRS_extractMetaData(meta, | 320 | ECRS_extractMetaData(meta, |
465 | filename, | 321 | filename, |
@@ -471,62 +327,20 @@ void on_fsinsertuploadbutton_clicked(gpointer dummy, | |||
471 | ECRS_addToMetaData(meta, | 327 | ECRS_addToMetaData(meta, |
472 | EXTRACTOR_FILENAME, | 328 | EXTRACTOR_FILENAME, |
473 | filenamerest); | 329 | filenamerest); |
474 | ECRS_getMetaData(meta, | 330 | createMetaDataListTreeView(metaXML, |
475 | (ECRS_MetaDataIterator) &publishMetaData, | 331 | "metaDataDialogMetaDataList", |
476 | metamodel); | 332 | "previewImage", |
333 | meta); | ||
334 | ECRS_freeMetaData(meta); | ||
477 | keywordURI = ECRS_metaDataToUri(meta); | 335 | keywordURI = ECRS_metaDataToUri(meta); |
478 | ECRS_getKeywordsFromUri(keywordURI, | 336 | createKeywordListTreeView(metaXML, |
479 | (ECRS_KeywordIterator) &publishKeyword, | 337 | "metaDataDialogKeywordList", |
480 | keymodel); | 338 | keywordURI); |
481 | keywordTypeModel | 339 | ECRS_freeUri(keywordURI); |
482 | = gtk_list_store_new(KTYPE_NUM, | 340 | createMetaTypeComboBox(metaXML, |
483 | G_TYPE_STRING, | 341 | "metaDataDialogMetaTypeComboBox"); |
484 | G_TYPE_INT); | ||
485 | metaType = glade_xml_get_widget(metaXML, | ||
486 | "metaDataDialogMetaTypeComboBox"); | ||
487 | gtk_combo_box_set_model(GTK_COMBO_BOX(metaType), | ||
488 | GTK_TREE_MODEL(keywordTypeModel)); | ||
489 | for (type=0;type<EXTRACTOR_getHighestKeywordTypeNumber();type++) { | ||
490 | stype = EXTRACTOR_getKeywordTypeAsString(type); | ||
491 | gtk_list_store_append(keywordTypeModel, | ||
492 | &iter); | ||
493 | gtk_list_store_set(keywordTypeModel, | ||
494 | &iter, | ||
495 | KTYPE_STRING, stype, | ||
496 | KTYPE_TYPE, type, | ||
497 | -1); | ||
498 | } | ||
499 | renderer = gtk_cell_renderer_text_new(); | ||
500 | gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(metaType), | ||
501 | renderer, | ||
502 | FALSE); | ||
503 | gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(metaType), | ||
504 | renderer, | ||
505 | "text", KTYPE_STRING); | ||
506 | gtk_combo_box_set_active(GTK_COMBO_BOX(metaType), | ||
507 | 0); | ||
508 | gtk_dialog_set_default_response(GTK_DIALOG(dialog), | 342 | gtk_dialog_set_default_response(GTK_DIALOG(dialog), |
509 | GTK_RESPONSE_OK); | 343 | GTK_RESPONSE_OK); |
510 | thumb = NULL; | ||
511 | ts = ECRS_getThumbnailFromMetaData(meta, | ||
512 | &thumb); | ||
513 | ECRS_freeMetaData(meta); | ||
514 | ECRS_freeUri(keywordURI); | ||
515 | preview = glade_xml_get_widget(metaXML, | ||
516 | "previewImage"); | ||
517 | if (ts != 0) { | ||
518 | loader = gdk_pixbuf_loader_new(); | ||
519 | gdk_pixbuf_loader_write(loader, | ||
520 | (const guchar*) thumb, | ||
521 | ts, | ||
522 | NULL); | ||
523 | pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); | ||
524 | gdk_pixbuf_loader_close(loader, | ||
525 | NULL); | ||
526 | gtk_image_set_from_pixbuf(GTK_IMAGE(preview), | ||
527 | pixbuf); | ||
528 | g_object_unref(pixbuf); | ||
529 | } | ||
530 | if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL) { | 344 | if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL) { |
531 | int doIndex; | 345 | int doIndex; |
532 | int doRec; | 346 | int doRec; |
@@ -544,107 +358,11 @@ void on_fsinsertuploadbutton_clicked(gpointer dummy, | |||
544 | else | 358 | else |
545 | doIndex = NO; | 359 | doIndex = NO; |
546 | 360 | ||
547 | meta = ECRS_createMetaData(); | 361 | meta = getMetaDataFromList(metaXML, |
548 | if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(metamodel), | 362 | "metaDataDialogMetaDataList", |
549 | &iter)) { | 363 | "previewImage"); |
550 | do { | 364 | keywordURI = getKeywordURIFromList(metaXML, |
551 | gtk_tree_model_get(GTK_TREE_MODEL(metamodel), | 365 | "metaDataDialogKeywordList"); |
552 | &iter, | ||
553 | META_TYPE, &type, | ||
554 | META_VALUE, &mvalue, | ||
555 | -1); | ||
556 | ECRS_addToMetaData(meta, | ||
557 | type, | ||
558 | mvalue); | ||
559 | } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(metamodel), | ||
560 | &iter)); | ||
561 | } | ||
562 | if (GTK_IMAGE_PIXBUF == | ||
563 | gtk_image_get_storage_type(GTK_IMAGE(preview))) { | ||
564 | size_t length; | ||
565 | char * thumb; | ||
566 | |||
567 | pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(preview)); | ||
568 | if (pixbuf != NULL) { | ||
569 | thumb = NULL; | ||
570 | if (gdk_pixbuf_save_to_buffer(pixbuf, | ||
571 | &thumb, | ||
572 | &length, | ||
573 | "png", | ||
574 | NULL, | ||
575 | NULL)) { | ||
576 | char * binary; | ||
577 | size_t pos; | ||
578 | size_t end; | ||
579 | size_t wpos; | ||
580 | size_t i; | ||
581 | unsigned int markers[8]; /* 256 bits */ | ||
582 | unsigned char marker; | ||
583 | |||
584 | /* encode! */ | ||
585 | binary = MALLOC(2 + length + (length+256) / 254); | ||
586 | pos = 0; | ||
587 | wpos = 0; | ||
588 | while (pos < length) { | ||
589 | /* find unused value between 1 and 255 in | ||
590 | the next 254 bytes */ | ||
591 | end = pos + 254; | ||
592 | if (end < pos) | ||
593 | break; /* integer overflow! */ | ||
594 | if (end > length) | ||
595 | end = length; | ||
596 | memset(markers, 0, sizeof(markers)); | ||
597 | for (i=pos;i<end;i++) | ||
598 | markers[thumb[i]&7] |= 1 << (thumb[i] >> 3); | ||
599 | marker = 1; | ||
600 | while (markers[marker&7] & (1 << (marker >> 3))) { | ||
601 | marker++; | ||
602 | GNUNET_ASSERT(marker != 0); | ||
603 | } | ||
604 | /* recode */ | ||
605 | binary[wpos++] = marker; | ||
606 | for (i=pos;i<end;i++) | ||
607 | binary[wpos++] = thumb[i] == 0 ? marker : thumb[i]; | ||
608 | pos = end; | ||
609 | } | ||
610 | binary[wpos++] = 0; /* 0-termination! */ | ||
611 | free(thumb); | ||
612 | ECRS_addToMetaData(meta, | ||
613 | EXTRACTOR_THUMBNAIL_DATA, | ||
614 | binary); | ||
615 | FREE(binary); | ||
616 | } | ||
617 | } | ||
618 | } | ||
619 | keywords = NULL; | ||
620 | ksize = 0; | ||
621 | GROW(keywords, | ||
622 | ksize, | ||
623 | 64); | ||
624 | kpos = 0; | ||
625 | if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keymodel), | ||
626 | &iter)) { | ||
627 | do { | ||
628 | gtk_tree_model_get(GTK_TREE_MODEL(keymodel), | ||
629 | &iter, | ||
630 | 0, &mvalue, | ||
631 | -1); | ||
632 | keywords[kpos++] = mvalue; | ||
633 | if (kpos == ksize) | ||
634 | GROW(keywords, | ||
635 | ksize, | ||
636 | kpos*2); | ||
637 | } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(keymodel), | ||
638 | &iter)); | ||
639 | } | ||
640 | keywords[kpos] = NULL; | ||
641 | |||
642 | keywordURI = ECRS_keywordsToUri((const char**)keywords); | ||
643 | while (kpos > 0) | ||
644 | FREE(keywords[--kpos]); | ||
645 | GROW(keywords, | ||
646 | ksize, | ||
647 | 0); | ||
648 | spin = glade_xml_get_widget(getMainXML(), | 366 | spin = glade_xml_get_widget(getMainXML(), |
649 | "uploadAnonymityLevelSpinButton"); | 367 | "uploadAnonymityLevelSpinButton"); |
650 | if (doRec) { | 368 | if (doRec) { |