aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2006-10-25 20:41:15 +0000
committerChristian Grothoff <christian@grothoff.org>2006-10-25 20:41:15 +0000
commit3ea2348ed08cfe631d528c6c3c706a667033363a (patch)
tree16977dece55b05635b38f1705fd7f34fbae25741
parent1f257dcf5bb802f8d35d580bc437d85bec1a0618 (diff)
downloadgnunet-gtk-3ea2348ed08cfe631d528c6c3c706a667033363a.tar.gz
gnunet-gtk-3ea2348ed08cfe631d528c6c3c706a667033363a.zip
syn
Diffstat
-rw-r--r--src/plugins/fs/fs.c3
-rw-r--r--src/plugins/fs/helper.c129
-rw-r--r--src/plugins/fs/helper.h9
-rw-r--r--src/plugins/fs/search.c1840
-rw-r--r--src/plugins/fs/search.h46
-rw-r--r--src/plugins/fs/search_namespace.c106
6 files changed, 1350 insertions, 783 deletions
diff --git a/src/plugins/fs/fs.c b/src/plugins/fs/fs.c
index 44008226..cbe76150 100644
--- a/src/plugins/fs/fs.c
+++ b/src/plugins/fs/fs.c
@@ -27,7 +27,6 @@
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 "download.h"
31#include "search.h" 30#include "search.h"
32#include "upload.h" 31#include "upload.h"
33#include "collection.h" 32#include "collection.h"
@@ -166,14 +165,12 @@ void init_fs(struct GE_Context * e,
166 NULL); 165 NULL);
167 fs_collection_start(ectx, cfg); 166 fs_collection_start(ectx, cfg);
168 fs_search_start(ectx, cfg); 167 fs_search_start(ectx, cfg);
169 fs_download_start(ectx, cfg);
170 fs_upload_start(ectx, cfg); 168 fs_upload_start(ectx, cfg);
171 fs_namespace_start(ectx, cfg); 169 fs_namespace_start(ectx, cfg);
172} 170}
173 171
174void done_fs() { 172void done_fs() {
175 DEBUG_BEGIN(); 173 DEBUG_BEGIN();
176 fs_download_stop();
177 fs_search_stop(); 174 fs_search_stop();
178 fs_collection_stop(); 175 fs_collection_stop();
179 fs_namespace_stop(); 176 fs_namespace_stop();
diff --git a/src/plugins/fs/helper.c b/src/plugins/fs/helper.c
index 9f6eaed9..6c2a70c0 100644
--- a/src/plugins/fs/helper.c
+++ b/src/plugins/fs/helper.c
@@ -205,3 +205,132 @@ buildSearchTabLabel(GtkWidget *searchPage,
205 205
206 return hbox; 206 return hbox;
207} 207}
208
209
210
211GtkWidget * makeSearchResultFrame(struct GC_Configuration * cfg,
212 GtkWidget ** treeview,
213 GtkWidget ** anonSpin) {
214 GtkWidget * window;
215 GtkWidget * child;
216 GtkWidget * resultList;
217 GtkTreeViewColumn * column;
218 GtkCellRenderer * renderer;
219 GtkTreeStore * tree;
220 GladeXML * searchXML;
221 int col;
222
223 DEBUG_BEGIN();
224 searchXML
225 = glade_xml_new(getGladeFileName(),
226 "searchResultsFrame",
227 PACKAGE_NAME);
228 connectGladeWithPlugins(searchXML);
229 window = glade_xml_get_widget(searchXML,
230 "searchResultsFrame");
231 resultList = glade_xml_get_widget(searchXML,
232 "searchResults");
233 *anonSpin = glade_xml_get_widget(searchXML,
234 "downloadAnonymitySpinButton");
235 if (treeview != NULL)
236 (*treeview) = GTK_WIDGET(GTK_TREE_VIEW(resultList));
237 tree =
238 gtk_tree_store_new(SEARCH_NUM,
239 G_TYPE_STRING, /* name */
240 G_TYPE_UINT64, /* size */
241 G_TYPE_STRING, /* human-readable size */
242 G_TYPE_STRING, /* mime-type */
243 G_TYPE_STRING, /* meta-data (some) */
244 GDK_TYPE_PIXBUF, /* preview */
245 G_TYPE_POINTER, /* url */
246 G_TYPE_POINTER, /* meta */
247 G_TYPE_POINTER); /* internal: download info/NULL */
248 gtk_tree_view_set_model(GTK_TREE_VIEW(resultList),
249 GTK_TREE_MODEL(tree));
250 renderer = gtk_cell_renderer_text_new();
251 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList),
252 -1,
253 _("Name"),
254 renderer,
255 "text", SEARCH_NAME,
256 NULL);
257 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList),
258 col - 1);
259 gtk_tree_view_column_set_resizable(column, TRUE);
260 gtk_tree_view_column_set_clickable(column, TRUE);
261 gtk_tree_view_column_set_reorderable(column, TRUE);
262 gtk_tree_view_column_set_sort_column_id(column, SEARCH_NAME);
263 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/
264 renderer = gtk_cell_renderer_text_new();
265 g_object_set (renderer, "xalign", 1.00, NULL);
266 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList),
267 -1,
268 _("Size"),
269 renderer,
270 "text", SEARCH_HSIZE,
271 NULL);
272 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList),
273 col - 1);
274 gtk_tree_view_column_set_resizable(column, TRUE);
275 gtk_tree_view_column_set_clickable(column, TRUE);
276 gtk_tree_view_column_set_reorderable(column, TRUE);
277 gtk_tree_view_column_set_sort_column_id(column, SEARCH_SIZE);
278 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/
279
280 renderer = gtk_cell_renderer_text_new();
281 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList),
282 -1,
283 _("Mime-type"),
284 renderer,
285 "text", SEARCH_MIME,
286 NULL);
287 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList),
288 col - 1);
289 gtk_tree_view_column_set_resizable(column, TRUE);
290 gtk_tree_view_column_set_clickable(column, TRUE);
291 gtk_tree_view_column_set_reorderable(column, TRUE);
292 gtk_tree_view_column_set_sort_column_id(column, SEARCH_MIME);
293 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/
294
295 renderer = gtk_cell_renderer_text_new();
296 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList),
297 -1,
298 _("Meta-data"),
299 renderer,
300 "text", SEARCH_DESC,
301 NULL);
302 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList),
303 col - 1);
304 gtk_tree_view_column_set_resizable(column, TRUE);
305 gtk_tree_view_column_set_clickable(column, TRUE);
306 gtk_tree_view_column_set_reorderable(column, TRUE);
307 gtk_tree_view_column_set_sort_column_id(column, SEARCH_DESC);
308 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/
309 if (YES != GC_get_configuration_value_yesno(cfg,
310 "GNUNET-GTK",
311 "DISABLE-PREVIEWS",
312 NO)) {
313 renderer = gtk_cell_renderer_pixbuf_new();
314 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList),
315 -1,
316 _("Preview"),
317 renderer,
318 "pixbuf", SEARCH_PIXBUF,
319 NULL);
320 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList),
321 col - 1);
322 gtk_tree_view_column_set_resizable(column, TRUE);
323 gtk_tree_view_column_set_reorderable(column, TRUE);
324 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList),
325 col - 1),
326 TRUE);
327 }
328 child = gtk_bin_get_child(GTK_BIN(window));
329 gtk_widget_ref(GTK_WIDGET(child));
330 gtk_container_remove(GTK_CONTAINER(window),
331 child);
332 gtk_widget_destroy(window);
333 UNREF(searchXML);
334 DEBUG_END();
335 return child;
336}
diff --git a/src/plugins/fs/helper.h b/src/plugins/fs/helper.h
index 73e40485..d70fc6e2 100644
--- a/src/plugins/fs/helper.h
+++ b/src/plugins/fs/helper.h
@@ -36,10 +36,15 @@
36 * @returns the created widget to pack into the page header 36 * @returns the created widget to pack into the page header
37 */ 37 */
38GtkWidget * 38GtkWidget *
39buildSearchTabLabel (GtkWidget *searchPage, 39buildSearchTabLabel(GtkWidget *searchPage,
40 const char *title); 40 const char *title);
41 41
42 42
43GtkWidget *
44makeSearchResultFrame(struct GC_Configuration * cfg,
45 GtkWidget ** treeview,
46 GtkWidget ** anonSpin);
47
43/** 48/**
44 * Parse a time given in the form 49 * Parse a time given in the form
45 * "XX seconds yy days zz months". 50 * "XX seconds yy days zz months".
diff --git a/src/plugins/fs/search.c b/src/plugins/fs/search.c
index 2b235c05..6436eb34 100644
--- a/src/plugins/fs/search.c
+++ b/src/plugins/fs/search.c
@@ -41,32 +41,217 @@ typedef struct SL {
41 struct SL * next; 41 struct SL * next;
42 GtkWidget * treeview; 42 GtkWidget * treeview;
43 GtkWidget * searchpage; 43 GtkWidget * searchpage;
44 GtkTreeModel * model; 44 GtkWidget * anonymityButton; /* FIXME: initialize! */
45 GtkWidget * anonymityButton;
46 struct ECRS_URI * uri; 45 struct ECRS_URI * uri;
47 struct FSUI_SearchList * fsui_list; /* FIXME: initialize! */ 46 struct FSUI_SearchList * fsui_list; /* FIXME: initialize! */
48} SearchList; 47} SearchList;
49 48
50static SearchList * head; 49static SearchList * search_head;
51 50
52static GtkListStore * summary; 51static GtkListStore * search_summary;
53 52
54static struct GE_Context * ectx; 53static struct GE_Context * ectx;
55 54
56static struct GC_Configuration * cfg; 55static struct GC_Configuration * cfg;
57 56
57typedef struct DL {
58 struct DL * next;
59 struct ECRS_URI * uri;
60 char * filename;
61 GtkTreeRowReference * rr;
62 GtkTreeModel * model;
63 struct FSUI_DownloadList * fsui_list;
64} DownloadList;
65
66static DownloadList * download_head;
67
68static GtkTreeStore * download_summary;
69
70
71void on_fssearchbutton_clicked_fs(gpointer dummy2,
72 GtkWidget * searchButton) {
73 struct ECRS_URI * uri;
74 const char * ss;
75 const char * ns;
76 gint pages;
77 char * tabtxt;
78 const char * descStr;
79 char * ustring;
80 gint i;
81 gint pages;
82 SearchList * list;
83
84 DEBUG_BEGIN();
85 searchKeywordGtkCB
86 = glade_xml_get_widget(getMainXML(),
87 "fssearchKeywordComboBoxEntry");
88 entry = gtk_bin_get_child(GTK_BIN(searchKeywordGtkCB));
89 ss = gtk_entry_get_text(GTK_ENTRY(entry));
90 if (ss == NULL) {
91 GE_LOG(ectx,
92 GE_ERROR | GE_USER | GE_IMMEDIATE,
93 _("Need a keyword to search!\n"));
94 return;
95 }
96 i = gtk_combo_box_get_active(GTK_COMBO_BOX(searchKeywordGtkCB));
97 if (i == -1) {
98 model = GTK_LIST_STORE
99 (gtk_combo_box_get_model
100 (GTK_COMBO_BOX(searchKeywordGtkCB)));
101 gtk_list_store_prepend(model,
102 &iter);
103 gtk_list_store_set(model,
104 &iter,
105 0, ss,
106 -1);
107 }
108 searchNamespaceGtkCB
109 = glade_xml_get_widget(getMainXML(),
110 "searchNamespaceComboBoxEntry");
111 tmodel = gtk_combo_box_get_model(GTK_COMBO_BOX(searchNamespaceGtkCB));
112 if (TRUE == gtk_combo_box_get_active_iter(GTK_COMBO_BOX(searchNamespaceGtkCB),
113 &iter)) {
114 ns = NULL;
115 descStr = NULL;
116 gtk_tree_model_get(tmodel,
117 &iter,
118 NS_SEARCH_DESCRIPTION, &descStr,
119 NS_SEARCH_ENCNAME, &ns,
120 -1);
121
122 if ( (descStr != NULL) &&
123 (0 == strcmp(descStr,
124 _("globally"))) ) {
125 ns = NULL;
126 } else {
127 GE_ASSERT(ectx, strlen(ns) == sizeof(EncName) - 1);
128 if (descStr == NULL)
129 descStr = ns;
130 }
131 }
132 if (ns != NULL) {
133 ustring = MALLOC(strlen(ss) + sizeof(EncName) +
134 strlen(ECRS_URI_PREFIX) +
135 strlen(ECRS_SUBSPACE_INFIX) + 10);
136 strcpy(ustring, ECRS_URI_PREFIX);
137 strcat(ustring, ECRS_SUBSPACE_INFIX);
138 strcat(ustring, ns);
139 strcat(ustring, "/");
140 strcat(ustring, ss);
141 uri = ECRS_stringToUri(ectx, ustring);
142 if (uri == NULL) {
143 GE_LOG(ectx,
144 GE_ERROR | GE_BULK | GE_USER,
145 _("Failed to create namespace URI from `%s'.\n"),
146 ustring);
147 }
148 FREE(ustring);
149 } else {
150 uri = ECRS_parseCharKeywordURI(ectx, ss);
151 }
152 if (uri == NULL)
153 return;
154 /* check if search is already running */
155 pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook));
156 list = search_head;
157 while (list != NULL) {
158 if (ECRS_equalsUri(list->uri,
159 uri)) {
160 for (i=0;i<pages;i++) {
161 page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
162 i);
163 if (page == list->searchpage) {
164 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook),
165 i);
166 ECRS_freeUri(uri);
167 return;
168 }
169 }
170 GE_BREAK(ectx, 0);
171 }
172 list = list->next;
173 }
174 if (ns == NULL) {
175 tabtxt = STRDUP(ss);
176 } else {
177 GE_ASSERT(ectx, descStr != NULL);
178 tabtxt = MALLOC(strlen(ss) + strlen(descStr) + 2);
179 SNPRINTF(tabtxt,
180 strlen(ss) + strlen(descStr) + 2,
181 "%s/%s",
182 descStr,
183 ss);
184 }
185 FSUI_startSearch(ctx,
186 getAnonymityLevel(getMainXML(),
187 "searchAnonymitySelectionSpinButton");
188 1000, /* FIXME: max results */
189 99 * cronYEARS, /* FIXME: timeout */
190 uri);
191}
192
193void on_searchResults_destroy_fs(GtkWidget * dummy,
194 GtkWidget * treeview) {
195 SearchList * list;
196
197 DEBUG_BEGIN();
198 list = search_head;
199 while (list != NULL) {
200 if (list->treeview == treeview)
201 break;
202 list = list->next;
203 }
204 GE_ASSERT(ectx, list != NULL);
205 FSUI_stopSearch(ctx,
206 list->fsui_list);
207 DEBUG_END();
208}
209
210void on_closeSearchButton_clicked_fs(GtkWidget * searchPage,
211 GtkWidget * closeButton) {
212 SearchList * list;
213
214 DEBUG_BEGIN();
215 list = search_head;
216 while (list != NULL) {
217 if (list->searchpage == searchPage)
218 break;
219 list = list->next;
220 }
221 GE_ASSERT(ectx, list != NULL);
222 FSUI_stopSearch(ctx,
223 list->fsui_list);
224 DEBUG_END();
225}
226
227void on_abortSearchButton_clicked_fs(GtkWidget * searchPage,
228 GtkWidget * closeButton) {
229 SearchList * list;
230
231 DEBUG_BEGIN();
232 list = search_head;
233 while (list != NULL) {
234 if (list->searchpage == searchPage)
235 break;
236 list = list->next;
237 }
238 GE_ASSERT(ectx, list != NULL);
239 FSUI_abortSearch(ctx,
240 list->fsui_list);
241 DEBUG_END();
242}
243
58/** 244/**
59 * Add an entry to the search tree. 245 * Add the given result to the model (search result
60 * 246 * list).
61 * @param model the search model 247 *
62 * @param pos the position to add the entry 248 * @param info the information to add to the model
63 * @param uri the URI to add 249 * @param uri the search URI
64 * @param meta metadata describing the URI 250 * @param searchContext identifies the search page
65 */ 251 */
66void addEntryToSearchTree(GtkTreeStore * model, 252void fs_search_result_received(struct SL * searchContext,
67 GtkTreeIter * pos, 253 const ECRS_FileInfo * info,
68 const struct ECRS_URI * uri, 254 const struct ECRS_URI * uri) {
69 const struct ECRS_MetaData * meta) {
70 char * name; 255 char * name;
71 char * mime; 256 char * mime;
72 char * desc; 257 char * desc;
@@ -76,9 +261,19 @@ void addEntryToSearchTree(GtkTreeStore * model,
76 GdkPixbufLoader * loader; 261 GdkPixbufLoader * loader;
77 unsigned long long size; 262 unsigned long long size;
78 char * size_h; 263 char * size_h;
79 264 GtkTreeStore * model;
265 GtkTreeIter iter;
266 GtkTreeIter parent;
267 GtkTreeIter * pparent;
268
80 DEBUG_BEGIN(); 269 DEBUG_BEGIN();
81 mime = ECRS_getFromMetaData(meta, 270 model = GTK_TREE_STORE
271 (gtk_tree_view_get_model
272 (GTK_TREE_VIEW(searchContext->treeview)));
273 gtk_tree_store_append(model,
274 &iter,
275 NULL);
276 mime = ECRS_getFromMetaData(info->meta,
82 EXTRACTOR_MIMETYPE); 277 EXTRACTOR_MIMETYPE);
83 if (mime == NULL) 278 if (mime == NULL)
84 mime = STRDUP(_("unknown")); 279 mime = STRDUP(_("unknown"));
@@ -116,11 +311,10 @@ void addEntryToSearchTree(GtkTreeStore * model,
116 } 311 }
117 name = validate_utf8(name); 312 name = validate_utf8(name);
118 313
119 if (ECRS_isFileUri(uri)) { 314 if (ECRS_isFileUri(info->uri))
120 size = ECRS_fileSize(uri); 315 size = ECRS_fileSize(info->uri);
121 } else { 316 else
122 size = 0; 317 size = 0;
123 }
124 thumb = NULL; 318 thumb = NULL;
125 ts = ECRS_getThumbnailFromMetaData(meta, 319 ts = ECRS_getThumbnailFromMetaData(meta,
126 &thumb); 320 &thumb);
@@ -148,30 +342,126 @@ void addEntryToSearchTree(GtkTreeStore * model,
148 SEARCH_MIME, mime, 342 SEARCH_MIME, mime,
149 SEARCH_DESC, desc, 343 SEARCH_DESC, desc,
150 SEARCH_PIXBUF, pixbuf, 344 SEARCH_PIXBUF, pixbuf,
151 SEARCH_URI, ECRS_dupUri(uri), 345 SEARCH_URI, ECRS_dupUri(info->uri),
152 SEARCH_META, ECRS_dupMetaData(meta), 346 SEARCH_META, ECRS_dupMetaData(info->meta),
153 SEARCH_INTERNAL, NULL, /* internal */ 347 SEARCH_INTERNAL, searchContext,
154 -1); 348 -1);
155 FREE(size_h); 349 FREE(size_h);
156 FREE(mime); 350 FREE(mime);
157 FREE(desc); 351 FREE(desc);
158 FREE(name); 352 FREE(name);
159 FREENONNULL(thumb); 353 FREENONNULL(thumb);
160 DEBUG_END(); 354
355 /* update tab title with the number of results */
356 file_count = (unsigned int *)
357 g_object_get_data(G_OBJECT(list->searchpage), "file_count");
358 (*file_count)++;
359 tab_label = (GtkWidget *)
360 g_object_get_data(G_OBJECT(list->searchpage), "label");
361 tab_title = (char *)
362 g_object_get_data(G_OBJECT(list->searchpage), "title");
363 new_title =
364 g_strdup_printf("%s%s%u%s",
365 tab_title, " (", *file_count, ")");
366 gtk_label_set(GTK_LABEL(tab_label), new_title);
367 FREE(new_title);
368
369 if (! gtk_tree_model_get_iter_first(GTK_TREE_MODEL(search_summary),
370 &iter)) {
371 GE_BREAK(ectx, 0);
372 return;
373 }
374
375 do {
376 gtk_tree_model_get(GTK_TREE_MODEL(search_summary),
377 &iter,
378 SER_SUM_URI, &euri,
379 -1);
380 if (ECRS_equalsUri(euri,
381 uri)) {
382 gtk_list_store_set(GTK_LIST_STORE(search_summary),
383 &iter,
384 SER_SUM_COUNT, *file_count,
385 -1);
386 DEBUG_END();
387 return;
388 }
389
390 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(search_summary),
391 &iter));
161} 392}
162
163 393
164GtkWidget * getAnonymityButtonFromTM(GtkTreeModel * model) { 394static SearchList *
395fs_search_started(struct FSUI_SearchList * fsui_list,
396 const struct ECRS_URI * uri,
397 unsigned int anonymityLevel,
398 unsigned int resultCount,
399 const ECRS_FileInfo * results) {
400 GtkWidget * notebook;
401 GtkWidget * label;
402 GtkTreeIter iter;
165 SearchList * list; 403 SearchList * list;
404 char * tabtxt;
405 int i;
406 const char * dhead;
166 407
167 list = head; 408 notebook
168 while (list != NULL) { 409 = glade_xml_get_widget(getMainXML(),
169 if (list->model == model) 410 "downloadNotebook");
170 return list->anonymityButton; 411 list
171 list = list->next; 412 = MALLOC(sizeof(SearchList));
413 list->searchpage
414 = makeSearchResultFrame(&list->treeview,
415 &list->anonymityButton);
416 list->uri
417 = ECRS_dupUri(uri);
418 list->next
419 = search_head;
420 list->fsui_list
421 = fsui_list;
422 search_head = list;
423
424 description = ECRS_uriToString(uri);
425 if (description == NULL) {
426 GE_BREAK(ectx, 0);
427 return SYSERR;
172 } 428 }
173 GE_BREAK(ectx, 0); 429 GE_ASSERT(ectx,
174 return NULL; 430 strlen(description) >= strlen(ECRS_URI_PREFIX));
431 dhead = &description[strlen(ECRS_URI_PREFIX)];
432 if (0 == strncmp(dhead,
433 ECRS_SEARCH_INFIX,
434 strlen(ECRS_SEARCH_INFIX)))
435 dhead = &dhead[strlen(ECRS_SEARCH_INFIX)];
436 else if (0 == strncmp(dhead,
437 ECRS_SUBSPACE_INFIX,
438 strlen(ECRS_SUBSPACE_INFIX)))
439 dhead = &dhead[strlen(ECRS_SUBSPACE_INFIX)];
440
441 tabtxt = STRDUP("foo"); /* FIXME! */
442 gtk_list_store_append(search_summary,
443 &iter);
444 gtk_list_store_set(search_summary,
445 &iter,
446 SER_SUM_NAME, dhead,
447 SER_SUM_COUNT, 0,
448 SER_SUM_URI, ECRS_dupUri(uri),
449 -1);
450 label = buildSearchTabLabel(list->searchpage,
451 dhead);
452 gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
453 list->searchpage,
454 label);
455 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook),
456 pages);
457 gtk_widget_show(notebook);
458 FREE(description);
459 for (i=0;i<resultCount;i++)
460 fs_search_result_received(ret,
461 &results[i],
462 uri);
463 DEBUG_END();
464 return list;
175} 465}
176 466
177/** 467/**
@@ -209,183 +499,23 @@ static void freeIterSubtree(GtkTreeModel * tree,
209 iter)); 499 iter));
210} 500}
211 501
212void on_searchResults_destroy_fs(GtkWidget * dummy, 502void fs_search_stopped(SearchList * list) {
213 GtkWidget * treeview) {
214 GtkTreeStore * tree;
215 GtkTreeIter iter;
216
217 tree = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)));
218 if (! gtk_tree_model_get_iter_first(GTK_TREE_MODEL(tree),
219 &iter))
220 return; /* tree empty */
221 freeIterSubtree(GTK_TREE_MODEL(tree),
222 &iter);
223}
224
225/**
226 * Add the given result to the model (search result
227 * list).
228 * @param info the information to add to the model
229 * @param treeview the page from which to obtain the model
230 * @param path the tree path that selects where to add
231 * the information
232 */
233static void addSearchResultToModel(const ECRS_FileInfo * info,
234 GtkWidget * treeview,
235 GtkTreeRowReference * row) {
236 GtkTreeStore * model;
237 GtkTreeIter iter;
238 GtkTreeIter parent;
239 GtkTreeIter * pparent;
240 GtkTreePath * path;
241
242 DEBUG_BEGIN();
243 if (! gtk_tree_row_reference_valid(row))
244 path = NULL;
245 else
246 path = gtk_tree_row_reference_get_path(row);
247 model = GTK_TREE_STORE
248 (gtk_tree_view_get_model
249 (GTK_TREE_VIEW(treeview)));
250 if (path != NULL) {
251 gtk_tree_model_get_iter(GTK_TREE_MODEL(model),
252 &parent,
253 path);
254 pparent = &parent;
255 } else
256 pparent = NULL;
257 gtk_tree_store_insert(model,
258 &iter,
259 pparent,
260 0x7FFFFFFF); /* MAX-int => insert at end! */
261 addEntryToSearchTree(model,
262 &iter,
263 info->uri,
264 info->meta);
265 DEBUG_END();
266}
267
268/**
269 * Add the given result to the model (search result
270 * list).
271 * @param info the information to add to the model
272 * @param uri the search URI
273 * @param path the tree path that selects where to add
274 * the information, NULL for top-level
275 */
276void displaySearchResult(const ECRS_FileInfo * info,
277 const struct ECRS_URI * uri,
278 GtkTreeRowReference * row) {
279 SearchList * list;
280 struct ECRS_URI * euri;
281 unsigned int *file_count;
282 GtkTreeIter iter;
283 GtkWidget *tab_label;
284 char *tab_title, *new_title;
285
286 DEBUG_BEGIN();
287 list = head;
288 while (list != NULL) {
289 if (ECRS_equalsUri(list->uri,
290 uri))
291 break;
292 list = list->next;
293 }
294 if (list == NULL)
295 return; /* search result received during shutdown */
296 addSearchResultToModel(info,
297 list->treeview,
298 row);
299
300 /* update tab title with the number of results */
301 file_count = (unsigned int *)
302 g_object_get_data(G_OBJECT(list->searchpage), "file_count");
303 (*file_count)++;
304 tab_label = (GtkWidget *)
305 g_object_get_data(G_OBJECT(list->searchpage), "label");
306 tab_title = (char *)
307 g_object_get_data(G_OBJECT(list->searchpage), "title");
308 new_title =
309 g_strdup_printf("%s%s%u%s", tab_title, " (", *file_count, ")");
310 gtk_label_set(GTK_LABEL(tab_label), new_title);
311 FREE(new_title);
312
313 if (! gtk_tree_model_get_iter_first(GTK_TREE_MODEL(summary),
314 &iter)) {
315 GE_BREAK(ectx, 0);
316 return;
317 }
318
319 do {
320 gtk_tree_model_get(GTK_TREE_MODEL(summary),
321 &iter,
322 SER_SUM_URI, &euri,
323 -1);
324 if (ECRS_equalsUri(euri,
325 uri)) {
326 gtk_list_store_set(GTK_LIST_STORE(summary),
327 &iter,
328 SER_SUM_COUNT, *file_count,
329 -1);
330 DEBUG_END();
331 return;
332 }
333
334 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(summary),
335 &iter));
336 GE_BREAK(ectx, 0);
337}
338
339static void * stopSearch(void * u) {
340 struct FSUI_SearchList * search = u;
341
342 DEBUG_BEGIN();
343 FSUI_stopSearch(ctx,
344 search);
345 DEBUG_END();
346 return NULL;
347}
348
349static void freeSearchModel(GtkTreeModel * model,
350 GtkTreeIter * parent) {
351 struct ECRS_URI * u;
352 struct ECRS_MetaData * m;
353 GtkTreeIter iter;
354
355 DEBUG_BEGIN();
356 if (gtk_tree_model_iter_children(model,
357 &iter,
358 parent)) {
359 do {
360 gtk_tree_model_get(model,
361 &iter,
362 SEARCH_URI, &u,
363 SEARCH_META, &m,
364 -1);
365 gtk_tree_store_set(GTK_TREE_STORE(model),
366 &iter,
367 SEARCH_URI, NULL,
368 SEARCH_META, NULL,
369 -1);
370 if (u != NULL)
371 ECRS_freeUri(u);
372 if (m != NULL)
373 ECRS_freeMetaData(m);
374 freeSearchModel(model, &iter);
375 } while (gtk_tree_model_iter_next(model,
376 &iter));
377 }
378 DEBUG_END();
379}
380
381static void closeSearchPage(SearchList * list) {
382 GtkWidget * notebook; 503 GtkWidget * notebook;
383 int index; 504 int index;
384 int i; 505 int i;
385 GtkTreeIter iter; 506 GtkTreeIter iter;
386 struct ECRS_URI * euri; 507 struct ECRS_URI * euri;
508 SearchList * prev;
387 509
388 DEBUG_BEGIN(); 510 DEBUG_BEGIN();
511 if (search_head == list) {
512 search_head = search_head->next;
513 } else {
514 prev = search_head;
515 while (prev->next != list)
516 prev = prev->next;
517 prev->next = list->next;
518 }
389 notebook 519 notebook
390 = glade_xml_get_widget(getMainXML(), 520 = glade_xml_get_widget(getMainXML(),
391 "downloadNotebook"); 521 "downloadNotebook");
@@ -394,666 +524,860 @@ static void closeSearchPage(SearchList * list) {
394 if (list->searchpage == gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), 524 if (list->searchpage == gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
395 i)) 525 i))
396 index = i; 526 index = i;
397 527 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook),
398 if (index != -1) { 528 index);
399 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), 529 /* recursively free download tree */
400 index); 530 if (gtk_tree_model_get_iter_first(list->model,
401 } else { 531 &iter))
402 GE_BREAK(ectx, 0); 532 freeIterSubtree(list->model,
403 } 533 &iter);
404 freeSearchModel(list->model, NULL); 534 freeSearchModel(list->model, NULL);
405 list->model = NULL; 535 if (! gtk_tree_model_get_iter_first(GTK_TREE_MODEL(search_summary),
406
407 if (! gtk_tree_model_get_iter_first(GTK_TREE_MODEL(summary),
408 &iter)) { 536 &iter)) {
409 GE_BREAK(ectx, 0); 537 GE_BREAK(ectx, 0);
410 ECRS_freeUri(list->uri); 538 ECRS_freeUri(list->uri);
411 list->uri = NULL; 539 FREE(list);
540 DEBUG_END();
412 return; 541 return;
413 } 542 }
414 do { 543 do {
415 gtk_tree_model_get(GTK_TREE_MODEL(summary), 544 gtk_tree_model_get(GTK_TREE_MODEL(search_summary),
416 &iter, 545 &iter,
417 SER_SUM_URI, &euri, 546 SER_SUM_URI, &euri,
418 -1); 547 -1);
419 if (ECRS_equalsUri(euri, 548 if (ECRS_equalsUri(euri,
420 list->uri)) { 549 list->uri)) {
421 gtk_list_store_remove(GTK_LIST_STORE(summary), 550 gtk_list_store_remove(GTK_LIST_STORE(search_summary),
422 &iter); 551 &iter);
423 ECRS_freeUri(euri); 552 ECRS_freeUri(euri);
424 ECRS_freeUri(list->uri); 553 break;
425 list->uri = NULL;
426 DEBUG_END();
427 return;
428 } 554 }
429 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(summary), 555 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(search_summary),
430 &iter)); 556 &iter));
431 ECRS_freeUri(list->uri); 557 ECRS_freeUri(list->uri);
432 list->uri = NULL;
433 GE_BREAK(ectx, 0);
434}
435
436void on_closeSearchButton_clicked_fs(GtkWidget * searchPage,
437 GtkWidget * closeButton) {
438 SearchList * list;
439 SearchList * prev;
440
441 DEBUG_BEGIN();
442 list = head;
443 prev = NULL;
444 while (list != NULL) {
445 if (list->searchpage == searchPage)
446 break;
447 prev = list;
448 list = list->next;
449 }
450 if (list == NULL)
451 return;
452 if (prev == NULL)
453 head = list->next;
454 else
455 prev->next = list->next;
456
457 run_with_save_calls(&stopSearch,
458 list->fsui_list);
459 closeSearchPage(list);
460 FREE(list); 558 FREE(list);
461 DEBUG_END(); 559 DEBUG_END();
462} 560}
463 561
464static GtkWidget * makeResultFrame(GtkWidget ** treeview, 562void fs_search_start(struct GE_Context * e,
465 GtkWidget ** anonSpin) { 563 struct GC_Configuration * c) {
466 GtkWidget * window; 564 GtkWidget * searchCB;
467 GtkWidget * child; 565 GtkWidget * searchList;
468 GtkWidget * resultList; 566 GtkListStore * model;
469 GtkTreeViewColumn * column;
470 GtkCellRenderer * renderer; 567 GtkCellRenderer * renderer;
471 GtkTreeStore * tree; 568 GtkTreeViewColumn * column;
472 GladeXML * searchXML;
473 int col; 569 int col;
474 570 GtkWidget * downloadList;
571
572 ectx = e;
573 cfg = c;
475 DEBUG_BEGIN(); 574 DEBUG_BEGIN();
476 searchXML 575 searchCB
477 = glade_xml_new(getGladeFileName(), 576 = glade_xml_get_widget(getMainXML(),
478 "searchResultsFrame", 577 "fssearchKeywordComboBoxEntry");
479 PACKAGE_NAME); 578
480 connectGladeWithPlugins(searchXML); 579 model = gtk_list_store_new(NS_SEARCH_NUM,
481 window = glade_xml_get_widget(searchXML, 580 G_TYPE_STRING, /* what we show */
482 "searchResultsFrame"); 581 G_TYPE_STRING, /* EncName of namespace */
483 resultList = glade_xml_get_widget(searchXML, 582 G_TYPE_POINTER, /* ECRS MetaData */
484 "searchResults"); 583 G_TYPE_POINTER, /* FSUI search list */
485 *anonSpin = glade_xml_get_widget(searchXML, 584 G_TYPE_INT); /* Meta-data about namespace */
486 "downloadAnonymitySpinButton"); 585 gtk_combo_box_set_model(GTK_COMBO_BOX(searchCB),
487 if (treeview != NULL) 586 GTK_TREE_MODEL(model));
488 (*treeview) = GTK_WIDGET(GTK_TREE_VIEW(resultList)); 587 gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(searchCB),
489 tree = 588 NS_SEARCH_DESCRIPTION);
490 gtk_tree_store_new(SEARCH_NUM, 589 searchList = glade_xml_get_widget(getMainXML(),
590 "activeSearchesSummary");
591 search_summary =
592 gtk_list_store_new(SER_SUM_NUM,
491 G_TYPE_STRING, /* name */ 593 G_TYPE_STRING, /* name */
492 G_TYPE_UINT64, /* size */ 594 G_TYPE_INT, /* # results */
493 G_TYPE_STRING, /* human-readable size */ 595 G_TYPE_POINTER, /* internal: FSUI search list */
494 G_TYPE_STRING, /* mime-type */ 596 G_TYPE_POINTER); /* internal: uri */
495 G_TYPE_STRING, /* meta-data (some) */ 597 gtk_tree_view_set_model(GTK_TREE_VIEW(searchList),
496 GDK_TYPE_PIXBUF, /* preview */ 598 GTK_TREE_MODEL(search_summary));
497 G_TYPE_POINTER, /* url */
498 G_TYPE_POINTER, /* meta */
499 G_TYPE_POINTER); /* internal: download info/NULL */
500 gtk_tree_view_set_model(GTK_TREE_VIEW(resultList),
501 GTK_TREE_MODEL(tree));
502 renderer = gtk_cell_renderer_text_new(); 599 renderer = gtk_cell_renderer_text_new();
503 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 600 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(searchList),
504 -1, 601 -1,
505 _("Name"), 602 _("Query"),
506 renderer, 603 renderer,
507 "text", SEARCH_NAME, 604 "text", SER_SUM_NAME,
508 NULL); 605 NULL);
509 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 606 column = gtk_tree_view_get_column(GTK_TREE_VIEW(searchList),
510 col - 1); 607 col - 1);
511 gtk_tree_view_column_set_resizable(column, TRUE); 608 gtk_tree_view_column_set_resizable(column, TRUE);
512 gtk_tree_view_column_set_clickable(column, TRUE); 609 gtk_tree_view_column_set_clickable(column, TRUE);
513 gtk_tree_view_column_set_reorderable(column, TRUE); 610 gtk_tree_view_column_set_reorderable(column, TRUE);
514 gtk_tree_view_column_set_sort_column_id(column, SEARCH_NAME); 611 gtk_tree_view_column_set_sort_column_id(column, SER_SUM_NAME);
515 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 612 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(searchList),
613 col - 1),
614 TRUE);
516 renderer = gtk_cell_renderer_text_new(); 615 renderer = gtk_cell_renderer_text_new();
517 g_object_set (renderer, "xalign", 1.00, NULL); 616 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(searchList),
518 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList),
519 -1, 617 -1,
520 _("Size"), 618 _("Results"),
521 renderer, 619 renderer,
522 "text", SEARCH_HSIZE, 620 "text", SER_SUM_COUNT,
523 NULL); 621 NULL);
524 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 622 column = gtk_tree_view_get_column(GTK_TREE_VIEW(searchList),
525 col - 1); 623 col - 1);
526 gtk_tree_view_column_set_resizable(column, TRUE); 624 gtk_tree_view_column_set_resizable(column, TRUE);
527 gtk_tree_view_column_set_clickable(column, TRUE); 625 gtk_tree_view_column_set_clickable(column, TRUE);
528 gtk_tree_view_column_set_reorderable(column, TRUE); 626 gtk_tree_view_column_set_reorderable(column, TRUE);
529 gtk_tree_view_column_set_sort_column_id(column, SEARCH_SIZE); 627 gtk_tree_view_column_set_sort_column_id(column, SER_SUM_COUNT);
530 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 628 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(searchList),
629 col - 1),
630 TRUE);
531 631
532 renderer = gtk_cell_renderer_text_new(); 632
533 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 633 downloadList = glade_xml_get_widget(getMainXML(),
534 -1, 634 "activeDownloadsList");
535 _("Mime-type"), 635 download_summary =
536 renderer, 636 gtk_tree_store_new(DOWNLOAD_NUM,
537 "text", SEARCH_MIME, 637 G_TYPE_STRING, /* name (full-path file name) */
538 NULL); 638 G_TYPE_STRING, /* name (user-friendly name) */
539 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 639 G_TYPE_UINT64, /* size */
640 G_TYPE_STRING, /* human readable size */
641 G_TYPE_INT, /* progress */
642 G_TYPE_STRING, /* uri */
643 G_TYPE_POINTER, /* url */
644 G_TYPE_POINTER, /* internal: gtk tree path / NULL */
645 G_TYPE_STRING); /* directory path if file is inside a dir */
646 gtk_tree_view_set_model(GTK_TREE_VIEW(downloadList),
647 GTK_TREE_MODEL(download_summary));
648 renderer = gtk_cell_renderer_progress_new();
649 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(downloadList),
650 -1,
651 _("Name"),
652 renderer,
653 "value", DOWNLOAD_PROGRESS,
654 "text", DOWNLOAD_SHORTNAME,
655 NULL);
656 column = gtk_tree_view_get_column(GTK_TREE_VIEW(downloadList),
540 col - 1); 657 col - 1);
541 gtk_tree_view_column_set_resizable(column, TRUE); 658 gtk_tree_view_column_set_resizable(column, TRUE);
542 gtk_tree_view_column_set_clickable(column, TRUE); 659 gtk_tree_view_column_set_clickable(column, TRUE);
543 gtk_tree_view_column_set_reorderable(column, TRUE); 660 gtk_tree_view_column_set_reorderable(column, TRUE);
544 gtk_tree_view_column_set_sort_column_id(column, SEARCH_MIME); 661 gtk_tree_view_column_set_sort_column_id(column, DOWNLOAD_PROGRESS);
545 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 662 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/
546 663 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(downloadList),
664 col - 1),
665 TRUE);
547 renderer = gtk_cell_renderer_text_new(); 666 renderer = gtk_cell_renderer_text_new();
548 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 667 g_object_set (renderer, "xalign", 1.00, NULL);
549 -1, 668 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(downloadList),
550 _("Meta-data"), 669 -1,
551 renderer, 670 _("Size"),
552 "text", SEARCH_DESC, 671 renderer,
553 NULL); 672 "text", DOWNLOAD_HSIZE,
554 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 673 NULL);
674
675 column = gtk_tree_view_get_column(GTK_TREE_VIEW(downloadList),
555 col - 1); 676 col - 1);
556 gtk_tree_view_column_set_resizable(column, TRUE); 677 gtk_tree_view_column_set_resizable(column, TRUE);
557 gtk_tree_view_column_set_clickable(column, TRUE); 678 gtk_tree_view_column_set_clickable(column, TRUE);
558 gtk_tree_view_column_set_reorderable(column, TRUE); 679 gtk_tree_view_column_set_reorderable(column, TRUE);
559 gtk_tree_view_column_set_sort_column_id(column, SEARCH_DESC); 680 gtk_tree_view_column_set_sort_column_id(column, DOWNLOAD_SIZE);
560 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 681 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/
561 if (YES != GC_get_configuration_value_yesno(cfg, 682 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(downloadList),
562 "GNUNET-GTK", 683 col - 1),
563 "DISABLE-PREVIEWS", 684 TRUE);
564 NO)) { 685 renderer = gtk_cell_renderer_text_new();
565 renderer = gtk_cell_renderer_pixbuf_new(); 686 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(downloadList),
566 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 687 -1,
567 -1, 688 _("URI"),
568 _("Preview"), 689 renderer,
569 renderer, 690 "text", DOWNLOAD_URISTRING,
570 "pixbuf", SEARCH_PIXBUF, 691 NULL);
571 NULL); 692 column = gtk_tree_view_get_column(GTK_TREE_VIEW(downloadList),
572 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 693 col - 1);
573 col - 1); 694 gtk_tree_view_column_set_resizable(column, TRUE);
574 gtk_tree_view_column_set_resizable(column, TRUE); 695 gtk_tree_view_column_set_reorderable(column, TRUE);
575 gtk_tree_view_column_set_reorderable(column, TRUE); 696 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/
576 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 697 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(downloadList),
577 col - 1), 698 col - 1),
578 TRUE); 699 TRUE);
579 }
580 child = gtk_bin_get_child(GTK_BIN(window));
581 gtk_widget_ref(GTK_WIDGET(child));
582 gtk_container_remove(GTK_CONTAINER(window),
583 child);
584 gtk_widget_destroy(window);
585 UNREF(searchXML);
586 DEBUG_END(); 700 DEBUG_END();
587 return child;
588} 701}
589 702
590typedef struct { 703void fs_search_stop() {
591 struct ECRS_URI * uri;
592 int anon;
593 struct FSUI_SearchList * ret;
594} StartSearchClosure;
595
596static void * startSearch(void * cls) {
597 StartSearchClosure * ssc = cls;
598
599 ssc->ret = FSUI_startSearch(ctx,
600 ssc->anon,
601 1000, /* FIXME: max results */
602 99 * cronYEARS, /* FIXME: timeout */
603 ssc->uri);
604 return NULL;
605} 704}
606 705
607void on_fssearchbutton_clicked_fs(gpointer dummy2, 706
608 GtkWidget * searchButton) { 707
609 GtkWidget * searchKeywordGtkCB; 708
610 GtkWidget * searchNamespaceGtkCB; 709
611 GtkWidget * notebook; 710
612 GtkWidget * page; 711
613 GtkWidget * label; 712
614 GtkWidget * entry; 713#if 0
615 GtkWidget * spin; 714static int addFilesToDirectory
616 GtkListStore * model; 715 (const ECRS_FileInfo * fi,
617 GtkTreeModel * tmodel; 716 const HashCode512 * key,
717 int isRoot,
718 void * closure) {
719 struct ECRS_URI * uri = closure;
720 DownloadList * pos;
618 GtkTreeIter iter; 721 GtkTreeIter iter;
619 struct ECRS_URI * uri; 722 GtkTreeIter child;
620 const char * ss; 723 int i;
621 const char * ns; 724 GtkTreePath * path;
622 gint pages;
623 gint i;
624 char * tabtxt;
625 SearchList * list;
626 const char * descStr;
627 StartSearchClosure ssc;
628 725
726 if (isRoot == YES)
727 return OK;
629 DEBUG_BEGIN(); 728 DEBUG_BEGIN();
630 searchKeywordGtkCB 729 pos = download_head;
631 = glade_xml_get_widget(getMainXML(), 730 while (pos != NULL) {
632 "fssearchKeywordComboBoxEntry"); 731 if (ECRS_equalsUri(uri,
633 entry = gtk_bin_get_child(GTK_BIN(searchKeywordGtkCB)); 732 pos->uri))
634 ss = gtk_entry_get_text(GTK_ENTRY(entry)); 733 break;
635 if (ss == NULL) { 734 pos = pos->next;
636 GE_LOG(ectx,
637 GE_ERROR | GE_USER | GE_IMMEDIATE,
638 _("Need a keyword to search!\n"));
639 return;
640 } 735 }
641 i = gtk_combo_box_get_active(GTK_COMBO_BOX(searchKeywordGtkCB)); 736 if (pos != NULL) {
642 if (i == -1) { 737 if (! gtk_tree_row_reference_valid(pos->rr))
643 model = GTK_LIST_STORE 738 return SYSERR;
644 (gtk_combo_box_get_model 739 path = gtk_tree_row_reference_get_path(pos->rr);
645 (GTK_COMBO_BOX(searchKeywordGtkCB))); 740 gtk_tree_model_get_iter(GTK_TREE_MODEL(pos->model),
646 gtk_list_store_prepend(model, 741 &iter,
647 &iter); 742 path);
648 gtk_list_store_set(model, 743 gtk_tree_path_free(path);
649 &iter, 744 for (i=gtk_tree_model_iter_n_children(pos->model,
650 0, ss, 745 &iter)-1;i>=0;i--) {
651 -1); 746 if (TRUE == gtk_tree_model_iter_nth_child(pos->model,
747 &child,
748 &iter,
749 i)) {
750 struct ECRS_URI * uri;
751 uri = NULL;
752 gtk_tree_model_get(pos->model,
753 &child,
754 SEARCH_URI, &uri,
755 -1);
756 if ( (uri != NULL) &&
757 (ECRS_equalsUri(uri,
758 fi->uri)) )
759 return OK;
760 }
761 }
762 gtk_tree_store_append(GTK_TREE_STORE(pos->model),
763 &child,
764 &iter);
765 addEntryToSearchTree(GTK_TREE_STORE(pos->model),
766 &child,
767 fi->uri,
768 fi->meta);
652 } 769 }
770 DEBUG_END();
771 return OK;
772}
773#endif
653 774
654 searchNamespaceGtkCB 775/**
655 = glade_xml_get_widget(getMainXML(), 776 * FIXME: somehow need way to pass
656 "searchNamespaceComboBoxEntry"); 777 * tree path for search into this download!
778 */
779struct DL *
780fs_download_started(struct FSUI_DownloadList * fsui_dl,
781 unsigned long long total,
782 unsigned int anonymityLevel,
783 const struct ECRS_FileInfo * fi,
784 const char * filename,
785 unsigned long long completed,
786 cron_t eta) {
787 DownloadList * list;
788 GtkTreeIter iiter;
789 GtkTreePath *dirTreePath;
790 unsigned long long size;
791 char * size_h;
792 const char * idc_name;
793
794 /* setup visualization */
795 list = MALLOC(sizeof(DownloadList));
796 list->download_list = fsui_dl;
797 list->rr = NULL;
798 list->model = NULL;
799 if (YES == ECRS_isDirectory(fi->meta)) {
800 list->rr = gtk_tree_row_reference_new(model, path);
801 list->model = model;
802 }
803 list->uri = ECRS_dupUri(fi->uri);
804 list->filename = STRDUP(filename);
805 size = ECRS_fileSize(fi->uri);
806 size_h = string_get_fancy_byte_size(size);
807 idc_name = "FIXME";
808 gtk_tree_store_append(download_summary,
809 &iiter,
810 NULL);
811 gtk_tree_store_set(download_summary,
812 &iiter,
813 DOWNLOAD_FILENAME, filename,
814 DOWNLOAD_SHORTNAME, idc_name,
815 DOWNLOAD_SIZE, size,
816 DOWNLOAD_HSIZE, size_h,
817 DOWNLOAD_PROGRESS, 0, /* progress */
818 DOWNLOAD_URISTRING, uri_name,
819 DOWNLOAD_URI, ECRS_dupUri(fi->uri),
820 DOWNLOAD_TREEPATH, list->rr, /* internal: row reference! */
821 DOWNLOAD_DIRPATH, dirPath,
822 -1);
823 FREE(size_h);
824 list->next = download_head;
825 download_head = list;
826 DEBUG_END();
827 return list;
828}
657 829
658 tmodel = gtk_combo_box_get_model(GTK_COMBO_BOX(searchNamespaceGtkCB));
659 if (TRUE == gtk_combo_box_get_active_iter(GTK_COMBO_BOX(searchNamespaceGtkCB),
660 &iter)) {
661 ns = NULL;
662 descStr = NULL;
663 gtk_tree_model_get(tmodel,
664 &iter,
665 NS_SEARCH_DESCRIPTION, &descStr,
666 NS_SEARCH_ENCNAME, &ns,
667 -1);
668 830
669 if ( (descStr != NULL) && 831
670 (0 == strcmp(descStr, 832
671 _("globally"))) ) { 833static void initiateDownload(GtkTreeModel * model,
672 ns = NULL; 834 GtkTreePath * path,
673 } else { 835 GtkTreeIter * iter,
674 GE_ASSERT(ectx, strlen(ns) == sizeof(EncName) - 1); 836 gpointer unused) {
675 if (descStr == NULL) 837 char * uri_name;
676 descStr = ns; 838 char * final_download_dir;
677 } 839 DownloadList * list;
840 GtkTreeIter iiter;
841 GtkWidget * spin;
842 const char * oname;
843 const char * cname;
844 char * dname;
845 GtkTreePath *dirTreePath;
846 char *dirPath;
847 unsigned int dirPathLen;
848 char * size_h;
849 unsigned long long size;
850
851 struct ECRS_URI * idc_uri;
852 struct ECRS_MetaData * idc_meta;
853 const char * idc_name;
854 const char * idc_mime;
855 char * idc_final_download_destination;
856 unsigned int idc_anon;
857 struct FSUI_SearchList * idc_ret;
858 struct SL * searchContext;
859
860#ifdef WINDOWS
861 char *filehash = NULL;
862#endif
863
864 DEBUG_BEGIN();
865 idc_uri = NULL;
866 idc_meta = NULL;
867 idc_name = NULL;
868 idc_mime = NULL;
869 gtk_tree_model_get(model,
870 iter,
871 SEARCH_NAME, &idc_name,
872 SEARCH_URI, &idc_uri,
873 SEARCH_META, &idc_meta,
874 SEARCH_MIME, &idc_mime,
875 SEARCH_INTERNAL, &searchContext,
876 -1);
877 if (idc_uri == NULL) {
878 GE_BREAK(ectx, 0);
879 return;
678 } 880 }
679 if (ns != NULL) {
680 char * ustring;
681 881
682 ustring = MALLOC(strlen(ss) + sizeof(EncName) + 882 spin = searchContext->anonymityButton;
683 strlen(ECRS_URI_PREFIX) + 883 if (spin == NULL) {
684 strlen(ECRS_SUBSPACE_INFIX) + 10); 884 GE_BREAK(ectx, 0);
685 strcpy(ustring, ECRS_URI_PREFIX); 885 idc_anon = 1;
686 strcat(ustring, ECRS_SUBSPACE_INFIX);
687 strcat(ustring, ns);
688 strcat(ustring, "/");
689 strcat(ustring, ss);
690 uri = ECRS_stringToUri(ectx, ustring);
691 if (uri == NULL) {
692 GE_LOG(ectx,
693 GE_ERROR | GE_BULK | GE_USER,
694 _("Failed to create namespace URI from `%s'.\n"),
695 ustring);
696 }
697 FREE(ustring);
698 } else { 886 } else {
699 uri = ECRS_parseCharKeywordURI(ectx, ss); 887 idc_anon = gtk_spin_button_get_value_as_int
888 (GTK_SPIN_BUTTON(spin));
700 } 889 }
701 if (uri == NULL) 890 if (! ECRS_isFileUri(idc_uri)) {
891 if (ECRS_isNamespaceUri(idc_uri)) {
892 /* start namespace search; would probably be better
893 to add this as a subtree, but for simplicity
894 we'll just add it as a new tab for now */
895 FSUI_startSearch(ctx,
896 idc_anon,
897 1000, /* FIXME: max results */
898 99 * cronYEARS, /* fixme: timeout */
899 idc_uri);
900 return;
901 } else {
902 GE_BREAK(ectx, 0); /* unsupported URI type (i.e. ksk or loc) */
903 return;
904 }
905 }
906
907 uri_name = ECRS_uriToString(idc_uri);
908 if ( (uri_name == NULL) ||
909 (strlen(uri_name) <
910 strlen(ECRS_URI_PREFIX) +
911 strlen(ECRS_FILE_INFIX)) ) {
912 GE_BREAK(ectx, 0);
913 FREENONNULL(uri_name);
702 return; 914 return;
703 if (ns == NULL) {
704 tabtxt = STRDUP(ss);
705 } else {
706 GE_ASSERT(ectx, descStr != NULL);
707 tabtxt = MALLOC(strlen(ss) + strlen(descStr) + 2);
708 SNPRINTF(tabtxt,
709 strlen(ss) + strlen(descStr) + 2,
710 "%s/%s",
711 descStr,
712 ss);
713 } 915 }
714 notebook 916
715 = glade_xml_get_widget(getMainXML(), 917 if (idc_name == NULL) {
716 "downloadNotebook"); 918#ifdef WINDOWS
717 list = head; 919 filehash = STRDUP(uri_name);
718 pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook)); 920 filehash[16] = 0;
719 while (list != NULL) { 921 idc_name = filehash;
720 if (ECRS_equalsUri(list->uri, 922#else
721 uri)) { 923 idc_name = uri_name;
722 for (i=0;i<pages;i++) { 924#endif
723 page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), 925 }
724 i); 926
725 if (page == list->searchpage) { 927 cname = idc_name;
726 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 928 oname = idc_name;
727 i); 929 dname = MALLOC(strlen(idc_name)+1);
728 ECRS_freeUri(uri); 930 dname[0] = '\0';
729 FREE(tabtxt); 931 while (*idc_name != '\0') {
730 return; 932 if ( (*idc_name == DIR_SEPARATOR) &&
731 } 933 (idc_name[1] != '\0') ) {
732 } 934 memcpy(dname, oname, idc_name - oname);
733 GE_BREAK(ectx, 0); 935 dname[idc_name - oname] = '\0';
936 cname = &idc_name[1];
734 } 937 }
735 list = list->next; 938 idc_name++;
736 } 939 }
737 list 940 if (*cname == '\0') /* name ended in '/' - likely directory */
738 = MALLOC(sizeof(SearchList)); 941 cname = oname;
739 list->searchpage 942 idc_name = cname;
740 = makeResultFrame(&list->treeview, 943 GC_get_configuration_value_filename(cfg,
741 &spin); 944 "FS",
742 list->next 945 "INCOMINGDIR",
743 = head; 946 "$HOME/gnunet-downloads/",
744 list->uri 947 &final_download_dir);
745 = uri; 948 if (strlen(dname) > 0) {
746 list->model 949 char * tmp;
747 = gtk_tree_view_get_model(GTK_TREE_VIEW(list->treeview)); 950 tmp = MALLOC(strlen(final_download_dir) + strlen(dname) + 2);
748 list->anonymityButton 951 strcpy(tmp, final_download_dir);
749 = spin; 952 if (tmp[strlen(tmp)] != DIR_SEPARATOR)
953 strcat(tmp, DIR_SEPARATOR_STR);
954 if (dname[0] == DIR_SEPARATOR)
955 strcat(tmp, &dname[1]);
956 else
957 strcat(tmp, dname);
958 FREE(final_download_dir);
959 final_download_dir = tmp;
960 }
961 FREE(dname);
962 disk_directory_create(ectx, final_download_dir);
750 963
751 head = list;
752 964
753 gtk_list_store_append(summary, 965 /* If file is inside a directory, get the full path */
754 &iter); 966 dirTreePath = gtk_tree_path_copy(path);
755 gtk_list_store_set(summary, 967 dirPath = MALLOC(1);
756 &iter, 968 dirPath[0] = '\0';
757 SER_SUM_NAME, tabtxt, 969 dirPathLen = 0;
758 SER_SUM_COUNT, 0, 970 while (gtk_tree_path_get_depth(dirTreePath) > 1) {
759 SER_SUM_URI, ECRS_dupUri(uri), 971 const char * dirname;
760 -1); 972 char * new;
761 973
762 label = buildSearchTabLabel(list->searchpage, tabtxt); 974 if (! gtk_tree_path_up(dirTreePath))
763 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), 975 break;
764 list->searchpage,
765 label);
766 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook),
767 pages);
768 gtk_widget_show(notebook);
769 ssc.anon = getAnonymityLevel(getMainXML(),
770 "searchAnonymitySelectionSpinButton");
771 ssc.uri = uri;
772 run_with_save_calls(&startSearch,
773 &ssc);
774 list->fsui_list = ssc.ret;
775 FREE(tabtxt);
776 DEBUG_END();
777}
778
779static int addNamespace(void * arg,
780 const char * namespaceName,
781 const HashCode512 * namespaceId,
782 const struct ECRS_MetaData * md,
783 int rating) {
784 GtkListStore * model = arg;
785 GtkTreeIter iter;
786 EncName enc;
787 char * name;
788 struct ECRS_MetaData * dmd;
789 char * desc;
790 size_t n;
791 976
792 DEBUG_BEGIN(); 977 if (!gtk_tree_model_get_iter(model,
793 hash2enc(namespaceId, 978 &iiter,
794 &enc); 979 dirTreePath))
795 if (md == NULL) { 980 break;
796 dmd = NULL; 981 gtk_tree_model_get(model,
797 desc = STRDUP(""); 982 &iiter,
798 } else { 983 SEARCH_NAME, &dirname,
799 dmd = ECRS_dupMetaData(md); 984 -1);
800 desc = ECRS_getFirstFromMetaData(md, 985 dirPathLen = strlen(dirPath) + strlen(dirname) + strlen(DIR_SEPARATOR_STR) + 1;
801 EXTRACTOR_DESCRIPTION, 986 new = MALLOC(dirPathLen + 1);
802 EXTRACTOR_TITLE, 987 strcpy(new, dirname);
803 EXTRACTOR_AUTHOR, 988 if (new[strlen(new)-1] != DIR_SEPARATOR)
804 EXTRACTOR_GENRE, 989 strcat(new, DIR_SEPARATOR_STR);
805 EXTRACTOR_SUBJECT, 990 strcat(new, dirPath);
806 EXTRACTOR_CREATOR, 991 FREE(dirPath);
807 EXTRACTOR_PRODUCER, 992 dirPath = new;
808 EXTRACTOR_GROUP,
809 EXTRACTOR_CREATED_FOR,
810 EXTRACTOR_SUMMARY,
811 EXTRACTOR_OWNER,
812 -1);
813 if (desc == NULL)
814 desc = STRDUP("");
815 } 993 }
816 994 gtk_tree_path_free(dirTreePath);
817 n = strlen(desc) + 64; 995
818 name = MALLOC(n); 996
819 SNPRINTF(name, 997 /* construct completed/directory/real-filename */
820 n, 998 idc_final_download_destination = MALLOC(strlen(final_download_dir) + 2 +
821 "%s: %*.s", 999 strlen(idc_name) + strlen(GNUNET_DIRECTORY_EXT) +
822 desc, 1000 strlen(dirPath));
823 20, 1001 strcpy(idc_final_download_destination, final_download_dir);
824 &enc); 1002 if (idc_final_download_destination[strlen(idc_final_download_destination)-1] != DIR_SEPARATOR)
825 gtk_list_store_append(model, 1003 strcat(idc_final_download_destination,
826 &iter); 1004 DIR_SEPARATOR_STR);
827 gtk_list_store_set(model, 1005 strcat(idc_final_download_destination, dirPath);
828 &iter, 1006 disk_directory_create(ectx,
829 NS_SEARCH_DESCRIPTION, name, 1007 idc_final_download_destination);
830 NS_SEARCH_ENCNAME, &enc, 1008 strcat(idc_final_download_destination, idc_name);
831 NS_SEARCH_METADATA, dmd, 1009 if ( (idc_final_download_destination[strlen(idc_final_download_destination) - 1] == '/') ||
832 NS_SEARCH_RATING, rating, 1010 (idc_final_download_destination[strlen(idc_final_download_destination) - 1] == '\\') )
833 -1); 1011 idc_final_download_destination[strlen(idc_final_download_destination) - 1] = '\0';
834 FREE(name); 1012 /* append ".gnd" if needed (== directory and .gnd not present) */
835 DEBUG_END(); 1013 if ( (idc_mime != NULL) &&
836 return OK; 1014 (0 == strcmp(idc_mime, GNUNET_DIRECTORY_MIME)) &&
1015 ( (strlen(idc_final_download_destination) < strlen(GNUNET_DIRECTORY_EXT)) ||
1016 (0 != strcmp(&idc_final_download_destination[strlen(idc_final_download_destination)
1017 - strlen(GNUNET_DIRECTORY_EXT)],
1018 GNUNET_DIRECTORY_EXT)) ) )
1019 strcat(idc_final_download_destination, GNUNET_DIRECTORY_EXT);
1020
1021 addLogEntry(_("Downloading `%s'"), idc_name);
1022 FSUI_startDownload(ctx,
1023 idc->anon,
1024 NO, /* FIXME: isRecursive */
1025 idc_uri,
1026 idc_final_download_destination);
1027 FREE(uri_name);
1028 FREE(dirPath);
1029 FREENONNULL(final_download_dir);
1030#ifdef WINDOWS
1031 FREENONNULL(filehash);
1032#endif
837} 1033}
838 1034
839#if 0 1035void on_downloadButton_clicked_fs(GtkWidget * treeview,
840/** 1036 GtkWidget * downloadButton) {
841 * cron job that periodically updates the model for the 1037 GtkTreeSelection * selection;
842 * namespace selection in the search vbox.
843 */
844static void updateNCBModelSafe(void * unused) {
845 GtkWidget * searchNamespaceCB;
846 GtkListStore * model;
847 GtkTreeIter iter;
848 1038
849 model = gtk_list_store_new(NS_SEARCH_NUM, 1039 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
850 G_TYPE_STRING, /* what we show */ 1040 gtk_tree_selection_selected_foreach
851 G_TYPE_STRING, /* EncName of namespace */ 1041 (selection,
852 G_TYPE_POINTER, 1042 &initiateDownload,
853 G_TYPE_INT); /* Meta-data about namespace */ 1043 NULL);
854 gtk_list_store_append(model,
855 &iter);
856 gtk_list_store_set(model,
857 &iter,
858 NS_SEARCH_DESCRIPTION, _("globally"),
859 NS_SEARCH_ENCNAME, NULL,
860 NS_SEARCH_METADATA, NULL,
861 NS_SEARCH_RATING, 0,
862 -1);
863 NS_listNamespaces(ectx,
864 cfg,
865 NO,
866 &addNamespace,
867 model);
868 searchNamespaceCB
869 = glade_xml_get_widget(getMainXML(),
870 "searchNamespaceComboBoxEntry");
871 gtk_combo_box_set_model(GTK_COMBO_BOX(searchNamespaceCB),
872 GTK_TREE_MODEL(model));
873 if (gtk_combo_box_entry_get_text_column(GTK_COMBO_BOX_ENTRY(searchNamespaceCB)) == -1)
874 gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(searchNamespaceCB),
875 0);
876 if (-1 == gtk_combo_box_get_active(GTK_COMBO_BOX(searchNamespaceCB)))
877 gtk_combo_box_set_active(GTK_COMBO_BOX(searchNamespaceCB),
878 0);
879} 1044}
880 1045
881static void updateNCBModel(void * dummy) { 1046
882 gtkSaveCall(&updateNCBModelSafe, NULL); 1047void on_statusDownloadURIEntry_editing_done_fs(GtkWidget * entry,
1048 GtkWidget * downloadButton) {
1049 struct ECRS_URI * idc_uri;
1050 struct ECRS_MetaData * idc_meta;
1051 const char * idc_name;
1052 const char * idc_mime;
1053 char * idc_final_download_destination;
1054 unsigned int idc_anon;
1055 struct FSUI_SearchList * idc_ret;
1056 const char * uris;
1057 char * urid;
1058 GtkWidget * spin;
1059 char * final_download_dir;
1060 const char * dname;
1061 DownloadList * list;
1062 GtkTreeIter iiter;
1063 char * size_h;
1064
1065 uris = gtk_entry_get_text(GTK_ENTRY(entry));
1066 urid = STRDUP(uris);
1067 gtk_entry_set_text(GTK_ENTRY(entry),
1068 ECRS_URI_PREFIX);
1069 idc_uri = ECRS_stringToUri(ectx, urid);
1070 if (idc_uri == NULL) {
1071 addLogEntry(_("Invalid URI `%s'"), urid);
1072 FREE(urid);
1073 return;
1074 }
1075 if (ECRS_isKeywordUri(idc_uri)) {
1076 addLogEntry(_("Please use the search function for keyword (KSK) URIs!"));
1077 FREE(urid);
1078 ECRS_freeUri(idc_uri);
1079 return;
1080 } else if (ECRS_isLocationUri(idc_uri)) {
1081 addLogEntry(_("Location URIs are not yet supported"));
1082 FREE(urid);
1083 ECRS_freeUri(idc_uri);
1084 return;
1085 }
1086 GC_get_configuration_value_filename(cfg,
1087 "FS",
1088 "INCOMINGDIR",
1089 "$HOME/gnunet-downloads/",
1090 &final_download_dir);
1091 disk_directory_create(ectx, final_download_dir);
1092 dname = &uris[strlen(ECRS_URI_PREFIX) + strlen(ECRS_FILE_INFIX)];
1093 idc_final_download_destination = MALLOC(strlen(final_download_dir) + strlen(dname) + 2);
1094 strcpy(idc_final_download_destination, final_download_dir);
1095 FREE(final_download_dir);
1096 if (idc_final_download_destination[strlen(idc_final_download_destination)] != DIR_SEPARATOR)
1097 strcat(idc_final_download_destination, DIR_SEPARATOR_STR);
1098 strcat(idc_final_download_destination, dname);
1099
1100 /* setup visualization */
1101 list = MALLOC(sizeof(DownloadList));
1102 list->next = download_head;
1103 list->rr = NULL;
1104 list->model = NULL;
1105 list->uri = idc_uri;
1106 list->filename = idc_final_download_destination;
1107 list->finalName = STRDUP(idc_final_download_destination);
1108 download_head = list;
1109 size_h = string_get_fancy_byte_size(ECRS_fileSize(idc_uri));
1110 gtk_tree_store_insert(download_summary,
1111 &iiter,
1112 NULL,
1113 0);
1114 gtk_tree_store_set(download_summary,
1115 &iiter,
1116 DOWNLOAD_FILENAME, idc_final_download_destination,
1117 DOWNLOAD_SHORTNAME, uris,
1118 DOWNLOAD_SIZE, ECRS_fileSize(idc_uri),
1119 DOWNLOAD_HSIZE, size_h,
1120 DOWNLOAD_PROGRESS, 0, /* progress */
1121 DOWNLOAD_URISTRING, uris,
1122 DOWNLOAD_URI, ECRS_dupUri(idc_uri),
1123 DOWNLOAD_TREEPATH, NULL, /* internal: row reference! */
1124 DOWNLOAD_DIRPATH, "",
1125 -1);
1126 FREE(size_h);
1127 /* get anonymity level */
1128 spin = glade_xml_get_widget(getMainXML(),
1129 "fsstatusAnonymitySpin");
1130 if (spin == NULL) {
1131 GE_BREAK(ectx, 0);
1132 idc_anon = 1;
1133 } else {
1134 idc_anon = gtk_spin_button_get_value_as_int
1135 (GTK_SPIN_BUTTON(spin));
1136 }
1137 addLogEntry(_("Downloading `%s'"), uris);
1138 FSUI_startDownload(ctx,
1139 idc_anon,
1140 NO, /* FIXME: isRecursive */
1141 idc_uri,
1142 idc_final_download_destination);
1143 FREE(urid);
883} 1144}
884#endif
885 1145
886 1146
887/** 1147void fs_download_update(struct DL * downloadContext,
888 * Open a tab for the given search 1148 unsigned long long completed,
889 * (and display the results). 1149 const char * data,
890 */ 1150 unsigned int size) {
891int openTabForSearch(struct FSUI_SearchList * slist,
892 const struct ECRS_URI * uri,
893 unsigned int anonymityLevel,
894 unsigned int resultCount,
895 const ECRS_FileInfo * results) {
896 SearchList * list;
897 char * description;
898 char * dhead;
899 GtkWidget * label;
900 GtkWidget * spin;
901 GtkWidget * notebook;
902 GtkTreeStore * model;
903 GtkTreeIter iter; 1151 GtkTreeIter iter;
904 int i; 1152 unsigned int val;
905 unsigned int *file_count; 1153 unsigned long long total;
906 GtkWidget *tab_label; 1154 struct ECRS_URI * u;
907 char * tab_title; 1155 struct ECRS_MetaData * meta;
908 char * new_title;
909 1156
910 DEBUG_BEGIN(); 1157 DEBUG_BEGIN();
911 description = ECRS_uriToString(uri); 1158 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(download_summary),
912 if (description == NULL) { 1159 &iter)) {
913 GE_BREAK(ectx, 0); 1160 do {
914 return SYSERR; 1161 gtk_tree_model_get(GTK_TREE_MODEL(download_summary),
1162 &iter,
1163 DOWNLOAD_SIZE, &total,
1164 DOWNLOAD_URI, &u,
1165 -1);
1166 if (u == NULL)
1167 return;
1168 if (ECRS_equalsUri(u, uri)) {
1169 if (total != 0)
1170 val = completed * 100 / total;
1171 else
1172 val = 100;
1173 gtk_tree_store_set(download_summary,
1174 &iter,
1175 DOWNLOAD_PROGRESS, val,
1176 -1);
1177 break;
1178 }
1179 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(download_summary),
1180 &iter));
915 } 1181 }
916 GE_ASSERT(ectx, 1182 meta = NULL;
917 strlen(description) >= strlen(ECRS_URI_PREFIX)); 1183 ECRS_listDirectory(ectx,
918 dhead = &description[strlen(ECRS_URI_PREFIX)]; 1184 data,
919 if (0 == strncmp(dhead, 1185 size,
920 ECRS_SEARCH_INFIX, 1186 &meta,
921 strlen(ECRS_SEARCH_INFIX))) 1187 &addFilesToDirectory,
922 dhead = &dhead[strlen(ECRS_SEARCH_INFIX)]; 1188 (void*)uri);
923 else if (0 == strncmp(dhead, 1189 if (meta != NULL)
924 ECRS_SUBSPACE_INFIX, 1190 ECRS_freeMetaData(meta);
925 strlen(ECRS_SUBSPACE_INFIX))) 1191 DEBUG_END();
926 dhead = &dhead[strlen(ECRS_SUBSPACE_INFIX)]; 1192}
927 1193
928 gtk_list_store_append(summary, 1194void fs_download_completed(struct DL * downloadContext) {
929 &iter); 1195 unsigned long long size;
930 gtk_list_store_set(summary, 1196 char * data;
931 &iter, 1197 int fd;
932 SER_SUM_NAME, dhead, 1198 struct ECRS_MetaData * meta;
933 SER_SUM_COUNT, resultCount, 1199 DownloadList * pos;
934 SER_SUM_URI, ECRS_dupUri(uri),
935 -1);
936 1200
937 list = MALLOC(sizeof(SearchList)); 1201 DEBUG_BEGIN();
938 list->uri = ECRS_dupUri(uri); 1202 GE_LOG(ectx,
939 list->next = head; 1203 GE_STATUS | GE_USER | GE_BULK,
940 list->searchpage 1204 _("Download '%s' complete.\n"),
941 = makeResultFrame(&list->treeview, 1205 filename);
942 &spin); 1206 pos = download_head;
943 list->anonymityButton 1207 while (pos != NULL) {
944 = spin; 1208 if (ECRS_equalsUri(uri,
945 model = GTK_TREE_STORE 1209 pos->uri))
946 (gtk_tree_view_get_model 1210 break;
947 (GTK_TREE_VIEW(list->treeview))); 1211 pos = pos->next;
948 list->model 1212 }
949 = GTK_TREE_MODEL(model); 1213
950 notebook 1214 /* Not available for resumed downloads */
951 = glade_xml_get_widget(getMainXML(), 1215 if (pos != NULL) {
952 "downloadNotebook"); 1216 if ( (pos->rr != NULL) &&
953 label = buildSearchTabLabel(list->searchpage, dhead); 1217 (gtk_tree_row_reference_valid(pos->rr)) ) {
954 FREE(description); 1218 /* update directory view (if applicable!) */
955 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), 1219 if (OK == disk_file_size(ectx,
956 list->searchpage, 1220 filename,
957 label); 1221 &size,
958 gtk_widget_show(notebook); 1222 YES)) {
959 head = list; 1223 GE_LOG(ectx,
960 for (i=0;i<resultCount;i++) { 1224 GE_DEBUG,
961 addSearchResultToModel(&results[i], 1225 "Updating directory view of '%s'\n",
962 list->treeview, 1226 filename);
963 NULL); 1227
1228 meta = NULL;
1229 fd = disk_file_open(ectx,
1230 filename,
1231 O_RDONLY);
1232 if (fd != -1) {
1233 data = MMAP(NULL,
1234 size,
1235 PROT_READ,
1236 MAP_SHARED,
1237 fd,
1238 0);
1239 if (data == MAP_FAILED) {
1240 GE_LOG_STRERROR_FILE(ectx,
1241 GE_ERROR | GE_ADMIN | GE_BULK,
1242 "mmap",
1243 filename);
1244 } else {
1245 if (data != NULL) {
1246 ECRS_listDirectory(ectx,
1247 data,
1248 size,
1249 &meta,
1250 &addFilesToDirectory,
1251 (void*)uri);
1252 MUNMAP(data, size);
1253 }
1254 }
1255 CLOSE(fd);
1256 }
1257 if (meta != NULL)
1258 ECRS_freeMetaData(meta);
1259 }
1260 }
964 } 1261 }
1262 DEBUG_END();
1263}
965 1264
966 /* update tab title with the number of results */ 1265void fs_download_stopped(struct DL * downloadContext) {
967 file_count = (unsigned int *) 1266 GtkTreeIter iter;
968 g_object_get_data(G_OBJECT(list->searchpage), "file_count"); 1267 char * f;
969 (*file_count) = resultCount; 1268 char * fn;
970 tab_label = (GtkWidget *) 1269 struct ECRS_URI * u;
971 g_object_get_data(G_OBJECT(list->searchpage), "label");
972 tab_title = (char *)
973 g_object_get_data(G_OBJECT(list->searchpage), "title");
974 new_title =
975 g_strdup_printf("%s%s%u%s", tab_title, " (", *file_count, ")");
976 gtk_label_set(GTK_LABEL(tab_label), new_title);
977 FREE(new_title);
978 1270
1271 DEBUG_BEGIN();
1272 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(download_summary),
1273 &iter)) {
1274 do {
1275 gtk_tree_model_get(GTK_TREE_MODEL(download_summary),
1276 &iter,
1277 DOWNLOAD_FILENAME, &f,
1278 DOWNLOAD_URI, &u,
1279 -1);
1280
1281 f = strrchr(f, DIR_SEPARATOR);
1282 fn = strrchr(filename, DIR_SEPARATOR);
1283
1284 if ( (ECRS_equalsUri(u, uri)) &&
1285 (0 == strcmp(f, fn)) ) {
1286 gtk_tree_store_remove(download_summary,
1287 &iter);
1288 break;
1289 }
1290 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(download_summary),
1291 &iter));
1292 }
979 DEBUG_END(); 1293 DEBUG_END();
980 return OK; 1294 return OK;
981} 1295}
982 1296
983void fs_search_start(struct GE_Context * e, 1297void on_clearCompletedDownloadsButton_clicked_fs(void * unused,
984 struct GC_Configuration * c) { 1298 GtkWidget * clearButton) {
985 GtkWidget * searchCB; 1299 /* FIXME */
986 GtkWidget * searchList; 1300}
987 GtkListStore * model;
988 GtkCellRenderer * renderer;
989 GtkTreeViewColumn * column;
990 int col;
991
992 ectx = e;
993 cfg = c;
994 DEBUG_BEGIN();
995 searchCB
996 = glade_xml_get_widget(getMainXML(),
997 "fssearchKeywordComboBoxEntry");
998 1301
999 model = gtk_list_store_new(NS_SEARCH_NUM, 1302static void abortDownloadCallback(GtkTreeModel * model,
1000 G_TYPE_STRING, /* what we show */ 1303 GtkTreePath * path,
1001 G_TYPE_STRING, /* EncName of namespace */ 1304 GtkTreeIter * iter,
1002 G_TYPE_POINTER, /* ECRS MetaData */ 1305 GtkTreeStore * tree) {
1003 G_TYPE_POINTER, /* FSUI search list */ 1306 struct DL * dl;
1004 G_TYPE_INT); /* Meta-data about namespace */ 1307
1005 gtk_combo_box_set_model(GTK_COMBO_BOX(searchCB), 1308 GE_ASSERT(ectx, model == GTK_TREE_MODEL(download_summary));
1006 GTK_TREE_MODEL(model)); 1309 gtk_tree_model_get(model,
1007 gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(searchCB), 1310 iter,
1008 NS_SEARCH_DESCRIPTION); 1311 DOWNLOAD_POS, &dl,
1009 searchList = glade_xml_get_widget(getMainXML(), 1312 -1);
1010 "activeSearchesSummary"); 1313 FSUI_abortDownload(ctx,
1011 summary = 1314 dl->fsui_list);
1012 gtk_list_store_new(SER_SUM_NUM,
1013 G_TYPE_STRING, /* name */
1014 G_TYPE_INT, /* # results */
1015 G_TYPE_POINTER, /* internal: FSUI search list */
1016 G_TYPE_POINTER); /* internal: uri */
1017 gtk_tree_view_set_model(GTK_TREE_VIEW(searchList),
1018 GTK_TREE_MODEL(summary));
1019 renderer = gtk_cell_renderer_text_new();
1020 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(searchList),
1021 -1,
1022 _("Query"),
1023 renderer,
1024 "text", SER_SUM_NAME,
1025 NULL);
1026 column = gtk_tree_view_get_column(GTK_TREE_VIEW(searchList),
1027 col - 1);
1028 gtk_tree_view_column_set_resizable(column, TRUE);
1029 gtk_tree_view_column_set_clickable(column, TRUE);
1030 gtk_tree_view_column_set_reorderable(column, TRUE);
1031 gtk_tree_view_column_set_sort_column_id(column, SER_SUM_NAME);
1032 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(searchList),
1033 col - 1),
1034 TRUE);
1035 renderer = gtk_cell_renderer_text_new();
1036 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(searchList),
1037 -1,
1038 _("Results"),
1039 renderer,
1040 "text", SER_SUM_COUNT,
1041 NULL);
1042 column = gtk_tree_view_get_column(GTK_TREE_VIEW(searchList),
1043 col - 1);
1044 gtk_tree_view_column_set_resizable(column, TRUE);
1045 gtk_tree_view_column_set_clickable(column, TRUE);
1046 gtk_tree_view_column_set_reorderable(column, TRUE);
1047 gtk_tree_view_column_set_sort_column_id(column, SER_SUM_COUNT);
1048 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(searchList),
1049 col - 1),
1050 TRUE);
1051 DEBUG_END();
1052} 1315}
1053 1316
1054void fs_search_stop() { 1317void on_abortDownloadButton_clicked_fs(void * unused,
1318 GtkWidget * clearButton) {
1319 GtkTreeSelection * selection;
1320 GtkWidget * downloadList;
1321
1322 DEBUG_BEGIN();
1323 downloadList = glade_xml_get_widget(getMainXML(),
1324 "activeDownloadsList");
1325 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(downloadList));
1326 gtk_tree_selection_selected_foreach
1327 (selection,
1328 &abortDownloadCallback,
1329 NULL);
1330 DEBUG_END();
1055} 1331}
1056 1332
1057 1333
1334struct DL *
1335fs_download_started(struct FSUI_DownloadList * fsui_dl,
1336 unsigned long long total,
1337 unsigned int anonymityLevel,
1338 const struct ECRS_FileInfo * fi,
1339 const char * filename,
1340 unsigned long long completed,
1341 cron_t eta) {
1342 GtkTreeIter iiter;
1343 int progress;
1344 char * uriname;
1345 const char * sname;
1346 char * size_h;
1347 struct DL * list;
1348
1349 DEBUG_BEGIN();
1350 if (filesize != 0)
1351 progress = bytesCompleted * 100 / filesize;
1352 else
1353 progress = 100;
1354 uriname = ECRS_uriToString(uri);
1355 gtk_tree_store_insert(download_summary,
1356 &iiter,
1357 NULL,
1358 0);
1359 sname = &filename[strlen(filename)-1];
1360 while ( (sname > filename) &&
1361 (sname[-1] != '/') &&
1362 (sname[-1] != '\\') )
1363 sname--;
1364 size_h = string_get_fancy_byte_size(filesize);
1365 gtk_tree_store_set(download_summary,
1366 &iiter,
1367 DOWNLOAD_FILENAME, filename,
1368 DOWNLOAD_SHORTNAME, sname,
1369 DOWNLOAD_SIZE, filesize,
1370 DOWNLOAD_HSIZE, size_h,
1371 DOWNLOAD_PROGRESS, progress,
1372 DOWNLOAD_URISTRING, uriname,
1373 DOWNLOAD_URI, ECRS_dupUri(uri),
1374 DOWNLOAD_TREEPATH, NULL,
1375 DOWNLOAD_POS, list,
1376 -1);
1377 FREE(size_h);
1378 FREE(uriname);
1379 DEBUG_END();
1380 return list;
1381}
1058 1382
1059/* end of search.c */ 1383/* end of search.c */
diff --git a/src/plugins/fs/search.h b/src/plugins/fs/search.h
index ac0df7ee..f3678982 100644
--- a/src/plugins/fs/search.h
+++ b/src/plugins/fs/search.h
@@ -30,24 +30,29 @@
30#include <GNUnet/gnunet_ecrs_lib.h> 30#include <GNUnet/gnunet_ecrs_lib.h>
31#include <GNUnet/gnunet_fsui_lib.h> 31#include <GNUnet/gnunet_fsui_lib.h>
32 32
33void * fs_download_started(void * downloadContext, 33struct SL;
34 unsigned long long total, 34
35 unsigned int anonymityLevel, 35struct DL;
36 const struct ECRS_URI * uri, 36
37 const char * filename, 37struct DL *
38 unsigned long long completed, 38fs_download_started(struct FSUI_DownloadList * fsui_dl,
39 cron_t eta); 39 unsigned long long total,
40 40 unsigned int anonymityLevel,
41void fs_download_update(void * downloadContext, 41 const struct ECRS_FileInfo * fi,
42 const char * filename,
43 unsigned long long completed,
44 cron_t eta);
45
46void fs_download_update(struct DL * downloadContext,
42 unsigned long long completed, 47 unsigned long long completed,
43 const char * data, 48 const char * data,
44 unsigned int size); 49 unsigned int size);
45 50
46void fs_download_completed(void * downloadContext); 51void fs_download_completed(struct DL * downloadContext);
47 52
48void fs_download_aborted(void * downloadContext); 53void fs_download_aborted(struct DL * downloadContext);
49 54
50void fs_download_stopped(void * downloadContext); 55void fs_download_stopped(struct DL * downloadContext);
51 56
52 57
53/** 58/**
@@ -58,7 +63,7 @@ void fs_download_stopped(void * downloadContext);
58 * @param path the tree path that selects where to add 63 * @param path the tree path that selects where to add
59 * the information, NULL for top-level 64 * the information, NULL for top-level
60 */ 65 */
61void fs_search_result_received(void * searchContext, 66void fs_search_result_received(struct SL * searchContext,
62 const ECRS_FileInfo * info, 67 const ECRS_FileInfo * info,
63 const struct ECRS_URI * uri); 68 const struct ECRS_URI * uri);
64 69
@@ -67,21 +72,22 @@ void fs_search_result_received(void * searchContext,
67 * 72 *
68 * @return internal search context 73 * @return internal search context
69 */ 74 */
70void * fs_search_started(struct FSUI_SearchList * list, 75struct SL *
71 const struct ECRS_URI * uri, 76fs_search_started(struct FSUI_SearchList * list,
72 unsigned int anonymityLevel, 77 const struct ECRS_URI * uri,
73 unsigned int resultCount, 78 unsigned int anonymityLevel,
74 const ECRS_FileInfo * results); 79 unsigned int resultCount,
80 const ECRS_FileInfo * results);
75 81
76/** 82/**
77 * A search process has been aborted. Update display. 83 * A search process has been aborted. Update display.
78 */ 84 */
79void fs_search_aborted(void * searchContext); 85void fs_search_aborted(struct SL * searchContext);
80 86
81/** 87/**
82 * A search process has stopped. Clean up. 88 * A search process has stopped. Clean up.
83 */ 89 */
84void fs_search_stopped(void * searchContext); 90void fs_search_stopped(struct SL * searchContext);
85 91
86 92
87/** 93/**
diff --git a/src/plugins/fs/search_namespace.c b/src/plugins/fs/search_namespace.c
new file mode 100644
index 00000000..22da212d
--- /dev/null
+++ b/src/plugins/fs/search_namespace.c
@@ -0,0 +1,106 @@
1static int addNamespace(void * arg,
2 const char * namespaceName,
3 const HashCode512 * namespaceId,
4 const struct ECRS_MetaData * md,
5 int rating) {
6 GtkListStore * model = arg;
7 GtkTreeIter iter;
8 EncName enc;
9 char * name;
10 struct ECRS_MetaData * dmd;
11 char * desc;
12 size_t n;
13
14 DEBUG_BEGIN();
15 hash2enc(namespaceId,
16 &enc);
17 if (md == NULL) {
18 dmd = NULL;
19 desc = STRDUP("");
20 } else {
21 dmd = ECRS_dupMetaData(md);
22 desc = ECRS_getFirstFromMetaData(md,
23 EXTRACTOR_DESCRIPTION,
24 EXTRACTOR_TITLE,
25 EXTRACTOR_AUTHOR,
26 EXTRACTOR_GENRE,
27 EXTRACTOR_SUBJECT,
28 EXTRACTOR_CREATOR,
29 EXTRACTOR_PRODUCER,
30 EXTRACTOR_GROUP,
31 EXTRACTOR_CREATED_FOR,
32 EXTRACTOR_SUMMARY,
33 EXTRACTOR_OWNER,
34 -1);
35 if (desc == NULL)
36 desc = STRDUP("");
37 }
38
39 n = strlen(desc) + 64;
40 name = MALLOC(n);
41 SNPRINTF(name,
42 n,
43 "%s: %*.s",
44 desc,
45 20,
46 &enc);
47 gtk_list_store_append(model,
48 &iter);
49 gtk_list_store_set(model,
50 &iter,
51 NS_SEARCH_DESCRIPTION, name,
52 NS_SEARCH_ENCNAME, &enc,
53 NS_SEARCH_METADATA, dmd,
54 NS_SEARCH_RATING, rating,
55 -1);
56 FREE(name);
57 DEBUG_END();
58 return OK;
59}
60
61#if 0
62/**
63 * cron job that periodically updates the model for the
64 * namespace selection in the search vbox.
65 */
66static void updateNCBModelSafe(void * unused) {
67 GtkWidget * searchNamespaceCB;
68 GtkListStore * model;
69 GtkTreeIter iter;
70
71 model = gtk_list_store_new(NS_SEARCH_NUM,
72 G_TYPE_STRING, /* what we show */
73 G_TYPE_STRING, /* EncName of namespace */
74 G_TYPE_POINTER,
75 G_TYPE_INT); /* Meta-data about namespace */
76 gtk_list_store_append(model,
77 &iter);
78 gtk_list_store_set(model,
79 &iter,
80 NS_SEARCH_DESCRIPTION, _("globally"),
81 NS_SEARCH_ENCNAME, NULL,
82 NS_SEARCH_METADATA, NULL,
83 NS_SEARCH_RATING, 0,
84 -1);
85 NS_listNamespaces(ectx,
86 cfg,
87 NO,
88 &addNamespace,
89 model);
90 searchNamespaceCB
91 = glade_xml_get_widget(getMainXML(),
92 "searchNamespaceComboBoxEntry");
93 gtk_combo_box_set_model(GTK_COMBO_BOX(searchNamespaceCB),
94 GTK_TREE_MODEL(model));
95 if (gtk_combo_box_entry_get_text_column(GTK_COMBO_BOX_ENTRY(searchNamespaceCB)) == -1)
96 gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(searchNamespaceCB),
97 0);
98 if (-1 == gtk_combo_box_get_active(GTK_COMBO_BOX(searchNamespaceCB)))
99 gtk_combo_box_set_active(GTK_COMBO_BOX(searchNamespaceCB),
100 0);
101}
102
103static void updateNCBModel(void * dummy) {
104 gtkSaveCall(&updateNCBModelSafe, NULL);
105}
106#endif
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-17 15:55:26 +0000