aboutsummaryrefslogtreecommitdiff
path: root/src/plugins
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins')
-rw-r--r--src/plugins/about/about.c38
-rw-r--r--src/plugins/daemon/daemon.c589
-rw-r--r--src/plugins/fs/collection.c240
-rw-r--r--src/plugins/fs/collection.h2
-rw-r--r--src/plugins/fs/content_tracking.c209
-rw-r--r--src/plugins/fs/content_tracking.h6
-rw-r--r--src/plugins/fs/directory.c173
-rw-r--r--src/plugins/fs/download.c1344
-rw-r--r--src/plugins/fs/download.h41
-rw-r--r--src/plugins/fs/extensions/musicinsert.c1555
-rw-r--r--src/plugins/fs/extensions/musicinsert.h14
-rw-r--r--src/plugins/fs/fs.c1086
-rw-r--r--src/plugins/fs/fs.h104
-rw-r--r--src/plugins/fs/helper.c127
-rw-r--r--src/plugins/fs/helper.h14
-rw-r--r--src/plugins/fs/meta.c887
-rw-r--r--src/plugins/fs/meta.h77
-rw-r--r--src/plugins/fs/namespace.c1586
-rw-r--r--src/plugins/fs/namespace.h13
-rw-r--r--src/plugins/fs/namespace_create.c332
-rw-r--r--src/plugins/fs/namespace_search.c396
-rw-r--r--src/plugins/fs/namespace_search.h9
-rw-r--r--src/plugins/fs/search.c1445
-rw-r--r--src/plugins/fs/search.h30
-rw-r--r--src/plugins/fs/upload.c857
-rw-r--r--src/plugins/fs/upload.h25
-rw-r--r--src/plugins/peers/peers.c562
-rw-r--r--src/plugins/stats/functions.c723
-rw-r--r--src/plugins/stats/functions.h24
-rw-r--r--src/plugins/stats/statistics.c587
30 files changed, 6219 insertions, 6876 deletions
diff --git a/src/plugins/about/about.c b/src/plugins/about/about.c
index 333397e7..c59b5b67 100644
--- a/src/plugins/about/about.c
+++ b/src/plugins/about/about.c
@@ -32,30 +32,26 @@
32/** 32/**
33 * This displays an about window 33 * This displays an about window
34 */ 34 */
35void on_about_clicked_about(GtkWidget *dummy, 35void
36 gpointer data) { 36on_about_clicked_about (GtkWidget * dummy, gpointer data)
37 GtkWidget * ad; 37{
38 GladeXML * axml; 38 GtkWidget *ad;
39 39 GladeXML *axml;
40 axml 40
41 = glade_xml_new(getGladeFileName(), 41 axml = glade_xml_new (getGladeFileName (), "aboutDialog", PACKAGE_NAME);
42 "aboutDialog", 42 ad = glade_xml_get_widget (axml, "aboutDialog");
43 PACKAGE_NAME); 43 gtk_dialog_run (GTK_DIALOG (ad));
44 ad 44 gtk_widget_destroy (ad);
45 = glade_xml_get_widget(axml, 45 g_object_unref (axml);
46 "aboutDialog");
47 gtk_dialog_run(GTK_DIALOG(ad));
48 gtk_widget_destroy(ad);
49 g_object_unref(axml);
50} 46}
51 47
52void init_about() { 48void
53 GtkWidget * tab; 49init_about ()
50{
51 GtkWidget *tab;
54 52
55 tab 53 tab = glade_xml_get_widget (getMainXML (), "aboutButton");
56 = glade_xml_get_widget(getMainXML(), 54 gtk_widget_show (tab);
57 "aboutButton");
58 gtk_widget_show(tab);
59} 55}
60 56
61/* end of about.c */ 57/* end of about.c */
diff --git a/src/plugins/daemon/daemon.c b/src/plugins/daemon/daemon.c
index 1898d979..4b0d20e8 100644
--- a/src/plugins/daemon/daemon.c
+++ b/src/plugins/daemon/daemon.c
@@ -33,367 +33,360 @@
33#include <GNUnet/gnunet_util_network_client.h> 33#include <GNUnet/gnunet_util_network_client.h>
34#include <gtk/gtk.h> 34#include <gtk/gtk.h>
35 35
36static struct CronManager * cron; 36static struct CronManager *cron;
37 37
38static struct GE_Context * ectx; 38static struct GE_Context *ectx;
39 39
40static struct GC_Configuration * cfg; 40static struct GC_Configuration *cfg;
41 41
42/** 42/**
43 * cron job that periodically updates the model for the 43 * cron job that periodically updates the model for the
44 * application list. 44 * application list.
45 */ 45 */
46static void * updateAppModelSafe(void * unused) { 46static void *
47 struct ClientServerConnection * sock; 47updateAppModelSafe (void *unused)
48 GtkWidget * w; 48{
49 GtkListStore * model; 49 struct ClientServerConnection *sock;
50 GtkWidget *w;
51 GtkListStore *model;
50 GtkTreeIter iter; 52 GtkTreeIter iter;
51 char * apps; 53 char *apps;
52 char * next; 54 char *next;
53 char * pos; 55 char *pos;
54 char * desc; 56 char *desc;
55 57
56 model = gtk_list_store_new(2, 58 model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
57 G_TYPE_STRING,
58 G_TYPE_STRING);
59 apps = NULL; 59 apps = NULL;
60 sock = client_connection_create(ectx, cfg); 60 sock = client_connection_create (ectx, cfg);
61 if (sock != NULL) 61 if (sock != NULL)
62 apps = getConfigurationOptionValue(sock, 62 apps = getConfigurationOptionValue (sock, "GNUNETD", "APPLICATIONS");
63 "GNUNETD", 63 if (apps != NULL)
64 "APPLICATIONS"); 64 {
65 if (apps != NULL) { 65 next = apps;
66 next = apps; 66 do
67 do { 67 {
68 while (*next == ' ') 68 while (*next == ' ')
69 next++; 69 next++;
70 pos = next; 70 pos = next;
71 while ( (*next != '\0') && 71 while ((*next != '\0') && (*next != ' '))
72 (*next != ' ') ) 72 next++;
73 next++; 73 if (*next == '\0')
74 if (*next == '\0') { 74 {
75 next = NULL; /* terminate! */ 75 next = NULL; /* terminate! */
76 } else { 76 }
77 *next = '\0'; /* add 0-termination for pos */ 77 else
78 next++; 78 {
79 } 79 *next = '\0'; /* add 0-termination for pos */
80 if (strlen(pos) > 0) { 80 next++;
81 desc 81 }
82 = getConfigurationOptionValue(sock, 82 if (strlen (pos) > 0)
83 "ABOUT", 83 {
84 pos); 84 desc = getConfigurationOptionValue (sock, "ABOUT", pos);
85 85
86 gtk_list_store_append(model, 86 gtk_list_store_append (model, &iter);
87 &iter); 87 gtk_list_store_set (model,
88 gtk_list_store_set(model, 88 &iter,
89 &iter, 89 0, pos, 1, dgettext ("GNUnet", desc), -1);
90 0, pos, 90 FREENONNULL (desc);
91 1, dgettext("GNUnet", desc), 91 }
92 -1); 92 }
93 FREENONNULL(desc); 93 while (next != NULL);
94 } 94 FREE (apps);
95 } while (next != NULL); 95 }
96 FREE(apps); 96 w = glade_xml_get_widget (getMainXML (), "applicationList");
97 } 97 gtk_tree_view_set_model (GTK_TREE_VIEW (w), GTK_TREE_MODEL (model));
98 w = glade_xml_get_widget(getMainXML(), 98 gtk_tree_selection_set_mode (gtk_tree_view_get_selection
99 "applicationList"); 99 (GTK_TREE_VIEW (w)), GTK_SELECTION_NONE);
100 gtk_tree_view_set_model(GTK_TREE_VIEW(w), 100 connection_destroy (sock);
101 GTK_TREE_MODEL(model));
102 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(w)),
103 GTK_SELECTION_NONE);
104 connection_destroy(sock);
105 return NULL; 101 return NULL;
106} 102}
107 103
108static void updateAppModel(void * dummy) { 104static void
109 gtkSaveCall(&updateAppModelSafe, NULL); 105updateAppModel (void *dummy)
106{
107 gtkSaveCall (&updateAppModelSafe, NULL);
110} 108}
111 109
112 110
113static void * doUpdateMenus(void * arg) { 111static void *
114 int ret = *(int*) arg; 112doUpdateMenus (void *arg)
115 static GtkWidget * killEntry = NULL; 113{
116 static GtkWidget * launchEntry = NULL; 114 int ret = *(int *) arg;
117 static GtkWidget * statsEntryYes = NULL; 115 static GtkWidget *killEntry = NULL;
118 static GtkWidget * statsEntryNo = NULL; 116 static GtkWidget *launchEntry = NULL;
119 static GtkWidget * statsEntryError = NULL; 117 static GtkWidget *statsEntryYes = NULL;
120 static GtkWidget * chooser = NULL; 118 static GtkWidget *statsEntryNo = NULL;
119 static GtkWidget *statsEntryError = NULL;
120 static GtkWidget *chooser = NULL;
121 static int once = 1; 121 static int once = 1;
122 static int isLocal; 122 static int isLocal;
123 char * host; 123 char *host;
124 int canStart; 124 int canStart;
125 struct GC_Configuration * dcfg; 125 struct GC_Configuration *dcfg;
126 char * fn; 126 char *fn;
127 char * user; 127 char *user;
128 struct passwd * pws; 128 struct passwd *pws;
129 129
130 if (once) { 130 if (once)
131 once = 0; 131 {
132 killEntry 132 once = 0;
133 = glade_xml_get_widget(getMainXML(), 133 killEntry = glade_xml_get_widget (getMainXML (), "stopDaemon");
134 "stopDaemon"); 134 launchEntry = glade_xml_get_widget (getMainXML (), "startDaemon");
135 launchEntry 135 statsEntryYes = glade_xml_get_widget (getMainXML (), "statusPixmapYes");
136 = glade_xml_get_widget(getMainXML(), 136 statsEntryNo = glade_xml_get_widget (getMainXML (), "statusPixmapNo");
137 "startDaemon"); 137 statsEntryError
138 statsEntryYes 138 = glade_xml_get_widget (getMainXML (), "statusPixmapError");
139 = glade_xml_get_widget(getMainXML(), 139 chooser
140 "statusPixmapYes"); 140 = glade_xml_get_widget (getMainXML (),
141 statsEntryNo 141 "gnunetdconfigFileChooserButton");
142 = glade_xml_get_widget(getMainXML(), 142 GC_get_configuration_value_string (cfg,
143 "statusPixmapNo"); 143 "NETWORK",
144 statsEntryError 144 "HOST", "localhost", &host);
145 = glade_xml_get_widget(getMainXML(), 145 if (strcmp (host, "localhost") == 0)
146 "statusPixmapError"); 146 isLocal = TRUE;
147 chooser 147 else
148 = glade_xml_get_widget(getMainXML(), 148 isLocal = FALSE;
149 "gnunetdconfigFileChooserButton"); 149 FREE (host);
150 GC_get_configuration_value_string(cfg, 150 }
151 "NETWORK", 151 updateAppModelSafe (NULL);
152 "HOST", 152 if (ret == 0)
153 "localhost", 153 {
154 &host); 154 canStart = 0;
155 if (strcmp(host, "localhost")==0) 155 if ((isLocal) &&
156 isLocal = TRUE; 156 (NULL !=
157 else 157 (fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser)))))
158 isLocal = FALSE; 158 {
159 FREE(host); 159 if (disk_file_test (ectx, fn) == YES)
160 } 160 {
161 updateAppModelSafe(NULL); 161 dcfg = GC_create_C_impl ();
162 if (ret == 0) { 162 canStart = 1;
163 canStart = 0; 163 if (0 != GC_parse_configuration (dcfg, fn))
164 if ( (isLocal) && 164 canStart = 0;
165 (NULL != (fn = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(chooser)))) ) { 165 user = NULL;
166 if (disk_file_test(ectx, fn) == YES) { 166 GC_get_configuration_value_string (dcfg,
167 dcfg = GC_create_C_impl(); 167 "GNUNETD",
168 canStart = 1; 168 "USER", "", &user);
169 if (0 != GC_parse_configuration(dcfg, fn)) 169 if (strlen (user) > 0)
170 canStart = 0; 170 {
171 user = NULL;
172 GC_get_configuration_value_string(dcfg,
173 "GNUNETD",
174 "USER",
175 "",
176 &user);
177 if (strlen(user) > 0) {
178#ifndef WINDOWS 171#ifndef WINDOWS
179 if (NULL == (pws = getpwnam(user))) { 172 if (NULL == (pws = getpwnam (user)))
180 canStart = 0; 173 {
181 } else { 174 canStart = 0;
182 if (pws->pw_uid != getuid()) 175 }
183 canStart = (geteuid() == 0); 176 else
184 else 177 {
185 canStart = 1; 178 if (pws->pw_uid != getuid ())
186 } 179 canStart = (geteuid () == 0);
180 else
181 canStart = 1;
182 }
187#else 183#else
188 canStart = 1; 184 canStart = 1;
189#endif 185#endif
190 } 186 }
191 FREE(user); 187 FREE (user);
192 GC_free(dcfg); 188 GC_free (dcfg);
193 } 189 }
194 g_free(fn); 190 g_free (fn);
191 }
192 gtk_widget_hide (statsEntryYes);
193 gtk_widget_set_sensitive (killEntry, FALSE);
194 if (canStart && isLocal)
195 {
196 gtk_widget_set_sensitive (launchEntry, TRUE);
197 gtk_widget_show_all (statsEntryNo);
198 gtk_widget_hide (statsEntryError);
199 }
200 else
201 {
202 gtk_widget_set_sensitive (launchEntry, FALSE);
203 gtk_widget_show_all (statsEntryError);
204 gtk_widget_hide (statsEntryNo);
205 }
195 } 206 }
196 gtk_widget_hide(statsEntryYes); 207 else
197 gtk_widget_set_sensitive(killEntry, FALSE); 208 {
198 if (canStart && isLocal) { 209 gtk_widget_hide (statsEntryNo);
199 gtk_widget_set_sensitive(launchEntry, TRUE); 210 gtk_widget_hide (statsEntryError);
200 gtk_widget_show_all(statsEntryNo); 211 gtk_widget_show_all (statsEntryYes);
201 gtk_widget_hide(statsEntryError); 212 gtk_widget_set_sensitive (killEntry, TRUE);
202 } else { 213 gtk_widget_set_sensitive (launchEntry, FALSE);
203 gtk_widget_set_sensitive(launchEntry, FALSE);
204 gtk_widget_show_all(statsEntryError);
205 gtk_widget_hide(statsEntryNo);
206 } 214 }
207 } else {
208 gtk_widget_hide(statsEntryNo);
209 gtk_widget_hide(statsEntryError);
210 gtk_widget_show_all(statsEntryYes);
211 gtk_widget_set_sensitive(killEntry, TRUE);
212 gtk_widget_set_sensitive(launchEntry, FALSE);
213 }
214 return NULL; 215 return NULL;
215} 216}
216 217
217static void cronCheckDaemon(void * dummy) { 218static void
219cronCheckDaemon (void *dummy)
220{
218 int ret; 221 int ret;
219 222
220 if (OK == connection_test_running(ectx, 223 if (OK == connection_test_running (ectx, cfg))
221 cfg))
222 ret = 1; 224 ret = 1;
223 else 225 else
224 ret = 0; 226 ret = 0;
225 gtkSaveCall(&doUpdateMenus, &ret); 227 gtkSaveCall (&doUpdateMenus, &ret);
226} 228}
227 229
228 230
229/** 231/**
230 * Launch gnunetd w/ checks 232 * Launch gnunetd w/ checks
231 */ 233 */
232void on_startDaemon_clicked_daemon(GtkWidget * widget, 234void
233 gpointer data) { 235on_startDaemon_clicked_daemon (GtkWidget * widget, gpointer data)
234 GtkWidget * launchEntry; 236{
235 GtkWidget * chooser; 237 GtkWidget *launchEntry;
236 char * fn; 238 GtkWidget *chooser;
237 239 char *fn;
238 launchEntry 240
239 = glade_xml_get_widget(getMainXML(), 241 launchEntry = glade_xml_get_widget (getMainXML (), "startDaemon");
240 "startDaemon"); 242 gtk_widget_set_sensitive (launchEntry, FALSE);
241 gtk_widget_set_sensitive(launchEntry, FALSE); 243 if (OK == connection_test_running (ectx, cfg))
242 if (OK == connection_test_running(ectx, 244 {
243 cfg) ) { 245 cronCheckDaemon (NULL);
244 cronCheckDaemon(NULL); 246 return;
245 return; 247 }
246 } else { 248 else
247 addLogEntry(_("Launching gnunetd...")); 249 {
248 chooser 250 addLogEntry (_("Launching gnunetd..."));
249 = glade_xml_get_widget(getMainXML(), 251 chooser
250 "gnunetdconfigFileChooserButton"); 252 = glade_xml_get_widget (getMainXML (),
251 fn = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(chooser)); 253 "gnunetdconfigFileChooserButton");
252 GE_BREAK(ectx, fn != NULL); 254 fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
253 if (SYSERR != os_daemon_start(ectx, 255 GE_BREAK (ectx, fn != NULL);
254 cfg, 256 if (SYSERR != os_daemon_start (ectx, cfg, fn, YES))
255 fn, 257 {
256 YES)) { 258 addLogEntry (_("Launched gnunetd"));
257 addLogEntry(_("Launched gnunetd")); 259 }
258 } else { 260 else
259 addLogEntry(_("Launching gnunetd failed")); 261 {
262 addLogEntry (_("Launching gnunetd failed"));
263 }
264 if (fn != NULL)
265 g_free (fn);
260 } 266 }
261 if (fn != NULL)
262 g_free(fn);
263 }
264} 267}
265 268
266/** 269/**
267 * Kill gnunetd 270 * Kill gnunetd
268 */ 271 */
269void on_stopDaemon_clicked_daemon(GtkWidget * widget, 272void
270 gpointer data) { 273on_stopDaemon_clicked_daemon (GtkWidget * widget, gpointer data)
271 GtkWidget * killEntry = NULL; 274{
272 struct ClientServerConnection * sock; 275 GtkWidget *killEntry = NULL;
273 276 struct ClientServerConnection *sock;
274 killEntry 277
275 = glade_xml_get_widget(getMainXML(), 278 killEntry = glade_xml_get_widget (getMainXML (), "stopDaemon");
276 "stopDaemon"); 279 gtk_widget_set_sensitive (killEntry, FALSE);
277 gtk_widget_set_sensitive(killEntry, FALSE); 280
278 281 if (OK == connection_test_running (ectx, cfg))
279 if (OK == connection_test_running(ectx, 282 {
280 cfg) ) { 283 sock = client_connection_create (ectx, cfg);
281 sock = client_connection_create(ectx, 284 if (OK != connection_request_shutdown (sock))
282 cfg); 285 {
283 if (OK != connection_request_shutdown(sock)) { 286 GtkWidget *dialog;
284 GtkWidget * dialog; 287
285 288 dialog = gtk_message_dialog_new
286 dialog = gtk_message_dialog_new 289 (NULL,
287 (NULL, 290 GTK_DIALOG_MODAL,
288 GTK_DIALOG_MODAL, 291 GTK_MESSAGE_ERROR,
289 GTK_MESSAGE_ERROR, 292 GTK_BUTTONS_CLOSE, _("Error requesting shutdown of gnunetd."));
290 GTK_BUTTONS_CLOSE, 293 gtk_dialog_run (GTK_DIALOG (dialog));
291 _("Error requesting shutdown of gnunetd.")); 294 gtk_widget_destroy (dialog);
292 gtk_dialog_run(GTK_DIALOG(dialog)); 295 }
293 gtk_widget_destroy(dialog); 296 else
294 } else { 297 {
295 addLogEntry(_("Terminating gnunetd...")); 298 addLogEntry (_("Terminating gnunetd..."));
299 }
300 connection_destroy (sock);
296 } 301 }
297 connection_destroy(sock); 302 cronCheckDaemon (NULL);
298 }
299 cronCheckDaemon(NULL);
300} 303}
301 304
302void init_daemon(struct GE_Context * e, 305void
303 struct GC_Configuration * c) { 306init_daemon (struct GE_Context *e, struct GC_Configuration *c)
304 GtkWidget * tab; 307{
305 GtkWidget * apps; 308 GtkWidget *tab;
306 GtkListStore * model; 309 GtkWidget *apps;
307 GtkCellRenderer * renderer; 310 GtkListStore *model;
311 GtkCellRenderer *renderer;
308 int col; 312 int col;
309 char * daemon_config; 313 char *daemon_config;
310 314
311 ectx = e; 315 ectx = e;
312 cfg = c; 316 cfg = c;
313 apps 317 apps = glade_xml_get_widget (getMainXML (), "applicationList");
314 = glade_xml_get_widget(getMainXML(), 318 model = gtk_list_store_new (1, G_TYPE_STRING);
315 "applicationList"); 319 gtk_tree_view_set_model (GTK_TREE_VIEW (apps), GTK_TREE_MODEL (model));
316 model = gtk_list_store_new(1, G_TYPE_STRING); 320 renderer = gtk_cell_renderer_text_new ();
317 gtk_tree_view_set_model(GTK_TREE_VIEW(apps), 321 col = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (apps),
318 GTK_TREE_MODEL(model)); 322 -1,
319 renderer = gtk_cell_renderer_text_new(); 323 _("Application"),
320 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(apps), 324 renderer,
321 -1, 325 "text", 0, NULL);
322 _("Application"), 326 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
323 renderer, 327 (GTK_TREE_VIEW (apps), col - 1), TRUE);
324 "text", 0, 328 renderer = gtk_cell_renderer_text_new ();
325 NULL); 329 col = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (apps),
326 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(apps), 330 -1,
327 col - 1), 331 _("Description"),
328 TRUE); 332 renderer,
329 renderer = gtk_cell_renderer_text_new(); 333 "text", 1, NULL);
330 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(apps), 334 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
331 -1, 335 (GTK_TREE_VIEW (apps), col - 1), TRUE);
332 _("Description"), 336
333 renderer, 337 tab = glade_xml_get_widget (getMainXML (), "daemonScrolledWindow");
334 "text", 1, 338 gtk_widget_show (tab);
335 NULL);
336 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(apps),
337 col - 1),
338 TRUE);
339
340 tab
341 = glade_xml_get_widget(getMainXML(),
342 "daemonScrolledWindow");
343 gtk_widget_show(tab);
344 daemon_config = NULL; 339 daemon_config = NULL;
345 GC_get_configuration_value_filename(cfg, 340 GC_get_configuration_value_filename (cfg,
346 "DAEMON", 341 "DAEMON",
347 "CONFIGFILE", 342 "CONFIGFILE",
348 DEFAULT_DAEMON_CONFIG_FILE, 343 DEFAULT_DAEMON_CONFIG_FILE,
349 &daemon_config); 344 &daemon_config);
350 if (YES == disk_file_test(NULL, daemon_config)) { 345 if (YES == disk_file_test (NULL, daemon_config))
351 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(glade_xml_get_widget(getMainXML(), 346 {
352 "gnunetdconfigFileChooserButton")), 347 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER
353 daemon_config); 348 (glade_xml_get_widget
354 } else { 349 (getMainXML (),
355 addLogEntry(_("Configuration file for GNUnet daemon `%s' does not exist! Run `gnunet-setup -d'."), 350 "gnunetdconfigFileChooserButton")),
356 daemon_config); 351 daemon_config);
357 } 352 }
358 FREE(daemon_config); 353 else
359 354 {
360 cron = gnunet_gtk_get_cron(); 355 addLogEntry (_
361 cron_add_job(cron, 356 ("Configuration file for GNUnet daemon `%s' does not exist! Run `gnunet-setup -d'."),
362 &cronCheckDaemon, 357 daemon_config);
363 0, 358 }
364 15 * cronSECONDS, 359 FREE (daemon_config);
365 NULL); 360
366 cron_add_job(cron, 361 cron = gnunet_gtk_get_cron ();
367 &updateAppModel, 362 cron_add_job (cron, &cronCheckDaemon, 0, 15 * cronSECONDS, NULL);
368 5 * cronMINUTES, 363 cron_add_job (cron,
369 5 * cronMINUTES, 364 &updateAppModel, 5 * cronMINUTES, 5 * cronMINUTES, NULL);
370 NULL);
371} 365}
372 366
373void done_daemon() { 367void
374 cron_del_job(cron, 368done_daemon ()
375 &cronCheckDaemon, 369{
376 15 * cronSECONDS, 370 cron_del_job (cron, &cronCheckDaemon, 15 * cronSECONDS, NULL);
377 NULL); 371 cron_del_job (cron, &updateAppModel, 5 * cronMINUTES, NULL);
378 cron_del_job(cron,
379 &updateAppModel,
380 5 * cronMINUTES,
381 NULL);
382} 372}
383 373
384/** 374/**
385* Launch 'gnunet-setup -d wizard-gtk' with needed rights 375* Launch 'gnunet-setup -d wizard-gtk' with needed rights
386*/ 376*/
387void on_startDaemonConfWizard_clicked_daemon(GtkWidget * widget, 377void
388 gpointer data) { 378on_startDaemonConfWizard_clicked_daemon (GtkWidget * widget, gpointer data)
389 startGNUnetSetup(TRUE); 379{
380 startGNUnetSetup (TRUE);
390} 381}
391 382
392/** 383/**
393* Launch 'gnunet-setup -d gconfig' with needed rights 384* Launch 'gnunet-setup -d gconfig' with needed rights
394*/ 385*/
395void on_startDaemonConfTool_clicked_daemon(GtkWidget * widget, 386void
396 gpointer data) { 387on_startDaemonConfTool_clicked_daemon (GtkWidget * widget, gpointer data)
397 startGNUnetSetup(FALSE); 388{
389 startGNUnetSetup (FALSE);
398} 390}
391
399/* end of daemon.c */ 392/* end of daemon.c */
diff --git a/src/plugins/fs/collection.c b/src/plugins/fs/collection.c
index efcb1b98..05cc566a 100644
--- a/src/plugins/fs/collection.c
+++ b/src/plugins/fs/collection.c
@@ -33,143 +33,133 @@
33#include <GNUnet/gnunet_collection_lib.h> 33#include <GNUnet/gnunet_collection_lib.h>
34#include <extractor.h> 34#include <extractor.h>
35 35
36static GladeXML * metaXML; 36static GladeXML *metaXML;
37 37
38void on_collectionDialogMetaDataAddButton_clicked_fs(gpointer dummy, 38void
39 GtkWidget * uploadButton) { 39on_collectionDialogMetaDataAddButton_clicked_fs (gpointer dummy,
40 handleMetaDataListUpdate(metaXML, 40 GtkWidget * uploadButton)
41 "collectionMetaDataTypeComboBox", 41{
42 "collectionMetaDataValueEntry", 42 handleMetaDataListUpdate (metaXML,
43 "collectionMetaDataTreeView"); 43 "collectionMetaDataTypeComboBox",
44 "collectionMetaDataValueEntry",
45 "collectionMetaDataTreeView");
44} 46}
45 47
46 48
47void createCollection_clicked_fs(GtkWidget * dummy1, 49void
48 GtkWidget * dummy2) { 50createCollection_clicked_fs (GtkWidget * dummy1, GtkWidget * dummy2)
49 const char * collectionName; 51{
50 const char * updateIntervalString; 52 const char *collectionName;
51 GtkWidget * w; 53 const char *updateIntervalString;
52 GtkWidget * nameLine; 54 GtkWidget *w;
53 GtkWidget * dialog; 55 GtkWidget *nameLine;
54 GtkWidget * spin; 56 GtkWidget *dialog;
55 struct ECRS_MetaData * meta; 57 GtkWidget *spin;
56 struct ECRS_URI * root; 58 struct ECRS_MetaData *meta;
59 struct ECRS_URI *root;
57 TIME_T updateInterval; 60 TIME_T updateInterval;
58 61
59 metaXML 62 metaXML
60 = glade_xml_new(getGladeFileName(), 63 = glade_xml_new (getGladeFileName (),
61 "createCollectionDialog", 64 "createCollectionDialog", PACKAGE_NAME);
62 PACKAGE_NAME); 65 connectGladeWithPlugins (metaXML);
63 connectGladeWithPlugins(metaXML); 66 dialog = glade_xml_get_widget (metaXML, "createCollectionDialog");
64 dialog = glade_xml_get_widget(metaXML, 67 createMetaDataListTreeView (metaXML,
65 "createCollectionDialog"); 68 "collectionMetaDataTreeView", NULL, NULL);
66 createMetaDataListTreeView(metaXML, 69 createMetaTypeComboBox (metaXML, "collectionMetaDataTypeComboBox");
67 "collectionMetaDataTreeView", 70 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
68 NULL, 71 if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
69 NULL); 72 {
70 createMetaTypeComboBox(metaXML, 73 updateIntervalString
71 "collectionMetaDataTypeComboBox"); 74 = getEntryLineValue (metaXML,
72 gtk_dialog_set_default_response(GTK_DIALOG(dialog), 75 "collectionUpdateIntervalComboBoxEntry");
73 GTK_RESPONSE_OK); 76 if (0 == strcmp (_("--sporadic update--"), updateIntervalString))
74 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { 77 updateInterval = ECRS_SBLOCK_UPDATE_SPORADIC;
75 updateIntervalString 78 else if (0 == strcmp (_("--no update--"), updateIntervalString))
76 = getEntryLineValue(metaXML, 79 updateInterval = ECRS_SBLOCK_UPDATE_NONE;
77 "collectionUpdateIntervalComboBoxEntry"); 80 else if (OK != parseTime (updateIntervalString, &updateInterval))
78 if (0 == strcmp(_("--sporadic update--"), 81 {
79 updateIntervalString)) 82 gtk_widget_destroy (dialog);
80 updateInterval = ECRS_SBLOCK_UPDATE_SPORADIC; 83 UNREF (metaXML);
81 else if (0 == strcmp(_("--no update--"), 84 metaXML = NULL;
82 updateIntervalString)) 85 dialog = gtk_message_dialog_new
83 updateInterval = ECRS_SBLOCK_UPDATE_NONE; 86 (NULL,
84 else if (OK != parseTime(updateIntervalString, 87 GTK_DIALOG_MODAL,
85 &updateInterval)) { 88 GTK_MESSAGE_ERROR,
86 gtk_widget_destroy(dialog); 89 GTK_BUTTONS_CLOSE, _("Failed to parse given time interval!"));
87 UNREF(metaXML); 90 gtk_dialog_run (GTK_DIALOG (dialog));
88 metaXML = NULL; 91 gtk_widget_destroy (dialog);
89 dialog = gtk_message_dialog_new 92 return;
90 (NULL, 93 }
91 GTK_DIALOG_MODAL, 94 meta = getMetaDataFromList (metaXML,
92 GTK_MESSAGE_ERROR, 95 "collectionMetaDataTreeView", NULL);
93 GTK_BUTTONS_CLOSE, 96 spin = glade_xml_get_widget (metaXML, "collectionAnonymityLevel");
94 _("Failed to parse given time interval!")); 97 nameLine = glade_xml_get_widget (metaXML, "collectionIdentifierEntry");
95 gtk_dialog_run(GTK_DIALOG(dialog)); 98 collectionName = gtk_entry_get_text (GTK_ENTRY (nameLine));
96 gtk_widget_destroy(dialog); 99 root = NULL;
97 return; 100 if (OK == CO_startCollection (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin)), 1000, /* priority */
101 updateInterval, collectionName, meta))
102 {
103 w = glade_xml_get_widget (getMainXML (), "createCollection");
104 gtk_widget_set_sensitive (w, FALSE);
105 w = glade_xml_get_widget (getMainXML (), "deleteCollection");
106 gtk_widget_set_sensitive (w, TRUE);
107 }
108 else
109 {
110 GtkWidget *dialog;
111
112 dialog = gtk_message_dialog_new
113 (NULL,
114 GTK_DIALOG_MODAL,
115 GTK_MESSAGE_ERROR,
116 GTK_BUTTONS_CLOSE,
117 _("Failed to start collection `%s' (consult logs)."),
118 collectionName);
119 gtk_dialog_run (GTK_DIALOG (dialog));
120 gtk_widget_destroy (dialog);
121 }
122 ECRS_freeMetaData (meta);
98 } 123 }
99 meta = getMetaDataFromList(metaXML, 124 gtk_widget_destroy (dialog);
100 "collectionMetaDataTreeView", 125 UNREF (metaXML);
101 NULL);
102 spin = glade_xml_get_widget(metaXML,
103 "collectionAnonymityLevel");
104 nameLine = glade_xml_get_widget(metaXML,
105 "collectionIdentifierEntry");
106 collectionName
107 = gtk_entry_get_text(GTK_ENTRY(nameLine));
108 root = NULL;
109 if (OK == CO_startCollection(gtk_spin_button_get_value_as_int
110 (GTK_SPIN_BUTTON(spin)),
111 1000, /* priority */
112 updateInterval,
113 collectionName,
114 meta)) {
115 w = glade_xml_get_widget(getMainXML(),
116 "createCollection");
117 gtk_widget_set_sensitive(w, FALSE);
118 w = glade_xml_get_widget(getMainXML(),
119 "deleteCollection");
120 gtk_widget_set_sensitive(w, TRUE);
121 } else {
122 GtkWidget * dialog;
123
124 dialog = gtk_message_dialog_new
125 (NULL,
126 GTK_DIALOG_MODAL,
127 GTK_MESSAGE_ERROR,
128 GTK_BUTTONS_CLOSE,
129 _("Failed to start collection `%s' (consult logs)."),
130 collectionName);
131 gtk_dialog_run(GTK_DIALOG(dialog));
132 gtk_widget_destroy(dialog);
133 }
134 ECRS_freeMetaData(meta);
135 }
136 gtk_widget_destroy(dialog);
137 UNREF(metaXML);
138 metaXML = NULL; 126 metaXML = NULL;
139} 127}
140 128
141void deleteCollection_clicked_fs(GtkWidget * dummy1, 129void
142 GtkWidget * dummy2) { 130deleteCollection_clicked_fs (GtkWidget * dummy1, GtkWidget * dummy2)
143 GtkWidget * w; 131{
144 132 GtkWidget *w;
145 if (OK == CO_stopCollection()) { 133
146 w = glade_xml_get_widget(getMainXML(), 134 if (OK == CO_stopCollection ())
147 "createCollection"); 135 {
148 gtk_widget_set_sensitive(w, TRUE); 136 w = glade_xml_get_widget (getMainXML (), "createCollection");
149 w = glade_xml_get_widget(getMainXML(), 137 gtk_widget_set_sensitive (w, TRUE);
150 "deleteCollection"); 138 w = glade_xml_get_widget (getMainXML (), "deleteCollection");
151 gtk_widget_set_sensitive(w, FALSE); 139 gtk_widget_set_sensitive (w, FALSE);
152 infoMessage(NO, 140 infoMessage (NO, _("Collection stopped.\n"));
153 _("Collection stopped.\n")); 141 }
154 } else { 142 else
155 infoMessage(YES, 143 {
156 _("Failed to stop collection (consult logs).\n")); 144 infoMessage (YES, _("Failed to stop collection (consult logs).\n"));
157 } 145 }
158} 146}
159 147
160void fs_collection_start() { 148void
161 GtkWidget * w; 149fs_collection_start ()
162 char * h; 150{
163 151 GtkWidget *w;
164 h = CO_getCollection(); 152 char *h;
165 if (NULL != h) { 153
166 w = glade_xml_get_widget(getMainXML(), 154 h = CO_getCollection ();
167 "createCollection"); 155 if (NULL != h)
168 FREE(h); 156 {
169 } else 157 w = glade_xml_get_widget (getMainXML (), "createCollection");
170 w = glade_xml_get_widget(getMainXML(), 158 FREE (h);
171 "deleteCollection"); 159 }
172 gtk_widget_set_sensitive(w, FALSE); 160 else
161 w = glade_xml_get_widget (getMainXML (), "deleteCollection");
162 gtk_widget_set_sensitive (w, FALSE);
173} 163}
174 164
175/* end of collection.c */ 165/* end of collection.c */
diff --git a/src/plugins/fs/collection.h b/src/plugins/fs/collection.h
index 0e4ba1e7..c236c4dc 100644
--- a/src/plugins/fs/collection.h
+++ b/src/plugins/fs/collection.h
@@ -29,6 +29,6 @@
29 29
30#include <GNUnet/gnunet_util.h> 30#include <GNUnet/gnunet_util.h>
31 31
32void fs_collection_start(void); 32void fs_collection_start (void);
33 33
34#endif 34#endif
diff --git a/src/plugins/fs/content_tracking.c b/src/plugins/fs/content_tracking.c
index 1767432d..d61b343b 100644
--- a/src/plugins/fs/content_tracking.c
+++ b/src/plugins/fs/content_tracking.c
@@ -37,64 +37,62 @@
37#include <GNUnet/gnunet_namespace_lib.h> 37#include <GNUnet/gnunet_namespace_lib.h>
38#include <extractor.h> 38#include <extractor.h>
39 39
40static void * clearContentList(void * mdl) { 40static void *
41 GtkTreeModel * model = GTK_TREE_MODEL(mdl); 41clearContentList (void *mdl)
42 struct ECRS_URI * uri; 42{
43 struct ECRS_MetaData * meta; 43 GtkTreeModel *model = GTK_TREE_MODEL (mdl);
44 struct ECRS_URI *uri;
45 struct ECRS_MetaData *meta;
44 GtkTreeIter iter; 46 GtkTreeIter iter;
45 47
46 DEBUG_BEGIN(); 48 DEBUG_BEGIN ();
47 if (gtk_tree_model_get_iter_first(model, 49 if (gtk_tree_model_get_iter_first (model, &iter))
48 &iter)) { 50 {
49 do { 51 do
50 gtk_tree_model_get(model, 52 {
51 &iter, 53 gtk_tree_model_get (model,
52 NAMESPACE_URI, &uri, 54 &iter,
53 NAMESPACE_META, &meta, 55 NAMESPACE_URI, &uri, NAMESPACE_META, &meta, -1);
54 -1); 56 ECRS_freeUri (uri);
55 ECRS_freeUri(uri); 57 ECRS_freeMetaData (meta);
56 ECRS_freeMetaData(meta); 58 gtk_list_store_set (GTK_LIST_STORE (model),
57 gtk_list_store_set(GTK_LIST_STORE(model), 59 &iter,
58 &iter, 60 NAMESPACE_URI, NULL, NAMESPACE_META, NULL, -1);
59 NAMESPACE_URI, NULL, 61 }
60 NAMESPACE_META, NULL, 62 while (gtk_list_store_remove (GTK_LIST_STORE (model), &iter));
61 -1); 63 }
62 } while (gtk_list_store_remove(GTK_LIST_STORE(model), 64 DEBUG_END ();
63 &iter));
64 }
65 DEBUG_END();
66 return NULL; 65 return NULL;
67} 66}
68 67
69 68
70void on_clearAvailableContentButton_clicked_fs(GtkWidget * dummy1, 69void
71 GtkWidget * dummy2) { 70on_clearAvailableContentButton_clicked_fs (GtkWidget * dummy1,
72 GtkWidget * contentList; 71 GtkWidget * dummy2)
73 GtkTreeModel * model; 72{
74 73 GtkWidget *contentList;
75 DEBUG_BEGIN(); 74 GtkTreeModel *model;
76 contentList 75
77 = glade_xml_get_widget(getMainXML(), 76 DEBUG_BEGIN ();
78 "availableContentList"); 77 contentList = glade_xml_get_widget (getMainXML (), "availableContentList");
79 model 78 model = gtk_tree_view_get_model (GTK_TREE_VIEW (contentList));
80 = gtk_tree_view_get_model(GTK_TREE_VIEW(contentList)); 79 URITRACK_clearTrackedURIS (ectx, cfg);
81 URITRACK_clearTrackedURIS(ectx, 80 gtkSaveCall (&clearContentList, model);
82 cfg); 81 DEBUG_END ();
83 gtkSaveCall(&clearContentList, model);
84 DEBUG_END();
85} 82}
86 83
87void on_trackingCheckButton_toggled_fs(GtkWidget * dummy1, 84void
88 GtkWidget * dummy2) { 85on_trackingCheckButton_toggled_fs (GtkWidget * dummy1, GtkWidget * dummy2)
89 GtkWidget * trackCheckButton; 86{
87 GtkWidget *trackCheckButton;
90 88
91 trackCheckButton 89 trackCheckButton
92 = glade_xml_get_widget(getMainXML(), 90 = glade_xml_get_widget (getMainXML (), "trackingCheckButton");
93 "trackingCheckButton"); 91 URITRACK_trackURIS (ectx,
94 URITRACK_trackURIS(ectx, 92 cfg,
95 cfg, 93 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
96 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(trackCheckButton)) == TRUE ? 94 (trackCheckButton)) ==
97 YES : NO); 95 TRUE ? YES : NO);
98} 96}
99 97
100 98
@@ -104,63 +102,62 @@ void on_trackingCheckButton_toggled_fs(GtkWidget * dummy1,
104 * content model. Check that it is not already 102 * content model. Check that it is not already
105 * present! 103 * present!
106 */ 104 */
107static void * updateView(void * cls) { 105static void *
108 const ECRS_FileInfo * fi = cls; 106updateView (void *cls)
107{
108 const ECRS_FileInfo *fi = cls;
109 GtkTreeIter iter; 109 GtkTreeIter iter;
110 char * filename; 110 char *filename;
111 char * uriString; 111 char *uriString;
112 unsigned long long size; 112 unsigned long long size;
113 char * size_h; 113 char *size_h;
114 GtkWidget * contentList; 114 GtkWidget *contentList;
115 GtkTreeModel * model; 115 GtkTreeModel *model;
116 116
117 contentList 117 contentList = glade_xml_get_widget (getMainXML (), "availableContentList");
118 = glade_xml_get_widget(getMainXML(), 118 model = gtk_tree_view_get_model (GTK_TREE_VIEW (contentList));
119 "availableContentList"); 119 filename = ECRS_getFirstFromMetaData (fi->meta,
120 model 120 EXTRACTOR_FILENAME,
121 = gtk_tree_view_get_model(GTK_TREE_VIEW(contentList)); 121 EXTRACTOR_TITLE,
122 filename = ECRS_getFirstFromMetaData(fi->meta, 122 EXTRACTOR_DESCRIPTION,
123 EXTRACTOR_FILENAME, 123 EXTRACTOR_SUBJECT,
124 EXTRACTOR_TITLE, 124 EXTRACTOR_ARTIST,
125 EXTRACTOR_DESCRIPTION, 125 EXTRACTOR_AUTHOR,
126 EXTRACTOR_SUBJECT, 126 EXTRACTOR_PUBLISHER,
127 EXTRACTOR_ARTIST, 127 EXTRACTOR_CREATOR,
128 EXTRACTOR_AUTHOR, 128 EXTRACTOR_PRODUCER,
129 EXTRACTOR_PUBLISHER, 129 EXTRACTOR_UNKNOWN, -1);
130 EXTRACTOR_CREATOR, 130 if (filename == NULL)
131 EXTRACTOR_PRODUCER, 131 {
132 EXTRACTOR_UNKNOWN, 132 filename = STRDUP (_("no name given"));
133 -1); 133 }
134 if (filename == NULL) { 134 else
135 filename = STRDUP(_("no name given")); 135 {
136 } else { 136 char *dotdot;
137 char * dotdot; 137
138 138 while (NULL != (dotdot = strstr (filename, "..")))
139 while (NULL != (dotdot = strstr(filename, ".."))) 139 dotdot[0] = dotdot[1] = '_';
140 dotdot[0] = dotdot[1] = '_'; 140 filename = validate_utf8 (filename);
141 filename = validate_utf8(filename); 141 }
142 } 142
143 143 if (ECRS_isFileUri (fi->uri))
144 if (ECRS_isFileUri(fi->uri)) 144 size = ECRS_fileSize (fi->uri);
145 size = ECRS_fileSize(fi->uri);
146 else 145 else
147 size = 0; 146 size = 0;
148 uriString = ECRS_uriToString(fi->uri); 147 uriString = ECRS_uriToString (fi->uri);
149 gtk_list_store_append(GTK_LIST_STORE(model), 148 gtk_list_store_append (GTK_LIST_STORE (model), &iter);
150 &iter); 149 size_h = string_get_fancy_byte_size (size);
151 size_h = string_get_fancy_byte_size(size); 150 gtk_list_store_set (GTK_LIST_STORE (model),
152 gtk_list_store_set(GTK_LIST_STORE(model), 151 &iter,
153 &iter, 152 NAMESPACE_FILENAME, filename,
154 NAMESPACE_FILENAME, filename, 153 NAMESPACE_SIZE, size,
155 NAMESPACE_SIZE, size, 154 NAMESPACE_HSIZE, size_h,
156 NAMESPACE_HSIZE, size_h, 155 NAMESPACE_URISTRING, uriString,
157 NAMESPACE_URISTRING, uriString, 156 NAMESPACE_URI, ECRS_dupUri (fi->uri),
158 NAMESPACE_URI, ECRS_dupUri(fi->uri), 157 NAMESPACE_META, ECRS_dupMetaData (fi->meta), -1);
159 NAMESPACE_META, ECRS_dupMetaData(fi->meta), 158 FREE (size_h);
160 -1); 159 FREE (filename);
161 FREE(size_h); 160 FREE (uriString);
162 FREE(filename);
163 FREE(uriString);
164 return NULL; 161 return NULL;
165} 162}
166 163
@@ -169,10 +166,10 @@ static void * updateView(void * cls) {
169 * content model. Check that it is not already 166 * content model. Check that it is not already
170 * present! 167 * present!
171 */ 168 */
172int updateViewSave(const ECRS_FileInfo * fi, 169int
173 const HashCode512 * key, 170updateViewSave (const ECRS_FileInfo * fi,
174 int isRoot, 171 const HashCode512 * key, int isRoot, void *closure)
175 void * closure) { 172{
176 gtkSaveCall(&updateView, (void*) fi); 173 gtkSaveCall (&updateView, (void *) fi);
177 return OK; 174 return OK;
178} 175}
diff --git a/src/plugins/fs/content_tracking.h b/src/plugins/fs/content_tracking.h
index 075810aa..44e7d92b 100644
--- a/src/plugins/fs/content_tracking.h
+++ b/src/plugins/fs/content_tracking.h
@@ -34,9 +34,7 @@
34 * content model. Check that it is not already 34 * content model. Check that it is not already
35 * present! 35 * present!
36 */ 36 */
37int updateViewSave(const ECRS_FileInfo * fi, 37int updateViewSave (const ECRS_FileInfo * fi,
38 const HashCode512 * key, 38 const HashCode512 * key, int isRoot, void *closure);
39 int isRoot,
40 void * closure);
41 39
42#endif 40#endif
diff --git a/src/plugins/fs/directory.c b/src/plugins/fs/directory.c
index ecaf34b8..12ca0bff 100644
--- a/src/plugins/fs/directory.c
+++ b/src/plugins/fs/directory.c
@@ -37,135 +37,114 @@
37 37
38#ifndef MINGW 38#ifndef MINGW
39static char * 39static char *
40selectFile() { 40selectFile ()
41 GladeXML * uploadXML; 41{
42 GtkFileChooser * dialog; 42 GladeXML *uploadXML;
43 char * ret; 43 GtkFileChooser *dialog;
44 char *ret;
44 45
45 uploadXML 46 uploadXML
46 = glade_xml_new(getGladeFileName(), 47 = glade_xml_new (getGladeFileName (),
47 "openDirectoryFileDialog", 48 "openDirectoryFileDialog", PACKAGE_NAME);
48 PACKAGE_NAME); 49 connectGladeWithPlugins (uploadXML);
49 connectGladeWithPlugins(uploadXML); 50 dialog = GTK_FILE_CHOOSER (glade_xml_get_widget (uploadXML,
50 dialog = GTK_FILE_CHOOSER(glade_xml_get_widget(uploadXML, 51 "openDirectoryFileDialog"));
51 "openDirectoryFileDialog")); 52 if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_CANCEL)
52 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL) 53 ret = gtk_file_chooser_get_filename (dialog);
53 ret = gtk_file_chooser_get_filename(dialog);
54 else 54 else
55 ret = NULL; 55 ret = NULL;
56 gtk_widget_destroy(GTK_WIDGET(dialog)); 56 gtk_widget_destroy (GTK_WIDGET (dialog));
57 UNREF(uploadXML); 57 UNREF (uploadXML);
58 return ret; 58 return ret;
59} 59}
60#else /* MINGW */ 60#else /* MINGW */
61static char * 61static char *
62selectFile() { 62selectFile ()
63 return plibc_ChooseFile(_("Choose the directory you want to open."), 63{
64 OFN_FILEMUSTEXIST | OFN_SHAREAWARE); 64 return plibc_ChooseFile (_("Choose the directory you want to open."),
65 OFN_FILEMUSTEXIST | OFN_SHAREAWARE);
65} 66}
66#endif /* MINGW */ 67#endif /* MINGW */
67 68
68static int 69static int
69spcb(const ECRS_FileInfo * fi, 70spcb (const ECRS_FileInfo * fi,
70 const HashCode512 * key, 71 const HashCode512 * key, int isRoot, void *closure)
71 int isRoot, 72{
72 void * closure) { 73 SearchList *list = closure;
73 SearchList * list = closure; 74 fs_search_result_received (list, fi, list->uri);
74 fs_search_result_received(list,
75 fi,
76 list->uri);
77 return OK; 75 return OK;
78} 76}
79 77
80 78
81void on_open_menu_activate_fs(GtkWidget * dummy1, 79void
82 GtkWidget * dummy2) { 80on_open_menu_activate_fs (GtkWidget * dummy1, GtkWidget * dummy2)
83 char * dn; 81{
84 char * directory_data; 82 char *dn;
83 char *directory_data;
85 unsigned long long directory_data_len; 84 unsigned long long directory_data_len;
86 size_t dlen; 85 size_t dlen;
87 struct ECRS_MetaData * md; 86 struct ECRS_MetaData *md;
88 int fd; 87 int fd;
89 SearchList * list; 88 SearchList *list;
90 struct ECRS_URI * uri; 89 struct ECRS_URI *uri;
91 const char * kws[2]; 90 const char *kws[2];
92 GtkNotebook * notebook; 91 GtkNotebook *notebook;
93 92
94 dn = selectFile(); 93 dn = selectFile ();
95 if (dn == NULL) 94 if (dn == NULL)
96 return; 95 return;
97 if ( (YES != disk_file_test(NULL, 96 if ((YES != disk_file_test (NULL,
98 dn)) || 97 dn)) ||
99 (OK != disk_file_size(NULL, 98 (OK != disk_file_size (NULL, dn, &directory_data_len, YES)))
100 dn, 99 {
101 &directory_data_len, 100 addLogEntry (_("Error accessing file `%s'."), dn);
102 YES)) ) { 101 FREE (dn);
103 addLogEntry(_("Error accessing file `%s'."), 102 return;
104 dn); 103 }
105 FREE(dn); 104 fd = disk_file_open (NULL, dn, O_LARGEFILE | O_RDONLY);
106 return; 105 if (fd == -1)
107 } 106 {
108 fd = disk_file_open(NULL, 107 addLogEntry (_("Error opening file `%s'."), dn);
109 dn, 108 FREE (dn);
110 O_LARGEFILE | O_RDONLY); 109 return;
111 if (fd == -1) { 110 }
112 addLogEntry(_("Error opening file `%s'."),
113 dn);
114 FREE(dn);
115 return;
116 }
117 dlen = (size_t) directory_data_len; 111 dlen = (size_t) directory_data_len;
118 directory_data = MMAP(NULL, 112 directory_data = MMAP (NULL, dlen, PROT_READ, MAP_SHARED, fd, 0);
119 dlen, 113 if (directory_data == MAP_FAILED)
120 PROT_READ, 114 {
121 MAP_SHARED, 115 addLogEntry (_("Error mapping file `%s' into memory."), dn);
122 fd, 116 CLOSE (fd);
123 0); 117 FREE (dn);
124 if (directory_data == MAP_FAILED) { 118 return;
125 addLogEntry(_("Error mapping file `%s' into memory."), 119 }
126 dn);
127 CLOSE(fd);
128 FREE(dn);
129 return;
130 }
131 kws[0] = dn; 120 kws[0] = dn;
132 kws[1] = NULL; 121 kws[1] = NULL;
133 uri = ECRS_keywordsToUri(kws); 122 uri = ECRS_keywordsToUri (kws);
134 md = NULL; 123 md = NULL;
135 list = fs_search_started(NULL, 124 list = fs_search_started (NULL, uri, 0, 0, NULL, FSUI_COMPLETED);
136 uri, 125 ECRS_freeUri (uri);
137 0, 126 ECRS_listDirectory (NULL,
138 0, 127 directory_data, directory_data_len, &md, &spcb, list);
139 NULL,
140 FSUI_COMPLETED);
141 ECRS_freeUri(uri);
142 ECRS_listDirectory(NULL,
143 directory_data,
144 directory_data_len,
145 &md,
146 &spcb,
147 list);
148 if (md != NULL) 128 if (md != NULL)
149 ECRS_freeMetaData(md); 129 ECRS_freeMetaData (md);
150 MUNMAP(directory_data, dlen); 130 MUNMAP (directory_data, dlen);
151 CLOSE(fd); 131 CLOSE (fd);
152 FREE(dn); 132 FREE (dn);
153 133
154 /* switch view -- select directory */ 134 /* switch view -- select directory */
155 notebook 135 notebook
156 = GTK_NOTEBOOK(glade_xml_get_widget(getMainXML(), 136 = GTK_NOTEBOOK (glade_xml_get_widget (getMainXML (), "downloadNotebook"));
157 "downloadNotebook")); 137 gtk_notebook_set_current_page (notebook,
158 gtk_notebook_set_current_page(notebook, 138 gtk_notebook_page_num (notebook,
159 gtk_notebook_page_num(notebook, 139 list->searchpage));
160 list->searchpage));
161 140
162 notebook 141 notebook
163 = GTK_NOTEBOOK(glade_xml_get_widget(getMainXML(), 142 = GTK_NOTEBOOK (glade_xml_get_widget (getMainXML (), "fsnotebook"));
164 "fsnotebook")); 143 gtk_notebook_set_current_page (notebook,
165 gtk_notebook_set_current_page(notebook, 144 gtk_notebook_page_num (notebook,
166 gtk_notebook_page_num(notebook, 145 glade_xml_get_widget
167 glade_xml_get_widget(getMainXML(), 146 (getMainXML (),
168 "fsdownloadvbox"))); 147 "fsdownloadvbox")));
169} 148}
170 149
171/* end of directory.c */ 150/* end of directory.c */
diff --git a/src/plugins/fs/download.c b/src/plugins/fs/download.c
index 2d825f71..c58a18e4 100644
--- a/src/plugins/fs/download.c
+++ b/src/plugins/fs/download.c
@@ -39,136 +39,113 @@
39 * by the download list. 39 * by the download list.
40 */ 40 */
41static int 41static int
42addFilesToDirectory(const ECRS_FileInfo * fi, 42addFilesToDirectory (const ECRS_FileInfo * fi,
43 const HashCode512 * key, 43 const HashCode512 * key, int isRoot, void *closure)
44 int isRoot, 44{
45 void * closure) { 45 DownloadList *list = closure;
46 DownloadList * list = closure;
47 GtkTreeIter iter; 46 GtkTreeIter iter;
48 GtkTreeIter child; 47 GtkTreeIter child;
49 int i; 48 int i;
50 GtkTreePath * path; 49 GtkTreePath *path;
51 GtkTreeModel * model; 50 GtkTreeModel *model;
52 51
53 if (isRoot == YES) 52 if (isRoot == YES)
54 return OK; 53 return OK;
55 if (! gtk_tree_row_reference_valid(list->searchViewRowReference)) 54 if (!gtk_tree_row_reference_valid (list->searchViewRowReference))
56 return SYSERR; 55 return SYSERR;
57 model = GTK_TREE_MODEL(list->searchList->tree); 56 model = GTK_TREE_MODEL (list->searchList->tree);
58 path = gtk_tree_row_reference_get_path(list->searchViewRowReference); 57 path = gtk_tree_row_reference_get_path (list->searchViewRowReference);
59 if (path == NULL) { 58 if (path == NULL)
60 GE_BREAK(ectx, 0); 59 {
61 return SYSERR; 60 GE_BREAK (ectx, 0);
62 } 61 return SYSERR;
63 gtk_tree_model_get_iter(model, 62 }
64 &iter, 63 gtk_tree_model_get_iter (model, &iter, path);
65 path); 64 gtk_tree_path_free (path);
66 gtk_tree_path_free(path);
67 /* check for existing entry -- this function maybe called multiple 65 /* check for existing entry -- this function maybe called multiple
68 times for the same directory entry */ 66 times for the same directory entry */
69 for (i=gtk_tree_model_iter_n_children(model, 67 for (i = gtk_tree_model_iter_n_children (model, &iter) - 1; i >= 0; i--)
70 &iter)-1;i>=0;i--) { 68 {
71 if (TRUE == gtk_tree_model_iter_nth_child(model, 69 if (TRUE == gtk_tree_model_iter_nth_child (model, &child, &iter, i))
72 &child, 70 {
73 &iter, 71 struct ECRS_URI *uri;
74 i)) { 72 uri = NULL;
75 struct ECRS_URI * uri; 73 gtk_tree_model_get (model, &child, SEARCH_URI, &uri, -1);
76 uri = NULL; 74 if ((uri != NULL) && (ECRS_equalsUri (uri, fi->uri)))
77 gtk_tree_model_get(model, 75 return OK;
78 &child, 76 }
79 SEARCH_URI, &uri, 77 }
80 -1); 78 gtk_tree_store_append (GTK_TREE_STORE (model), &child, &iter);
81 if ( (uri != NULL) && 79 addEntryToSearchTree (list->searchList, list, fi, &child);
82 (ECRS_equalsUri(uri,
83 fi->uri)) )
84 return OK;
85 }
86 }
87 gtk_tree_store_append(GTK_TREE_STORE(model),
88 &child,
89 &iter);
90 addEntryToSearchTree(list->searchList,
91 list,
92 fi,
93 &child);
94 return OK; 80 return OK;
95} 81}
96 82
97static void 83static void
98refreshDirectoryViewFromDisk(DownloadList * list) { 84refreshDirectoryViewFromDisk (DownloadList * list)
85{
99 unsigned long long size; 86 unsigned long long size;
100 char * data; 87 char *data;
101 int fd; 88 int fd;
102 char * fn; 89 char *fn;
103 struct ECRS_MetaData * meta; 90 struct ECRS_MetaData *meta;
104 struct stat buf; 91 struct stat buf;
105 const char * f; 92 const char *f;
106 93
107 if ( (list->is_directory != YES) || 94 if ((list->is_directory != YES) ||
108 (list->searchList == NULL) || 95 (list->searchList == NULL) ||
109 (list->searchViewRowReference == NULL) || 96 (list->searchViewRowReference == NULL) ||
110 (! gtk_tree_row_reference_valid(list->searchViewRowReference)) ) 97 (!gtk_tree_row_reference_valid (list->searchViewRowReference)))
111 return; 98 return;
112 99
113 if (0 != stat(list->filename, 100 if (0 != stat (list->filename, &buf))
114 &buf))
115 return; 101 return;
116 if (S_ISDIR(buf.st_mode)) { 102 if (S_ISDIR (buf.st_mode))
117 fn = MALLOC(strlen(list->filename) + strlen(GNUNET_DIRECTORY_EXT) + 1); 103 {
118 strcpy(fn, list->filename); 104 fn =
119 if (fn[strlen(fn)-1] == '/') 105 MALLOC (strlen (list->filename) + strlen (GNUNET_DIRECTORY_EXT) + 1);
120 fn[strlen(fn)-1] = '\0'; 106 strcpy (fn, list->filename);
121 strcat(fn, GNUNET_DIRECTORY_EXT); 107 if (fn[strlen (fn) - 1] == '/')
122 if (0 != stat(list->filename, 108 fn[strlen (fn) - 1] = '\0';
123 &buf)) { 109 strcat (fn, GNUNET_DIRECTORY_EXT);
124 FREE(fn); 110 if (0 != stat (list->filename, &buf))
125 return; 111 {
112 FREE (fn);
113 return;
114 }
115 f = fn;
116 }
117 else
118 {
119 fn = NULL;
120 f = list->filename;
126 } 121 }
127 f = fn;
128 } else {
129 fn = NULL;
130 f = list->filename;
131 }
132 size = buf.st_size; 122 size = buf.st_size;
133 if (size == 0) { 123 if (size == 0)
134 FREENONNULL(fn); 124 {
135 return; 125 FREENONNULL (fn);
136 } 126 return;
137 fd = disk_file_open(ectx, 127 }
138 list->filename, 128 fd = disk_file_open (ectx, list->filename, O_RDONLY);
139 O_RDONLY); 129 if (fd == -1)
140 if (fd == -1) { 130 {
141 FREENONNULL(fn); 131 FREENONNULL (fn);
142 return; 132 return;
143 } 133 }
144 data = MMAP(NULL, 134 data = MMAP (NULL, size, PROT_READ, MAP_SHARED, fd, 0);
145 size, 135 if ((data == MAP_FAILED) || (data == NULL))
146 PROT_READ, 136 {
147 MAP_SHARED, 137 GE_LOG_STRERROR_FILE (ectx, GE_ERROR | GE_ADMIN | GE_BULK, "mmap", f);
148 fd, 138 CLOSE (fd);
149 0); 139 FREENONNULL (fn);
150 if ( (data == MAP_FAILED) || 140 return;
151 (data == NULL) ) { 141 }
152 GE_LOG_STRERROR_FILE(ectx, 142 FREENONNULL (fn);
153 GE_ERROR | GE_ADMIN | GE_BULK,
154 "mmap",
155 f);
156 CLOSE(fd);
157 FREENONNULL(fn);
158 return;
159 }
160 FREENONNULL(fn);
161 meta = NULL; 143 meta = NULL;
162 ECRS_listDirectory(ectx, 144 ECRS_listDirectory (ectx, data, size, &meta, &addFilesToDirectory, list);
163 data, 145 MUNMAP (data, size);
164 size, 146 CLOSE (fd);
165 &meta,
166 &addFilesToDirectory,
167 list);
168 MUNMAP(data, size);
169 CLOSE(fd);
170 if (meta != NULL) 147 if (meta != NULL)
171 ECRS_freeMetaData(meta); 148 ECRS_freeMetaData (meta);
172} 149}
173 150
174/** 151/**
@@ -177,162 +154,158 @@ refreshDirectoryViewFromDisk(DownloadList * list) {
177 * the download summary. 154 * the download summary.
178 */ 155 */
179DownloadList * 156DownloadList *
180fs_download_started(struct FSUI_DownloadList * fsui_dl, 157fs_download_started (struct FSUI_DownloadList *fsui_dl,
181 DownloadList * dl_parent, 158 DownloadList * dl_parent,
182 SearchList * sl_parent, 159 SearchList * sl_parent,
183 unsigned long long total, 160 unsigned long long total,
184 unsigned int anonymityLevel, 161 unsigned int anonymityLevel,
185 const ECRS_FileInfo * fi, 162 const ECRS_FileInfo * fi,
186 const char * filename, 163 const char *filename,
187 unsigned long long completed, 164 unsigned long long completed,
188 cron_t eta, 165 cron_t eta, FSUI_State state)
189 FSUI_State state) { 166{
190 DownloadList * list; 167 DownloadList *list;
191 GtkTreeIter iter; 168 GtkTreeIter iter;
192 GtkTreeIter piter; 169 GtkTreeIter piter;
193 GtkTreePath * path; 170 GtkTreePath *path;
194 unsigned long long size; 171 unsigned long long size;
195 char * size_h; 172 char *size_h;
196 const char * sname; 173 const char *sname;
197 int progress; 174 int progress;
198 char * uri_name; 175 char *uri_name;
199 gboolean valid; 176 gboolean valid;
200 struct ECRS_URI * u; 177 struct ECRS_URI *u;
201 GtkTreeModel * model; 178 GtkTreeModel *model;
202 179
203 /* setup visualization */ 180 /* setup visualization */
204 list = MALLOC(sizeof(DownloadList)); 181 list = MALLOC (sizeof (DownloadList));
205 memset(list, 182 memset (list, 0, sizeof (DownloadList));
206 0, 183 list->uri = ECRS_dupUri (fi->uri);
207 sizeof(DownloadList)); 184 list->filename = STRDUP (filename);
208 list->uri = ECRS_dupUri(fi->uri); 185 if ((dl_parent != NULL) &&
209 list->filename = STRDUP(filename); 186 (NULL !=
210 if ( (dl_parent != NULL) && 187 (path =
211 (NULL != (path = gtk_tree_row_reference_get_path(dl_parent->summaryViewRowReference) ) ) ) { 188 gtk_tree_row_reference_get_path (dl_parent->
212 valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(download_summary), 189 summaryViewRowReference))))
213 &piter, 190 {
214 path); 191 valid = gtk_tree_model_get_iter (GTK_TREE_MODEL (download_summary),
215 if (valid) { 192 &piter, path);
216 gtk_tree_store_append(download_summary, 193 if (valid)
217 &iter, 194 {
218 &piter); 195 gtk_tree_store_append (download_summary, &iter, &piter);
219 } else { 196 }
220 gtk_tree_store_append(download_summary, 197 else
221 &iter, 198 {
222 NULL); 199 gtk_tree_store_append (download_summary, &iter, NULL);
223 } 200 }
224 gtk_tree_path_free(path); 201 gtk_tree_path_free (path);
225 } else { 202 }
226 gtk_tree_store_append(download_summary, 203 else
227 &iter, 204 {
228 NULL); 205 gtk_tree_store_append (download_summary, &iter, NULL);
229 } 206 }
230 size = ECRS_fileSize(fi->uri); 207 size = ECRS_fileSize (fi->uri);
231 size_h = string_get_fancy_byte_size(size); 208 size_h = string_get_fancy_byte_size (size);
232 sname = &filename[strlen(filename)-1]; 209 sname = &filename[strlen (filename) - 1];
233 while ( (sname > filename) && 210 while ((sname > filename) && (sname[-1] != '/') && (sname[-1] != '\\'))
234 (sname[-1] != '/') &&
235 (sname[-1] != '\\') )
236 sname--; 211 sname--;
237 if (size != 0) 212 if (size != 0)
238 progress = completed * 100 / size; 213 progress = completed * 100 / size;
239 else 214 else
240 progress = 100; 215 progress = 100;
241 uri_name = ECRS_uriToString(fi->uri); 216 uri_name = ECRS_uriToString (fi->uri);
242 gtk_tree_store_set(download_summary, 217 gtk_tree_store_set (download_summary,
243 &iter, 218 &iter,
244 DOWNLOAD_FILENAME, filename, 219 DOWNLOAD_FILENAME, filename,
245 DOWNLOAD_SHORTNAME, sname, 220 DOWNLOAD_SHORTNAME, sname,
246 DOWNLOAD_SIZE, size, 221 DOWNLOAD_SIZE, size,
247 DOWNLOAD_HSIZE, size_h, 222 DOWNLOAD_HSIZE, size_h,
248 DOWNLOAD_PROGRESS, progress, 223 DOWNLOAD_PROGRESS, progress,
249 DOWNLOAD_URISTRING, uri_name, 224 DOWNLOAD_URISTRING, uri_name,
250 DOWNLOAD_INTERNAL, list, 225 DOWNLOAD_INTERNAL, list, -1);
251 -1); 226 FREE (uri_name);
252 FREE(uri_name); 227 FREE (size_h);
253 FREE(size_h); 228 path = gtk_tree_model_get_path (GTK_TREE_MODEL (download_summary), &iter);
254 path = gtk_tree_model_get_path(GTK_TREE_MODEL(download_summary),
255 &iter);
256 list->summaryViewRowReference 229 list->summaryViewRowReference
257 = gtk_tree_row_reference_new(GTK_TREE_MODEL(download_summary), 230 = gtk_tree_row_reference_new (GTK_TREE_MODEL (download_summary), path);
258 path); 231 gtk_tree_path_free (path);
259 gtk_tree_path_free(path);
260 list->searchList = sl_parent; 232 list->searchList = sl_parent;
261 list->searchViewRowReference = NULL; 233 list->searchViewRowReference = NULL;
262 if (sl_parent != NULL) { 234 if (sl_parent != NULL)
263 model = GTK_TREE_MODEL(sl_parent->tree); 235 {
264 if (dl_parent != NULL) { 236 model = GTK_TREE_MODEL (sl_parent->tree);
265 /* have parent, must be download from 237 if (dl_parent != NULL)
266 directory inside of search */ 238 {
267 /* FIXME: this requires GTK 2.8. Since it doesn't support Win9x, the quick 239 /* have parent, must be download from
268 solution is to #ifndef it */ 240 directory inside of search */
241 /* FIXME: this requires GTK 2.8. Since it doesn't support Win9x, the quick
242 solution is to #ifndef it */
269#ifndef MINGW 243#ifndef MINGW
270 GE_BREAK(ectx, 244 GE_BREAK (ectx,
271 gtk_tree_row_reference_get_model(dl_parent->searchViewRowReference) 245 gtk_tree_row_reference_get_model (dl_parent->
272 == model); 246 searchViewRowReference)
247 == model);
273#endif 248#endif
274 path = gtk_tree_row_reference_get_path(dl_parent->searchViewRowReference); 249 path =
275 if (path != NULL) { 250 gtk_tree_row_reference_get_path (dl_parent->
276 valid = gtk_tree_model_get_iter(model, 251 searchViewRowReference);
277 &piter, 252 if (path != NULL)
278 path); 253 {
279 GE_BREAK(ectx, valid == TRUE); 254 valid = gtk_tree_model_get_iter (model, &piter, path);
280 if (valid == TRUE) { 255 GE_BREAK (ectx, valid == TRUE);
281 valid = gtk_tree_model_iter_children(model, 256 if (valid == TRUE)
282 &iter, 257 {
283 &piter); 258 valid = gtk_tree_model_iter_children (model, &iter, &piter);
284 GE_BREAK(ectx, valid == TRUE); 259 GE_BREAK (ectx, valid == TRUE);
285 } 260 }
286 } else { 261 }
287 GE_BREAK(ectx, 0); 262 else
288 valid = FALSE; 263 {
289 } 264 GE_BREAK (ectx, 0);
290 } else { 265 valid = FALSE;
291 /* no download-parent, must be top-level entry in search */ 266 }
292 valid = gtk_tree_model_get_iter_first(model, 267 }
293 &iter); 268 else
294 GE_BREAK(ectx, valid == TRUE); 269 {
295 } 270 /* no download-parent, must be top-level entry in search */
296 while (valid == TRUE) { 271 valid = gtk_tree_model_get_iter_first (model, &iter);
297 /* find matching entry */ 272 GE_BREAK (ectx, valid == TRUE);
298 gtk_tree_model_get(model, 273 }
299 &iter, 274 while (valid == TRUE)
300 SEARCH_URI, &u, 275 {
301 -1); 276 /* find matching entry */
302 if (ECRS_equalsUri(u, 277 gtk_tree_model_get (model, &iter, SEARCH_URI, &u, -1);
303 fi->uri)) { 278 if (ECRS_equalsUri (u, fi->uri))
304 path = gtk_tree_model_get_path(model, 279 {
305 &iter); 280 path = gtk_tree_model_get_path (model, &iter);
306 list->searchViewRowReference 281 list->searchViewRowReference
307 = gtk_tree_row_reference_new(model, 282 = gtk_tree_row_reference_new (model, path);
308 path); 283 gtk_tree_path_free (path);
309 gtk_tree_path_free(path); 284 gtk_tree_store_set (sl_parent->tree,
310 gtk_tree_store_set(sl_parent->tree, 285 &iter,
311 &iter, 286 SEARCH_CELL_BG_COLOR,
312 SEARCH_CELL_BG_COLOR, getColorCode(URITRACK_DOWNLOAD_STARTED), 287 getColorCode (URITRACK_DOWNLOAD_STARTED),
313 -1); 288 -1);
314 break; 289 break;
315 } 290 }
316 valid = gtk_tree_model_iter_next(model, 291 valid = gtk_tree_model_iter_next (model, &iter);
317 &iter); 292 }
318 } 293 if (valid == FALSE)
319 if (valid == FALSE) { 294 {
320 /* did not find matching entry in search list -- bug! Continue 295 /* did not find matching entry in search list -- bug! Continue
321 without adding to to search list! */ 296 without adding to to search list! */
322 GE_BREAK(ectx, 0); 297 GE_BREAK (ectx, 0);
323 list->searchList = NULL; 298 list->searchList = NULL;
324 } 299 }
325 } 300 }
326 list->fsui_list = fsui_dl; 301 list->fsui_list = fsui_dl;
327 list->total = total; 302 list->total = total;
328 list->is_directory = ECRS_isDirectory(fi->meta); 303 list->is_directory = ECRS_isDirectory (fi->meta);
329 list->has_terminated = ( (state != FSUI_ACTIVE) && 304 list->has_terminated = ((state != FSUI_ACTIVE) && (state != FSUI_PENDING));
330 (state != FSUI_PENDING) );
331 list->next = download_head; 305 list->next = download_head;
332 download_head = list; 306 download_head = list;
333 if ( (list->is_directory == YES) && 307 if ((list->is_directory == YES) && (completed != 0))
334 (completed != 0) ) 308 refreshDirectoryViewFromDisk (list);
335 refreshDirectoryViewFromDisk(list);
336 return list; 309 return list;
337} 310}
338 311
@@ -341,158 +314,166 @@ fs_download_started(struct FSUI_DownloadList * fsui_dl,
341 * summary and the preview of the directory 314 * summary and the preview of the directory
342 * contents in the search page (if applicable). 315 * contents in the search page (if applicable).
343 */ 316 */
344void fs_download_update(DownloadList * list, 317void
345 unsigned long long completed, 318fs_download_update (DownloadList * list,
346 const char * data, 319 unsigned long long completed,
347 unsigned int size) { 320 const char *data, unsigned int size)
321{
348 GtkTreeIter iter; 322 GtkTreeIter iter;
349 GtkTreePath * path; 323 GtkTreePath *path;
350 unsigned int val; 324 unsigned int val;
351 struct ECRS_MetaData * meta; 325 struct ECRS_MetaData *meta;
352 326
353 path = gtk_tree_row_reference_get_path(list->summaryViewRowReference); 327 path = gtk_tree_row_reference_get_path (list->summaryViewRowReference);
354 if (path == NULL) { 328 if (path == NULL)
355 GE_BREAK(ectx, 0); 329 {
356 return; 330 GE_BREAK (ectx, 0);
357 } 331 return;
358 gtk_tree_model_get_iter(GTK_TREE_MODEL(download_summary), 332 }
359 &iter, 333 gtk_tree_model_get_iter (GTK_TREE_MODEL (download_summary), &iter, path);
360 path); 334 gtk_tree_path_free (path);
361 gtk_tree_path_free(path);
362 if (list->total != 0) 335 if (list->total != 0)
363 val = completed * 100 / list->total; 336 val = completed * 100 / list->total;
364 else 337 else
365 val = 100; 338 val = 100;
366 gtk_tree_store_set(download_summary, 339 gtk_tree_store_set (download_summary, &iter, DOWNLOAD_PROGRESS, val, -1);
367 &iter, 340 if ((list->is_directory == YES) &&
368 DOWNLOAD_PROGRESS, val, 341 (list->searchList != NULL) && (list->searchViewRowReference != NULL))
369 -1); 342 {
370 if ( (list->is_directory == YES) && 343 meta = NULL;
371 (list->searchList != NULL) && 344 ECRS_listDirectory (ectx,
372 (list->searchViewRowReference != NULL) ) { 345 data, size, &meta, &addFilesToDirectory, list);
373 meta = NULL; 346 if (meta != NULL)
374 ECRS_listDirectory(ectx, 347 ECRS_freeMetaData (meta);
375 data, 348 }
376 size,
377 &meta,
378 &addFilesToDirectory,
379 list);
380 if (meta != NULL)
381 ECRS_freeMetaData(meta);
382 }
383} 349}
384 350
385/** 351/**
386 * A download has terminated successfully. Update summary and 352 * A download has terminated successfully. Update summary and
387 * possibly refresh directory listing. 353 * possibly refresh directory listing.
388 */ 354 */
389void fs_download_completed(DownloadList * downloadContext) { 355void
356fs_download_completed (DownloadList * downloadContext)
357{
390 GtkTreeIter iter; 358 GtkTreeIter iter;
391 GtkTreePath * path; 359 GtkTreePath *path;
392 360
393 if (downloadContext->searchViewRowReference != NULL) { 361 if (downloadContext->searchViewRowReference != NULL)
394 path = gtk_tree_row_reference_get_path(downloadContext->searchViewRowReference); 362 {
395 gtk_tree_model_get_iter(GTK_TREE_MODEL(downloadContext->searchList->tree), 363 path =
396 &iter, 364 gtk_tree_row_reference_get_path (downloadContext->
397 path); 365 searchViewRowReference);
398 gtk_tree_path_free(path); 366 gtk_tree_model_get_iter (GTK_TREE_MODEL
399 gtk_tree_store_set(downloadContext->searchList->tree, 367 (downloadContext->searchList->tree), &iter,
400 &iter, 368 path);
401 SEARCH_CELL_BG_COLOR, getColorCode(URITRACK_DOWNLOAD_COMPLETED), 369 gtk_tree_path_free (path);
402 -1); 370 gtk_tree_store_set (downloadContext->searchList->tree,
403 } 371 &iter,
372 SEARCH_CELL_BG_COLOR,
373 getColorCode (URITRACK_DOWNLOAD_COMPLETED), -1);
374 }
404 downloadContext->has_terminated = YES; 375 downloadContext->has_terminated = YES;
405 refreshDirectoryViewFromDisk(downloadContext); 376 refreshDirectoryViewFromDisk (downloadContext);
406} 377}
407 378
408/** 379/**
409 * A download has been aborted. Update summary and 380 * A download has been aborted. Update summary and
410 * possibly refresh directory listing. 381 * possibly refresh directory listing.
411 */ 382 */
412void fs_download_aborted(DownloadList * downloadContext) { 383void
384fs_download_aborted (DownloadList * downloadContext)
385{
413 GtkTreeIter iter; 386 GtkTreeIter iter;
414 GtkTreePath * path; 387 GtkTreePath *path;
415 388
416 if (downloadContext->searchViewRowReference != NULL) { 389 if (downloadContext->searchViewRowReference != NULL)
417 path = gtk_tree_row_reference_get_path(downloadContext->searchViewRowReference); 390 {
418 gtk_tree_model_get_iter(GTK_TREE_MODEL(downloadContext->searchList->tree), 391 path =
419 &iter, 392 gtk_tree_row_reference_get_path (downloadContext->
420 path); 393 searchViewRowReference);
421 gtk_tree_path_free(path); 394 gtk_tree_model_get_iter (GTK_TREE_MODEL
422 gtk_tree_store_set(downloadContext->searchList->tree, 395 (downloadContext->searchList->tree), &iter,
423 &iter, 396 path);
424 SEARCH_CELL_BG_COLOR, getColorCode(URITRACK_DOWNLOAD_ABORTED), 397 gtk_tree_path_free (path);
425 -1); 398 gtk_tree_store_set (downloadContext->searchList->tree,
426 } 399 &iter,
400 SEARCH_CELL_BG_COLOR,
401 getColorCode (URITRACK_DOWNLOAD_ABORTED), -1);
402 }
427 downloadContext->has_terminated = YES; 403 downloadContext->has_terminated = YES;
428 refreshDirectoryViewFromDisk(downloadContext); 404 refreshDirectoryViewFromDisk (downloadContext);
429} 405}
430 406
431/** 407/**
432 * A download has been stopped. Remove from summary 408 * A download has been stopped. Remove from summary
433 * and free associated resources. 409 * and free associated resources.
434 */ 410 */
435void fs_download_stopped(DownloadList * list) { 411void
412fs_download_stopped (DownloadList * list)
413{
436 GtkTreeIter iter; 414 GtkTreeIter iter;
437 GtkTreeIter piter; 415 GtkTreeIter piter;
438 GtkTreePath * path; 416 GtkTreePath *path;
439 DownloadList * prev; 417 DownloadList *prev;
440 int valid; 418 int valid;
441 GtkTreeModel * model; 419 GtkTreeModel *model;
442 420
443 path = gtk_tree_row_reference_get_path(list->summaryViewRowReference); 421 path = gtk_tree_row_reference_get_path (list->summaryViewRowReference);
444 if (path == NULL) { 422 if (path == NULL)
445 GE_BREAK(ectx, 0); 423 {
446 } else { 424 GE_BREAK (ectx, 0);
447 gtk_tree_model_get_iter(GTK_TREE_MODEL(download_summary), 425 }
448 &iter, 426 else
449 path); 427 {
450 gtk_tree_path_free(path); 428 gtk_tree_model_get_iter (GTK_TREE_MODEL (download_summary),
451 gtk_tree_row_reference_free(list->summaryViewRowReference); 429 &iter, path);
452 list->summaryViewRowReference = NULL; 430 gtk_tree_path_free (path);
453 gtk_tree_store_remove(download_summary, 431 gtk_tree_row_reference_free (list->summaryViewRowReference);
454 &iter); 432 list->summaryViewRowReference = NULL;
455 } 433 gtk_tree_store_remove (download_summary, &iter);
456 FREE(list->filename); 434 }
457 ECRS_freeUri(list->uri); 435 FREE (list->filename);
436 ECRS_freeUri (list->uri);
458 437
459 /* if we have child-results in view, remove them! */ 438 /* if we have child-results in view, remove them! */
460 if (list->searchList != NULL) { 439 if (list->searchList != NULL)
461 path = gtk_tree_row_reference_get_path(list->searchViewRowReference); 440 {
462 if (path == NULL) { 441 path = gtk_tree_row_reference_get_path (list->searchViewRowReference);
463 GE_BREAK(ectx, 0); 442 if (path == NULL)
464 } else { 443 {
465 model = GTK_TREE_MODEL(list->searchList->tree); 444 GE_BREAK (ectx, 0);
466 gtk_tree_model_get_iter(model, 445 }
467 &piter, 446 else
468 path); 447 {
469 gtk_tree_path_free(path); 448 model = GTK_TREE_MODEL (list->searchList->tree);
470 valid = gtk_tree_model_iter_children(model, 449 gtk_tree_model_get_iter (model, &piter, path);
471 &iter, 450 gtk_tree_path_free (path);
472 &piter); 451 valid = gtk_tree_model_iter_children (model, &iter, &piter);
473 while (TRUE == valid) 452 while (TRUE == valid)
474 valid = gtk_tree_store_remove(GTK_TREE_STORE(model), 453 valid = gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
475 &iter); 454 }
476 } 455 }
477 } 456 if (list->searchViewRowReference != NULL)
478 if (list->searchViewRowReference != NULL) { 457 {
479 gtk_tree_row_reference_free(list->searchViewRowReference); 458 gtk_tree_row_reference_free (list->searchViewRowReference);
480 list->searchViewRowReference = NULL; 459 list->searchViewRowReference = NULL;
481 } 460 }
482 461
483 if (download_head == list) { 462 if (download_head == list)
484 download_head = list->next; 463 {
485 } else { 464 download_head = list->next;
486 prev = download_head; 465 }
487 while ( (prev != NULL) && 466 else
488 (prev->next != list) ) 467 {
489 prev = prev->next; 468 prev = download_head;
490 if (prev != NULL) 469 while ((prev != NULL) && (prev->next != list))
491 prev->next = list->next; 470 prev = prev->next;
492 else 471 if (prev != NULL)
493 GE_BREAK(ectx, 0); 472 prev->next = list->next;
494 } 473 else
495 FREE(list); 474 GE_BREAK (ectx, 0);
475 }
476 FREE (list);
496} 477}
497 478
498 479
@@ -506,59 +487,60 @@ void fs_download_stopped(DownloadList * list) {
506 * such a download is already active. 487 * such a download is already active.
507 */ 488 */
508static int 489static int
509check_pending(const char * filename, 490check_pending (const char *filename, GtkTreeIter * parent)
510 GtkTreeIter * parent) { 491{
511 GtkTreeModel * model; 492 GtkTreeModel *model;
512 GtkTreeIter iter; 493 GtkTreeIter iter;
513 char * name; 494 char *name;
514 495
515 model = GTK_TREE_MODEL(download_summary); 496 model = GTK_TREE_MODEL (download_summary);
516 if (gtk_tree_model_iter_children(model, 497 if (gtk_tree_model_iter_children (model, &iter, parent))
517 &iter, 498 {
518 parent)) { 499 do
519 do { 500 {
520 gtk_tree_model_get(model, 501 gtk_tree_model_get (model, &iter, DOWNLOAD_FILENAME, &name, -1);
521 &iter, 502 if ((name != NULL) && (0 == strcmp (name, filename)))
522 DOWNLOAD_FILENAME, &name, 503 {
523 -1); 504 free (name);
524 if ( (name != NULL) && 505 return SYSERR;
525 (0 == strcmp(name, filename)) ) { 506 }
526 free(name); 507 if (name != NULL)
527 return SYSERR; 508 free (name);
528 } 509 if (SYSERR == check_pending (filename, &iter))
529 if (name != NULL) 510 return SYSERR;
530 free(name); 511 }
531 if (SYSERR == check_pending(filename, 512 while (gtk_tree_model_iter_next (model, &iter));
532 &iter)) 513 }
533 return SYSERR;
534 } while (gtk_tree_model_iter_next(model,
535 &iter));
536 }
537 return OK; 514 return OK;
538} 515}
539 516
540typedef struct { 517typedef struct
541 char * uri_name; 518{
542 struct ECRS_URI * idc_uri; 519 char *uri_name;
543 struct ECRS_MetaData * idc_meta; 520 struct ECRS_URI *idc_uri;
544 char * idc_final_download_destination; 521 struct ECRS_MetaData *idc_meta;
545 SearchList * searchContext; 522 char *idc_final_download_destination;
546 DownloadList * parentContext; 523 SearchList *searchContext;
524 DownloadList *parentContext;
547 unsigned int anonymity; 525 unsigned int anonymity;
548 int recursive; 526 int recursive;
549} SDC; 527} SDC;
550 528
551static void * init_download_helper(void * cls) { 529static void *
552 SDC * sdc = cls; 530init_download_helper (void *cls)
553 531{
554 FSUI_startDownload(ctx, 532 SDC *sdc = cls;
555 sdc->anonymity, 533
556 sdc->recursive, 534 FSUI_startDownload (ctx,
557 sdc->idc_uri, 535 sdc->anonymity,
558 sdc->idc_meta, 536 sdc->recursive,
559 sdc->idc_final_download_destination, 537 sdc->idc_uri,
560 (sdc->searchContext != NULL) ? sdc->searchContext->fsui_list : NULL, 538 sdc->idc_meta,
561 (sdc->parentContext != NULL) ? sdc->parentContext->fsui_list : NULL); 539 sdc->idc_final_download_destination,
540 (sdc->searchContext !=
541 NULL) ? sdc->searchContext->fsui_list : NULL,
542 (sdc->parentContext !=
543 NULL) ? sdc->parentContext->fsui_list : NULL);
562 return NULL; 544 return NULL;
563} 545}
564 546
@@ -567,21 +549,20 @@ static void * init_download_helper(void * cls) {
567 * Start the download of the selected entry. 549 * Start the download of the selected entry.
568 */ 550 */
569static void 551static void
570initiateDownload(GtkTreeModel * model, 552initiateDownload (GtkTreeModel * model,
571 GtkTreePath * path, 553 GtkTreePath * path, GtkTreeIter * iter, gpointer unused)
572 GtkTreeIter * iter, 554{
573 gpointer unused) {
574 SDC sdc; 555 SDC sdc;
575 char * final_download_dir; 556 char *final_download_dir;
576 GtkTreeIter iiter; 557 GtkTreeIter iiter;
577 char * tmp; 558 char *tmp;
578 char * cname; 559 char *cname;
579 char * dname; 560 char *dname;
580 GtkTreePath *dirTreePath; 561 GtkTreePath *dirTreePath;
581 char *dirPath; 562 char *dirPath;
582 unsigned int dirPathLen; 563 unsigned int dirPathLen;
583 char * idc_name; 564 char *idc_name;
584 char * idc_mime; 565 char *idc_mime;
585 566
586 sdc.idc_uri = NULL; 567 sdc.idc_uri = NULL;
587 sdc.idc_meta = NULL; 568 sdc.idc_meta = NULL;
@@ -589,178 +570,183 @@ initiateDownload(GtkTreeModel * model,
589 idc_mime = NULL; 570 idc_mime = NULL;
590 sdc.searchContext = NULL; 571 sdc.searchContext = NULL;
591 sdc.parentContext = NULL; 572 sdc.parentContext = NULL;
592 gtk_tree_model_get(model, 573 gtk_tree_model_get (model,
593 iter, 574 iter,
594 SEARCH_NAME, &idc_name, 575 SEARCH_NAME, &idc_name,
595 SEARCH_URI, &sdc.idc_uri, 576 SEARCH_URI, &sdc.idc_uri,
596 SEARCH_META, &sdc.idc_meta, 577 SEARCH_META, &sdc.idc_meta,
597 SEARCH_MIME, &idc_mime, 578 SEARCH_MIME, &idc_mime,
598 SEARCH_INTERNAL, &sdc.searchContext, 579 SEARCH_INTERNAL, &sdc.searchContext,
599 SEARCH_INTERNAL_PARENT, &sdc.parentContext, 580 SEARCH_INTERNAL_PARENT, &sdc.parentContext, -1);
600 -1); 581 if ((sdc.idc_uri == NULL) ||
601 if ( (sdc.idc_uri == NULL) || 582 (!(ECRS_isFileUri (sdc.idc_uri) || ECRS_isLocationUri (sdc.idc_uri))))
602 (! (ECRS_isFileUri(sdc.idc_uri) || 583 {
603 ECRS_isLocationUri(sdc.idc_uri) ) ) ) { 584 GE_BREAK (ectx, 0);
604 GE_BREAK(ectx, 0); 585 FREENONNULL (idc_name);
605 FREENONNULL(idc_name); 586 FREENONNULL (idc_mime);
606 FREENONNULL(idc_mime); 587 return;
607 return; 588 }
608 } 589 sdc.uri_name = ECRS_uriToString (sdc.idc_uri);
609 sdc.uri_name = ECRS_uriToString(sdc.idc_uri); 590 if ((sdc.uri_name == NULL) ||
610 if ( (sdc.uri_name == NULL) || 591 (strlen (sdc.uri_name) <
611 (strlen(sdc.uri_name) < 592 strlen (ECRS_URI_PREFIX) + strlen (ECRS_FILE_INFIX)))
612 strlen(ECRS_URI_PREFIX) + 593 {
613 strlen(ECRS_FILE_INFIX)) ) { 594 GE_BREAK (ectx, 0);
614 GE_BREAK(ectx, 0); 595 FREENONNULL (sdc.uri_name);
615 FREENONNULL(sdc.uri_name); 596 FREENONNULL (idc_name);
616 FREENONNULL(idc_name); 597 FREENONNULL (idc_mime);
617 FREENONNULL(idc_mime); 598 return;
618 return; 599 }
619 }
620 /* reduce "//" to "/" */ 600 /* reduce "//" to "/" */
621 if (idc_name != NULL) { 601 if (idc_name != NULL)
622 while (strstr(idc_name, "//") != NULL) 602 {
623 memcpy(strstr(idc_name, "//"), 603 while (strstr (idc_name, "//") != NULL)
624 strstr(idc_name, "//") + 1, 604 memcpy (strstr (idc_name, "//"),
625 strlen(strstr(idc_name, "//"))); 605 strstr (idc_name, "//") + 1,
626 } 606 strlen (strstr (idc_name, "//")));
607 }
627 /* if no name given or just "/", produce better name */ 608 /* if no name given or just "/", produce better name */
628 if ( (idc_name == NULL) || 609 if ((idc_name == NULL) || (0 == strcmp ("/", idc_name)))
629 (0 == strcmp("/", idc_name)) ) { 610 {
630#ifdef WINDOWS 611#ifdef WINDOWS
631 char * filehash; 612 char *filehash;
632 613
633 GE_ASSERT(NULL, 614 GE_ASSERT (NULL,
634 strlen(sdc.uri_name) > strlen(ECRS_URI_PREFIX) + strlen(ECRS_FILE_INFIX)); 615 strlen (sdc.uri_name) >
635 FREENONNULL(idc_name); 616 strlen (ECRS_URI_PREFIX) + strlen (ECRS_FILE_INFIX));
636 filehash = STRDUP(&sdc.uri_name[strlen(ECRS_URI_PREFIX) + strlen(ECRS_FILE_INFIX)]); 617 FREENONNULL (idc_name);
637 filehash[16] = 0; 618 filehash =
638 idc_name = STRDUP(filehash); 619 STRDUP (&sdc.
639 FREENONNULL(filehash); 620 uri_name[strlen (ECRS_URI_PREFIX) +
621 strlen (ECRS_FILE_INFIX)]);
622 filehash[16] = 0;
623 idc_name = STRDUP (filehash);
624 FREENONNULL (filehash);
640#else 625#else
641 GE_ASSERT(NULL, 626 GE_ASSERT (NULL,
642 strlen(sdc.uri_name) > strlen(ECRS_URI_PREFIX) + strlen(ECRS_FILE_INFIX)); 627 strlen (sdc.uri_name) >
643 FREENONNULL(idc_name); 628 strlen (ECRS_URI_PREFIX) + strlen (ECRS_FILE_INFIX));
644 idc_name = STRDUP(&sdc.uri_name[strlen(ECRS_URI_PREFIX) + strlen(ECRS_FILE_INFIX)]); 629 FREENONNULL (idc_name);
630 idc_name =
631 STRDUP (&sdc.
632 uri_name[strlen (ECRS_URI_PREFIX) +
633 strlen (ECRS_FILE_INFIX)]);
645#endif 634#endif
646 } 635 }
647 636
648 /* dname = directory portion of idc_name */ 637 /* dname = directory portion of idc_name */
649 cname = idc_name; 638 cname = idc_name;
650 dname = STRDUP(idc_name); 639 dname = STRDUP (idc_name);
651 cname = &dname[strlen(dname)-1]; 640 cname = &dname[strlen (dname) - 1];
652 if (cname != dname) 641 if (cname != dname)
653 cname--; /* ignore tailing '/' */ 642 cname--; /* ignore tailing '/' */
654 while ( (cname != dname) && 643 while ((cname != dname) && (*cname != DIR_SEPARATOR))
655 (*cname != DIR_SEPARATOR) )
656 cname--; 644 cname--;
657 if (*cname == DIR_SEPARATOR) { 645 if (*cname == DIR_SEPARATOR)
658 *cname = '\0'; 646 {
659 FREE(idc_name); 647 *cname = '\0';
660 idc_name = STRDUP(cname + 1); 648 FREE (idc_name);
661 } else { 649 idc_name = STRDUP (cname + 1);
662 *cname = '\0'; 650 }
663 } 651 else
652 {
653 *cname = '\0';
654 }
664 cname = NULL; 655 cname = NULL;
665 656
666 GC_get_configuration_value_filename(cfg, 657 GC_get_configuration_value_filename (cfg,
667 "FS", 658 "FS",
668 "INCOMINGDIR", 659 "INCOMINGDIR",
669 "$HOME/gnunet-downloads/", 660 "$HOME/gnunet-downloads/",
670 &final_download_dir); 661 &final_download_dir);
671 if (strlen(dname) > 0) { 662 if (strlen (dname) > 0)
672 tmp = MALLOC(strlen(final_download_dir) + strlen(dname) + 2); 663 {
673 strcpy(tmp, final_download_dir); 664 tmp = MALLOC (strlen (final_download_dir) + strlen (dname) + 2);
674 if (tmp[strlen(tmp)] != DIR_SEPARATOR) 665 strcpy (tmp, final_download_dir);
675 strcat(tmp, DIR_SEPARATOR_STR); 666 if (tmp[strlen (tmp)] != DIR_SEPARATOR)
676 if (dname[0] == DIR_SEPARATOR) 667 strcat (tmp, DIR_SEPARATOR_STR);
677 strcat(tmp, &dname[1]); 668 if (dname[0] == DIR_SEPARATOR)
678 else 669 strcat (tmp, &dname[1]);
679 strcat(tmp, dname); 670 else
680 FREE(final_download_dir); 671 strcat (tmp, dname);
681 final_download_dir = tmp; 672 FREE (final_download_dir);
682 } 673 final_download_dir = tmp;
683 FREE(dname); 674 }
675 FREE (dname);
684 dname = NULL; 676 dname = NULL;
685 /* If file is inside a directory, get the full path */ 677 /* If file is inside a directory, get the full path */
686 dirTreePath = gtk_tree_path_copy(path); 678 dirTreePath = gtk_tree_path_copy (path);
687 dirPath = MALLOC(1); 679 dirPath = MALLOC (1);
688 dirPath[0] = '\0'; 680 dirPath[0] = '\0';
689 dirPathLen = 0; 681 dirPathLen = 0;
690 while (gtk_tree_path_get_depth(dirTreePath) > 1) { 682 while (gtk_tree_path_get_depth (dirTreePath) > 1)
691 char * dirname; 683 {
692 char * newPath; 684 char *dirname;
693 685 char *newPath;
694 if (! gtk_tree_path_up(dirTreePath)) 686
695 break; 687 if (!gtk_tree_path_up (dirTreePath))
696 if (! gtk_tree_model_get_iter(model, 688 break;
697 &iiter, 689 if (!gtk_tree_model_get_iter (model, &iiter, dirTreePath))
698 dirTreePath)) 690 break;
699 break; 691 gtk_tree_model_get (model, &iiter, SEARCH_NAME, &dirname, -1);
700 gtk_tree_model_get(model, 692 dirPathLen =
701 &iiter, 693 strlen (dirPath) + strlen (dirname) + strlen (DIR_SEPARATOR_STR) + 1;
702 SEARCH_NAME, &dirname, 694 newPath = MALLOC (dirPathLen + 1);
703 -1); 695 strcpy (newPath, dirname);
704 dirPathLen = strlen(dirPath) + strlen(dirname) + strlen(DIR_SEPARATOR_STR) + 1; 696 if (newPath[strlen (newPath) - 1] != DIR_SEPARATOR)
705 newPath = MALLOC(dirPathLen + 1); 697 strcat (newPath, DIR_SEPARATOR_STR);
706 strcpy(newPath, dirname); 698 strcat (newPath, dirPath);
707 if (newPath[strlen(newPath)-1] != DIR_SEPARATOR) 699 FREE (dirPath);
708 strcat(newPath, DIR_SEPARATOR_STR); 700 dirPath = newPath;
709 strcat(newPath, dirPath); 701 free (dirname);
710 FREE(dirPath); 702 }
711 dirPath = newPath; 703 gtk_tree_path_free (dirTreePath);
712 free(dirname);
713 }
714 gtk_tree_path_free(dirTreePath);
715 704
716 /* construct completed/directory/real-filename */ 705 /* construct completed/directory/real-filename */
717 sdc.idc_final_download_destination = MALLOC(strlen(final_download_dir) + 2 + 706 sdc.idc_final_download_destination =
718 strlen(idc_name) + strlen(GNUNET_DIRECTORY_EXT) + 707 MALLOC (strlen (final_download_dir) + 2 + strlen (idc_name) +
719 strlen(dirPath)); 708 strlen (GNUNET_DIRECTORY_EXT) + strlen (dirPath));
720 strcpy(sdc.idc_final_download_destination, 709 strcpy (sdc.idc_final_download_destination, final_download_dir);
721 final_download_dir); 710 if (sdc.
722 if (sdc.idc_final_download_destination[strlen(sdc.idc_final_download_destination)-1] != DIR_SEPARATOR) 711 idc_final_download_destination[strlen
723 strcat(sdc.idc_final_download_destination, 712 (sdc.idc_final_download_destination) -
724 DIR_SEPARATOR_STR); 713 1] != DIR_SEPARATOR)
725 strcat(sdc.idc_final_download_destination, 714 strcat (sdc.idc_final_download_destination, DIR_SEPARATOR_STR);
726 dirPath); 715 strcat (sdc.idc_final_download_destination, dirPath);
727 strcat(sdc.idc_final_download_destination, 716 strcat (sdc.idc_final_download_destination, idc_name);
728 idc_name); 717 sdc.anonymity = getSpinButtonValue (sdc.searchContext->searchXML,
729 sdc.anonymity = getSpinButtonValue(sdc.searchContext->searchXML, 718 "downloadAnonymitySpinButton");
730 "downloadAnonymitySpinButton"); 719 sdc.recursive = getToggleButtonValue (sdc.searchContext->searchXML,
731 sdc.recursive = getToggleButtonValue(sdc.searchContext->searchXML, 720 "downloadRecursiveCheckButton");
732 "downloadRecursiveCheckButton"); 721 if (OK == check_pending (idc_name, NULL))
733 if (OK == check_pending(idc_name, 722 {
734 NULL)) { 723 addLogEntry (_("Downloading `%s'\n"), idc_name);
735 addLogEntry(_("Downloading `%s'\n"), 724 run_with_save_calls (&init_download_helper, &sdc);
736 idc_name); 725 }
737 run_with_save_calls(&init_download_helper, 726 else
738 &sdc); 727 {
739 } else { 728 addLogEntry (_("ERROR: already downloading `%s'"), idc_name);
740 addLogEntry(_("ERROR: already downloading `%s'"), 729 }
741 idc_name); 730 FREE (sdc.uri_name);
742 } 731 FREE (dirPath);
743 FREE(sdc.uri_name); 732 FREE (sdc.idc_final_download_destination);
744 FREE(dirPath); 733 FREENONNULL (final_download_dir);
745 FREE(sdc.idc_final_download_destination); 734 FREENONNULL (idc_name);
746 FREENONNULL(final_download_dir); 735 FREENONNULL (idc_mime);
747 FREENONNULL(idc_name);
748 FREENONNULL(idc_mime);
749} 736}
750 737
751/** 738/**
752 * The download button in the search dialog was 739 * The download button in the search dialog was
753 * clicked. Download all selected entries. 740 * clicked. Download all selected entries.
754 */ 741 */
755void on_downloadButton_clicked_fs(GtkWidget * treeview, 742void
756 GtkWidget * downloadButton) { 743on_downloadButton_clicked_fs (GtkWidget * treeview,
757 GtkTreeSelection * selection; 744 GtkWidget * downloadButton)
758 745{
759 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); 746 GtkTreeSelection *selection;
760 ggc_tree_selection_selected_foreach 747
761 (selection, 748 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
762 &initiateDownload, 749 ggc_tree_selection_selected_foreach (selection, &initiateDownload, NULL);
763 NULL);
764} 750}
765 751
766 752
@@ -773,161 +759,151 @@ void on_downloadButton_clicked_fs(GtkWidget * treeview,
773 * - support for user-specified filename 759 * - support for user-specified filename
774 * - enable button only if valid URI is entered 760 * - enable button only if valid URI is entered
775 */ 761 */
776void on_statusDownloadURIEntry_editing_done_fs(GtkWidget * entry, 762void
777 GtkWidget * downloadButton) { 763on_statusDownloadURIEntry_editing_done_fs (GtkWidget * entry,
778 const char * uris; 764 GtkWidget * downloadButton)
779 char * urid; 765{
780 char * final_download_dir; 766 const char *uris;
781 const char * dname; 767 char *urid;
768 char *final_download_dir;
769 const char *dname;
782 SDC sdc; 770 SDC sdc;
783 771
784 uris = gtk_entry_get_text(GTK_ENTRY(entry)); 772 uris = gtk_entry_get_text (GTK_ENTRY (entry));
785 urid = STRDUP(uris); 773 urid = STRDUP (uris);
786 gtk_entry_set_text(GTK_ENTRY(entry), 774 gtk_entry_set_text (GTK_ENTRY (entry), ECRS_URI_PREFIX);
787 ECRS_URI_PREFIX); 775 sdc.idc_uri = ECRS_stringToUri (ectx, urid);
788 sdc.idc_uri = ECRS_stringToUri(ectx, urid); 776 if (sdc.idc_uri == NULL)
789 if (sdc.idc_uri == NULL) { 777 {
790 addLogEntry(_("Invalid URI `%s'"), urid); 778 addLogEntry (_("Invalid URI `%s'"), urid);
791 FREE(urid); 779 FREE (urid);
792 return; 780 return;
793 } 781 }
794 if (ECRS_isKeywordUri(sdc.idc_uri)) { 782 if (ECRS_isKeywordUri (sdc.idc_uri))
795 addLogEntry(_("Please use the search function for keyword (KSK) URIs!")); 783 {
796 FREE(urid); 784 addLogEntry (_
797 ECRS_freeUri(sdc.idc_uri); 785 ("Please use the search function for keyword (KSK) URIs!"));
798 return; 786 FREE (urid);
799 } else if (ECRS_isLocationUri(sdc.idc_uri)) { 787 ECRS_freeUri (sdc.idc_uri);
800 addLogEntry(_("Location URIs are not yet supported")); 788 return;
801 FREE(urid); 789 }
802 ECRS_freeUri(sdc.idc_uri); 790 else if (ECRS_isLocationUri (sdc.idc_uri))
803 return; 791 {
804 } 792 addLogEntry (_("Location URIs are not yet supported"));
805 GC_get_configuration_value_filename(cfg, 793 FREE (urid);
806 "FS", 794 ECRS_freeUri (sdc.idc_uri);
807 "INCOMINGDIR", 795 return;
808 "$HOME/gnunet-downloads/", 796 }
809 &final_download_dir); 797 GC_get_configuration_value_filename (cfg,
810 disk_directory_create(ectx, final_download_dir); 798 "FS",
811 dname = &uris[strlen(ECRS_URI_PREFIX) + strlen(ECRS_FILE_INFIX)]; 799 "INCOMINGDIR",
812 sdc.idc_final_download_destination = MALLOC(strlen(final_download_dir) + strlen(dname) + 2); 800 "$HOME/gnunet-downloads/",
813 strcpy(sdc.idc_final_download_destination, 801 &final_download_dir);
814 final_download_dir); 802 disk_directory_create (ectx, final_download_dir);
815 FREE(final_download_dir); 803 dname = &uris[strlen (ECRS_URI_PREFIX) + strlen (ECRS_FILE_INFIX)];
816 if (sdc.idc_final_download_destination[strlen(sdc.idc_final_download_destination)] != DIR_SEPARATOR) 804 sdc.idc_final_download_destination =
817 strcat(sdc.idc_final_download_destination, 805 MALLOC (strlen (final_download_dir) + strlen (dname) + 2);
818 DIR_SEPARATOR_STR); 806 strcpy (sdc.idc_final_download_destination, final_download_dir);
819 strcat(sdc.idc_final_download_destination, 807 FREE (final_download_dir);
820 dname); 808 if (sdc.
821 809 idc_final_download_destination[strlen
822 addLogEntry(_("Downloading `%s'\n"), 810 (sdc.idc_final_download_destination)] !=
823 uris); 811 DIR_SEPARATOR)
824 sdc.idc_meta = ECRS_createMetaData(); 812 strcat (sdc.idc_final_download_destination, DIR_SEPARATOR_STR);
825 sdc.anonymity = getSpinButtonValue(getMainXML(), 813 strcat (sdc.idc_final_download_destination, dname);
826 "fsstatusAnonymitySpin"); 814
815 addLogEntry (_("Downloading `%s'\n"), uris);
816 sdc.idc_meta = ECRS_createMetaData ();
817 sdc.anonymity = getSpinButtonValue (getMainXML (), "fsstatusAnonymitySpin");
827 sdc.recursive = NO; 818 sdc.recursive = NO;
828 sdc.searchContext = NULL; 819 sdc.searchContext = NULL;
829 sdc.parentContext = NULL; 820 sdc.parentContext = NULL;
830 run_with_save_calls(&init_download_helper, 821 run_with_save_calls (&init_download_helper, &sdc);
831 &sdc); 822 ECRS_freeMetaData (sdc.idc_meta);
832 ECRS_freeMetaData(sdc.idc_meta); 823 FREE (sdc.idc_final_download_destination);
833 FREE(sdc.idc_final_download_destination); 824 FREE (urid);
834 FREE(urid);
835} 825}
836 826
837struct FCBC { 827struct FCBC
838 int (*method)(struct FSUI_Context * ctx, 828{
839 struct FSUI_DownloadList * list); 829 int (*method) (struct FSUI_Context * ctx, struct FSUI_DownloadList * list);
840 struct FSUI_DownloadList * argument; 830 struct FSUI_DownloadList *argument;
841}; 831};
842 832
843static void * fsui_callback(void * cls) { 833static void *
844 struct FCBC * fcbc = cls; 834fsui_callback (void *cls)
845 fcbc->method(ctx, 835{
846 fcbc->argument); 836 struct FCBC *fcbc = cls;
837 fcbc->method (ctx, fcbc->argument);
847 return NULL; 838 return NULL;
848} 839}
849 840
850static void 841static void
851clearCompletedDownloadCallback(GtkTreeModel * model, 842clearCompletedDownloadCallback (GtkTreeModel * model,
852 GtkTreePath * path, 843 GtkTreePath * path,
853 GtkTreeIter * iter, 844 GtkTreeIter * iter, gpointer unused)
854 gpointer unused) { 845{
855 DownloadList * dl; 846 DownloadList *dl;
856 struct FCBC fcbc; 847 struct FCBC fcbc;
857 848
858 GE_ASSERT(ectx, 849 GE_ASSERT (ectx, model == GTK_TREE_MODEL (download_summary));
859 model == GTK_TREE_MODEL(download_summary)); 850 gtk_tree_model_get (model, iter, DOWNLOAD_INTERNAL, &dl, -1);
860 gtk_tree_model_get(model, 851 if ((FALSE == gtk_tree_model_iter_has_child (model,
861 iter, 852 iter)) && (dl->has_terminated))
862 DOWNLOAD_INTERNAL, &dl, 853 {
863 -1); 854 fcbc.method = &FSUI_stopDownload;
864 if ( (FALSE == gtk_tree_model_iter_has_child(model, 855 fcbc.argument = dl->fsui_list;
865 iter)) && 856 run_with_save_calls (&fsui_callback, &fcbc);
866 (dl->has_terminated) ) { 857 }
867 fcbc.method = &FSUI_stopDownload;
868 fcbc.argument = dl->fsui_list;
869 run_with_save_calls(&fsui_callback,
870 &fcbc);
871 }
872} 858}
873 859
874void on_clearCompletedDownloadsButton_clicked_fs(void * unused, 860void
875 GtkWidget * clearButton) { 861on_clearCompletedDownloadsButton_clicked_fs (void *unused,
876 ggc_tree_model_foreach(GTK_TREE_MODEL(download_summary), 862 GtkWidget * clearButton)
877 &clearCompletedDownloadCallback, 863{
878 NULL); 864 ggc_tree_model_foreach (GTK_TREE_MODEL (download_summary),
865 &clearCompletedDownloadCallback, NULL);
879} 866}
880 867
881static void 868static void
882fsuiCallDownloadCallback(GtkTreeModel * model, 869fsuiCallDownloadCallback (GtkTreeModel * model,
883 GtkTreePath * path, 870 GtkTreePath * path,
884 GtkTreeIter * iter, 871 GtkTreeIter * iter, gpointer fsui_call)
885 gpointer fsui_call) { 872{
886 DownloadList * dl; 873 DownloadList *dl;
887 struct FCBC fcbc; 874 struct FCBC fcbc;
888 875
889 GE_ASSERT(ectx, 876 GE_ASSERT (ectx, model == GTK_TREE_MODEL (download_summary));
890 model == GTK_TREE_MODEL(download_summary)); 877 gtk_tree_model_get (model, iter, DOWNLOAD_INTERNAL, &dl, -1);
891 gtk_tree_model_get(model,
892 iter,
893 DOWNLOAD_INTERNAL, &dl,
894 -1);
895 fcbc.method = fsui_call; 878 fcbc.method = fsui_call;
896 fcbc.argument = dl->fsui_list; 879 fcbc.argument = dl->fsui_list;
897 run_with_save_calls(&fsui_callback, 880 run_with_save_calls (&fsui_callback, &fcbc);
898 &fcbc);
899} 881}
900 882
901void on_abortDownloadButton_clicked_fs(void * unused, 883void
902 GtkWidget * abortButton) { 884on_abortDownloadButton_clicked_fs (void *unused, GtkWidget * abortButton)
903 GtkTreeSelection * selection; 885{
904 GtkWidget * downloadList; 886 GtkTreeSelection *selection;
887 GtkWidget *downloadList;
905 888
906 downloadList = glade_xml_get_widget(getMainXML(), 889 downloadList = glade_xml_get_widget (getMainXML (), "activeDownloadsList");
907 "activeDownloadsList"); 890 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (downloadList));
908 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(downloadList));
909 ggc_tree_selection_selected_foreach 891 ggc_tree_selection_selected_foreach
910 (selection, 892 (selection, &fsuiCallDownloadCallback, &FSUI_abortDownload);
911 &fsuiCallDownloadCallback,
912 &FSUI_abortDownload);
913} 893}
914 894
915void on_stopDownloadButton_clicked_fs(void * unused, 895void
916 GtkWidget * stopButton) { 896on_stopDownloadButton_clicked_fs (void *unused, GtkWidget * stopButton)
917 GtkTreeSelection * selection; 897{
918 GtkWidget * downloadList; 898 GtkTreeSelection *selection;
899 GtkWidget *downloadList;
919 900
920 downloadList = glade_xml_get_widget(getMainXML(), 901 downloadList = glade_xml_get_widget (getMainXML (), "activeDownloadsList");
921 "activeDownloadsList"); 902 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (downloadList));
922 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(downloadList));
923 ggc_tree_selection_selected_foreach 903 ggc_tree_selection_selected_foreach
924 (selection, 904 (selection, &fsuiCallDownloadCallback, &FSUI_abortDownload);
925 &fsuiCallDownloadCallback,
926 &FSUI_abortDownload);
927 ggc_tree_selection_selected_foreach 905 ggc_tree_selection_selected_foreach
928 (selection, 906 (selection, &fsuiCallDownloadCallback, &FSUI_stopDownload);
929 &fsuiCallDownloadCallback,
930 &FSUI_stopDownload);
931} 907}
932 908
933/* end of download.c */ 909/* end of download.c */
diff --git a/src/plugins/fs/download.h b/src/plugins/fs/download.h
index d03be966..9f09f263 100644
--- a/src/plugins/fs/download.h
+++ b/src/plugins/fs/download.h
@@ -31,27 +31,24 @@
31#include <GNUnet/gnunet_fsui_lib.h> 31#include <GNUnet/gnunet_fsui_lib.h>
32#include "fs.h" 32#include "fs.h"
33 33
34DownloadList * 34DownloadList *fs_download_started (struct FSUI_DownloadList *fsui_dl,
35fs_download_started(struct FSUI_DownloadList * fsui_dl, 35 DownloadList * dl_parent,
36 DownloadList * dl_parent, 36 SearchList * sl_parent,
37 SearchList * sl_parent, 37 unsigned long long total,
38 unsigned long long total, 38 unsigned int anonymityLevel,
39 unsigned int anonymityLevel, 39 const ECRS_FileInfo * fi,
40 const ECRS_FileInfo * fi, 40 const char *filename,
41 const char * filename, 41 unsigned long long completed,
42 unsigned long long completed, 42 cron_t eta, FSUI_State state);
43 cron_t eta, 43
44 FSUI_State state); 44void fs_download_update (DownloadList * downloadContext,
45 45 unsigned long long completed,
46void fs_download_update(DownloadList * downloadContext, 46 const char *data, unsigned int size);
47 unsigned long long completed, 47
48 const char * data, 48void fs_download_completed (DownloadList * downloadContext);
49 unsigned int size); 49
50 50void fs_download_aborted (DownloadList * downloadContext);
51void fs_download_completed(DownloadList * downloadContext); 51
52 52void fs_download_stopped (DownloadList * downloadContext);
53void fs_download_aborted(DownloadList * downloadContext);
54
55void fs_download_stopped(DownloadList * downloadContext);
56 53
57#endif 54#endif
diff --git a/src/plugins/fs/extensions/musicinsert.c b/src/plugins/fs/extensions/musicinsert.c
index a586e362..0e5798f5 100644
--- a/src/plugins/fs/extensions/musicinsert.c
+++ b/src/plugins/fs/extensions/musicinsert.c
@@ -56,7 +56,7 @@ EXTRACTOR_ExtractorList *Extractors;
56GtkWidget *musicinsertdialog; 56GtkWidget *musicinsertdialog;
57 57
58GtkTreeViewColumn *filename_list_col, *title_list_col, *artist_list_col, 58GtkTreeViewColumn *filename_list_col, *title_list_col, *artist_list_col,
59 *album_list_col, *type_list_col, *format_list_col, *keywords_list_col; 59 *album_list_col, *type_list_col, *format_list_col, *keywords_list_col;
60 60
61GtkWidget *filelist_popup; 61GtkWidget *filelist_popup;
62 62
@@ -66,260 +66,236 @@ main (int argc, char *argv[])
66 66
67 67
68 68
69 gtk_init (&argc, &argv); 69 gtk_init (&argc, &argv);
70 70
71 show_musicinsertdialog (); 71 show_musicinsertdialog ();
72 72
73 gtk_main (); 73 gtk_main ();
74 return 0; 74 return 0;
75} 75}
76 76
77void 77void
78show_musicinsertdialog () 78show_musicinsertdialog ()
79{ 79{
80 musicinsertXML = 80 musicinsertXML =
81 glade_xml_new (MUSICINSERTXMLFILE, "musicinsertdialog", 81 glade_xml_new (MUSICINSERTXMLFILE, "musicinsertdialog", PACKAGE_NAME);
82 PACKAGE_NAME); 82 glade_xml_signal_autoconnect (musicinsertXML);
83 glade_xml_signal_autoconnect (musicinsertXML);
84/* libglade*/ 83/* libglade*/
85 84
86 85
87 gtk_set_locale (); 86 gtk_set_locale ();
88 87
89 musicinsertdialog = 88 musicinsertdialog =
90 glade_xml_get_widget (musicinsertXML, "musicinsertdialog"); 89 glade_xml_get_widget (musicinsertXML, "musicinsertdialog");
91 90
92/* 91/*
93 * Create the 3 ComboBoxEntry manually (libglade doesn't handle this well : 92 * Create the 3 ComboBoxEntry manually (libglade doesn't handle this well :
94 * should use gtk_combo_box_entry_new_text instead of gtk_combo_box_entry_new) 93 * should use gtk_combo_box_entry_new_text instead of gtk_combo_box_entry_new)
95 */ 94 */
96 artistcombobox = 95 artistcombobox = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ());
97 GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ()); 96 albumcombobox = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ());
98 albumcombobox = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ()); 97 typecombobox = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ());
99 typecombobox = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ()); 98
100 99 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox),
101 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), 100 "Ogg (application/ogg)");
102 "Ogg (application/ogg)"); 101 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox),
103 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), 102 "MP3 (audio/mpeg)");
104 "MP3 (audio/mpeg)"); 103 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox),
105 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), 104 "MPC (application/x-musepack)");
106 "MPC (application/x-musepack)"); 105 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), "AAC");
107 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), "AAC"); 106 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox),
108 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), 107 "WMA (audio/x-ms-wma)");
109 "WMA (audio/x-ms-wma)"); 108 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox),
110 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), 109 "FLAC (audio/flac)");
111 "FLAC (audio/flac)"); 110 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), "APE");
112 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), "APE"); 111 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox),
113 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), 112 "WAV (application/x-wav)");
114 "WAV (application/x-wav)"); 113 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox),
115 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), 114 "REAL (audio/vnd.rn-realaudio)");
116 "REAL (audio/vnd.rn-realaudio)"); 115 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox),
117 gtk_combo_box_append_text (GTK_COMBO_BOX (typecombobox), 116 "MIDI (audio/x-midi)");
118 "MIDI (audio/x-midi)"); 117
119 118 GtkWidget *globaltable =
120 GtkWidget *globaltable = 119 glade_xml_get_widget (musicinsertXML, "globaltable");
121 glade_xml_get_widget (musicinsertXML, "globaltable"); 120 gtk_table_attach (GTK_TABLE (globaltable),
122 gtk_table_attach (GTK_TABLE (globaltable), 121 GTK_WIDGET (artistcombobox), 1, 3, 1, 2,
123 GTK_WIDGET (artistcombobox), 1, 3, 1, 2, 122 GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0);
124 GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0); 123 gtk_table_attach (GTK_TABLE (globaltable), GTK_WIDGET (albumcombobox),
125 gtk_table_attach (GTK_TABLE (globaltable), GTK_WIDGET (albumcombobox), 124 1, 3, 2, 3, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0);
126 1, 3, 2, 3, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 125 gtk_table_attach (GTK_TABLE (globaltable), GTK_WIDGET (typecombobox),
127 0); 126 1, 3, 3, 4, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0);
128 gtk_table_attach (GTK_TABLE (globaltable), GTK_WIDGET (typecombobox), 127
129 1, 3, 3, 4, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 128 gtk_widget_show (GTK_WIDGET (artistcombobox));
130 0); 129 gtk_widget_show (GTK_WIDGET (albumcombobox));
131 130 gtk_widget_show (GTK_WIDGET (typecombobox));
132 gtk_widget_show (GTK_WIDGET (artistcombobox)); 131
133 gtk_widget_show (GTK_WIDGET (albumcombobox)); 132 /*
134 gtk_widget_show (GTK_WIDGET (typecombobox)); 133 * treeview creation
135 134 */
136 /* 135
137 * treeview creation 136 /* liststore model */
138 */ 137 filelist_store =
139 138 gtk_list_store_new (COLS_NUMBER, G_TYPE_STRING, G_TYPE_STRING,
140 /* liststore model */ 139 G_TYPE_STRING, G_TYPE_STRING,
141 filelist_store = 140 G_TYPE_STRING, G_TYPE_STRING,
142 gtk_list_store_new (COLS_NUMBER, G_TYPE_STRING, G_TYPE_STRING, 141 G_TYPE_STRING, G_TYPE_STRING);
143 G_TYPE_STRING, G_TYPE_STRING, 142
144 G_TYPE_STRING, G_TYPE_STRING, 143 /* view */
145 G_TYPE_STRING, G_TYPE_STRING); 144 GtkWidget *filelist = glade_xml_get_widget (musicinsertXML, "filelist");
146 145 gtk_tree_view_set_model (GTK_TREE_VIEW (filelist),
147 /* view */ 146 GTK_TREE_MODEL (filelist_store));
148 GtkWidget *filelist = 147
149 glade_xml_get_widget (musicinsertXML, "filelist"); 148 /* cells definition */
150 gtk_tree_view_set_model (GTK_TREE_VIEW (filelist), 149 GtkCellRenderer *filename_renderer = gtk_cell_renderer_text_new ();
151 GTK_TREE_MODEL (filelist_store)); 150 g_object_set (filename_renderer, "editable", TRUE, NULL);
152 151 GtkCellRenderer *title_renderer = gtk_cell_renderer_text_new ();
153 /* cells definition */ 152 g_object_set (title_renderer, "editable", TRUE, NULL);
154 GtkCellRenderer *filename_renderer = gtk_cell_renderer_text_new (); 153 GtkCellRenderer *artist_renderer = gtk_cell_renderer_text_new ();
155 g_object_set (filename_renderer, "editable", TRUE, NULL); 154 g_object_set (artist_renderer, "editable", TRUE, NULL);
156 GtkCellRenderer *title_renderer = gtk_cell_renderer_text_new (); 155 GtkCellRenderer *album_renderer = gtk_cell_renderer_text_new ();
157 g_object_set (title_renderer, "editable", TRUE, NULL); 156 g_object_set (album_renderer, "editable", TRUE, NULL);
158 GtkCellRenderer *artist_renderer = gtk_cell_renderer_text_new (); 157 GtkCellRenderer *type_renderer = gtk_cell_renderer_text_new ();
159 g_object_set (artist_renderer, "editable", TRUE, NULL); 158 g_object_set (type_renderer, "editable", TRUE, NULL);
160 GtkCellRenderer *album_renderer = gtk_cell_renderer_text_new (); 159 GtkCellRenderer *format_renderer = gtk_cell_renderer_text_new ();
161 g_object_set (album_renderer, "editable", TRUE, NULL); 160 g_object_set (format_renderer, "editable", TRUE, NULL);
162 GtkCellRenderer *type_renderer = gtk_cell_renderer_text_new (); 161 GtkCellRenderer *keywords_renderer = gtk_cell_renderer_text_new ();
163 g_object_set (type_renderer, "editable", TRUE, NULL); 162 g_object_set (keywords_renderer, "editable", TRUE, NULL);
164 GtkCellRenderer *format_renderer = gtk_cell_renderer_text_new (); 163
165 g_object_set (format_renderer, "editable", TRUE, NULL); 164
166 GtkCellRenderer *keywords_renderer = gtk_cell_renderer_text_new (); 165 g_signal_connect ((gpointer) filename_renderer, "edited",
167 g_object_set (keywords_renderer, "editable", TRUE, NULL); 166 G_CALLBACK (on_renderer_edited),
168 167 (gpointer) & filename_col_num);
169 168 g_signal_connect ((gpointer) title_renderer, "edited",
170 g_signal_connect ((gpointer) filename_renderer, "edited", 169 G_CALLBACK (on_renderer_edited),
171 G_CALLBACK (on_renderer_edited), 170 (gpointer) & title_col_num);
172 (gpointer) & filename_col_num); 171 g_signal_connect ((gpointer) artist_renderer, "edited",
173 g_signal_connect ((gpointer) title_renderer, "edited", 172 G_CALLBACK (on_renderer_edited),
174 G_CALLBACK (on_renderer_edited), 173 (gpointer) & artist_col_num);
175 (gpointer) & title_col_num); 174 g_signal_connect ((gpointer) album_renderer, "edited",
176 g_signal_connect ((gpointer) artist_renderer, "edited", 175 G_CALLBACK (on_renderer_edited),
177 G_CALLBACK (on_renderer_edited), 176 (gpointer) & album_col_num);
178 (gpointer) & artist_col_num); 177 g_signal_connect ((gpointer) type_renderer, "edited",
179 g_signal_connect ((gpointer) album_renderer, "edited", 178 G_CALLBACK (on_renderer_edited),
180 G_CALLBACK (on_renderer_edited), 179 (gpointer) & type_col_num);
181 (gpointer) & album_col_num); 180 g_signal_connect ((gpointer) format_renderer, "edited",
182 g_signal_connect ((gpointer) type_renderer, "edited", 181 G_CALLBACK (on_renderer_edited),
183 G_CALLBACK (on_renderer_edited), 182 (gpointer) & format_col_num);
184 (gpointer) & type_col_num); 183 g_signal_connect ((gpointer) keywords_renderer, "edited",
185 g_signal_connect ((gpointer) format_renderer, "edited", 184 G_CALLBACK (on_renderer_edited),
186 G_CALLBACK (on_renderer_edited), 185 (gpointer) & keywords_col_num);
187 (gpointer) & format_col_num); 186
188 g_signal_connect ((gpointer) keywords_renderer, "edited", 187 /* columns definition */
189 G_CALLBACK (on_renderer_edited), 188 filename_list_col =
190 (gpointer) & keywords_col_num); 189 gtk_tree_view_column_new_with_attributes (_
191 190 ("Published filename"),
192 /* columns definition */ 191 filename_renderer,
193 filename_list_col = 192 "text", FILENAME_COL, NULL);
194 gtk_tree_view_column_new_with_attributes (_ 193 title_list_col =
195 ("Published filename"), 194 gtk_tree_view_column_new_with_attributes (_("Title"),
196 filename_renderer, 195 title_renderer,
197 "text", 196 "text", TITLE_COL, NULL);
198 FILENAME_COL, NULL); 197 artist_list_col =
199 title_list_col = 198 gtk_tree_view_column_new_with_attributes (_("Artist"),
200 gtk_tree_view_column_new_with_attributes (_("Title"), 199 artist_renderer,
201 title_renderer, 200 "text", ARTIST_COL, NULL);
202 "text", TITLE_COL, 201 album_list_col =
203 NULL); 202 gtk_tree_view_column_new_with_attributes (_("Album"),
204 artist_list_col = 203 album_renderer,
205 gtk_tree_view_column_new_with_attributes (_("Artist"), 204 "text", ALBUM_COL, NULL);
206 artist_renderer, 205 type_list_col =
207 "text", ARTIST_COL, 206 gtk_tree_view_column_new_with_attributes (_("Type"),
208 NULL); 207 type_renderer,
209 album_list_col = 208 "text", TYPE_COL, NULL);
210 gtk_tree_view_column_new_with_attributes (_("Album"), 209 format_list_col =
211 album_renderer, 210 gtk_tree_view_column_new_with_attributes (_("Format"),
212 "text", ALBUM_COL, 211 format_renderer,
213 NULL); 212 "text", FORMAT_COL, NULL);
214 type_list_col = 213 keywords_list_col =
215 gtk_tree_view_column_new_with_attributes (_("Type"), 214 gtk_tree_view_column_new_with_attributes (_("Keywords"),
216 type_renderer, 215 keywords_renderer,
217 "text", TYPE_COL, 216 "text", KEYWORDS_COL, NULL);
218 NULL);
219 format_list_col =
220 gtk_tree_view_column_new_with_attributes (_("Format"),
221 format_renderer,
222 "text", FORMAT_COL,
223 NULL);
224 keywords_list_col =
225 gtk_tree_view_column_new_with_attributes (_("Keywords"),
226 keywords_renderer,
227 "text",
228 KEYWORDS_COL, NULL);
229 217
230/* Allow sorting for all columns */ 218/* Allow sorting for all columns */
231 gtk_tree_view_column_set_sort_column_id (filename_list_col, 219 gtk_tree_view_column_set_sort_column_id (filename_list_col, FILENAME_COL);
232 FILENAME_COL); 220 gtk_tree_view_column_set_sort_column_id (title_list_col, TITLE_COL);
233 gtk_tree_view_column_set_sort_column_id (title_list_col, TITLE_COL); 221 gtk_tree_view_column_set_sort_column_id (artist_list_col, ARTIST_COL);
234 gtk_tree_view_column_set_sort_column_id (artist_list_col, ARTIST_COL); 222 gtk_tree_view_column_set_sort_column_id (album_list_col, ALBUM_COL);
235 gtk_tree_view_column_set_sort_column_id (album_list_col, ALBUM_COL); 223 gtk_tree_view_column_set_sort_column_id (type_list_col, TYPE_COL);
236 gtk_tree_view_column_set_sort_column_id (type_list_col, TYPE_COL); 224 gtk_tree_view_column_set_sort_column_id (format_list_col, FORMAT_COL);
237 gtk_tree_view_column_set_sort_column_id (format_list_col, FORMAT_COL); 225 gtk_tree_view_column_set_sort_column_id (keywords_list_col, KEYWORDS_COL);
238 gtk_tree_view_column_set_sort_column_id (keywords_list_col, 226
239 KEYWORDS_COL); 227 /* Allow to resize all columns */
240 228 gtk_tree_view_column_set_resizable (filename_list_col, TRUE);
241 /* Allow to resize all columns */ 229 gtk_tree_view_column_set_resizable (title_list_col, TRUE);
242 gtk_tree_view_column_set_resizable (filename_list_col, TRUE); 230 gtk_tree_view_column_set_resizable (artist_list_col, TRUE);
243 gtk_tree_view_column_set_resizable (title_list_col, TRUE); 231 gtk_tree_view_column_set_resizable (album_list_col, TRUE);
244 gtk_tree_view_column_set_resizable (artist_list_col, TRUE); 232 gtk_tree_view_column_set_resizable (type_list_col, TRUE);
245 gtk_tree_view_column_set_resizable (album_list_col, TRUE); 233 gtk_tree_view_column_set_resizable (format_list_col, TRUE);
246 gtk_tree_view_column_set_resizable (type_list_col, TRUE); 234 gtk_tree_view_column_set_resizable (keywords_list_col, TRUE);
247 gtk_tree_view_column_set_resizable (format_list_col, TRUE); 235
248 gtk_tree_view_column_set_resizable (keywords_list_col, TRUE); 236 /* Hide unedeed columns */
249 237 gtk_tree_view_column_set_visible (artist_list_col, FALSE);
250 /* Hide unedeed columns */ 238 gtk_tree_view_column_set_visible (album_list_col, FALSE);
251 gtk_tree_view_column_set_visible (artist_list_col, FALSE); 239 gtk_tree_view_column_set_visible (type_list_col, FALSE);
252 gtk_tree_view_column_set_visible (album_list_col, FALSE); 240 gtk_tree_view_column_set_visible (keywords_list_col, FALSE);
253 gtk_tree_view_column_set_visible (type_list_col, FALSE); 241
254 gtk_tree_view_column_set_visible (keywords_list_col, FALSE); 242 /* Set a smart option */
255 243 gtk_tree_view_get_hover_expand (GTK_TREE_VIEW (filelist));
256 /* Set a smart option */ 244
257 gtk_tree_view_get_hover_expand (GTK_TREE_VIEW (filelist)); 245 /* add columns to view */
258 246 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), filename_list_col);
259 /* add columns to view */ 247 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), title_list_col);
260 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), 248 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), artist_list_col);
261 filename_list_col); 249 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), album_list_col);
262 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), 250 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), type_list_col);
263 title_list_col); 251 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), format_list_col);
264 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), 252 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), keywords_list_col);
265 artist_list_col); 253
266 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), 254 /* Expand columns */
267 album_list_col); 255 gtk_tree_view_column_set_expand (filename_list_col, TRUE);
268 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), type_list_col); 256 gtk_tree_view_column_set_expand (artist_list_col, TRUE);
269 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), 257 gtk_tree_view_column_set_expand (album_list_col, TRUE);
270 format_list_col); 258 gtk_tree_view_column_set_expand (type_list_col, TRUE);
271 gtk_tree_view_append_column (GTK_TREE_VIEW (filelist), 259 gtk_tree_view_column_set_expand (format_list_col, TRUE);
272 keywords_list_col); 260 gtk_tree_view_column_set_expand (keywords_list_col, TRUE);
273 261
274 /* Expand columns */ 262 /* Allow multiple selections */
275 gtk_tree_view_column_set_expand (filename_list_col, TRUE); 263 GtkTreeSelection *filelist_selection =
276 gtk_tree_view_column_set_expand (artist_list_col, TRUE); 264 gtk_tree_view_get_selection (GTK_TREE_VIEW (filelist));
277 gtk_tree_view_column_set_expand (album_list_col, TRUE); 265 gtk_tree_selection_set_mode (filelist_selection, GTK_SELECTION_MULTIPLE);
278 gtk_tree_view_column_set_expand (type_list_col, TRUE); 266
279 gtk_tree_view_column_set_expand (format_list_col, TRUE); 267
280 gtk_tree_view_column_set_expand (keywords_list_col, TRUE); 268
281 269 AlbumList = NULL;
282 /* Allow multiple selections */ 270 ArtistList = NULL;
283 GtkTreeSelection *filelist_selection = 271
284 gtk_tree_view_get_selection (GTK_TREE_VIEW (filelist)); 272 Extractors = EXTRACTOR_loadDefaultLibraries ();
285 gtk_tree_selection_set_mode (filelist_selection, 273 Extractors =
286 GTK_SELECTION_MULTIPLE); 274 EXTRACTOR_loadConfigLibraries (Extractors, "libextractor_filename");
287
288
289
290 AlbumList = NULL;
291 ArtistList = NULL;
292
293 Extractors = EXTRACTOR_loadDefaultLibraries ();
294 Extractors =
295 EXTRACTOR_loadConfigLibraries (Extractors,
296 "libextractor_filename");
297 275
298/* Create the popup menu */ 276/* Create the popup menu */
299 filelist_popup = gtk_menu_new (); 277 filelist_popup = gtk_menu_new ();
300 GtkWidget *select_all_menu_item = 278 GtkWidget *select_all_menu_item =
301 gtk_menu_item_new_with_label (_("Select all files")); 279 gtk_menu_item_new_with_label (_("Select all files"));
302 GtkWidget *delete_menu_item = 280 GtkWidget *delete_menu_item =
303 gtk_menu_item_new_with_label (_("Remove selected files")); 281 gtk_menu_item_new_with_label (_("Remove selected files"));
304 gtk_menu_attach (GTK_MENU (filelist_popup), select_all_menu_item, 0, 282 gtk_menu_attach (GTK_MENU (filelist_popup), select_all_menu_item, 0,
305 1, 0, 1); 283 1, 0, 1);
306 gtk_menu_attach (GTK_MENU (filelist_popup), delete_menu_item, 0, 1, 1, 284 gtk_menu_attach (GTK_MENU (filelist_popup), delete_menu_item, 0, 1, 1, 2);
307 2); 285 gtk_widget_show (select_all_menu_item);
308 gtk_widget_show (select_all_menu_item); 286 gtk_widget_show (delete_menu_item);
309 gtk_widget_show (delete_menu_item); 287 gtk_signal_connect (GTK_OBJECT (filelist), "button-press-event",
310 gtk_signal_connect (GTK_OBJECT (filelist), "button-press-event", 288 GTK_SIGNAL_FUNC (popup_delete), (gpointer) NULL);
311 GTK_SIGNAL_FUNC (popup_delete), (gpointer) NULL); 289 gtk_signal_connect (GTK_OBJECT (select_all_menu_item), "activate",
312 gtk_signal_connect (GTK_OBJECT (select_all_menu_item), "activate", 290 GTK_SIGNAL_FUNC (select_all_files), (gpointer) TRUE);
313 GTK_SIGNAL_FUNC (select_all_files), 291 gtk_signal_connect (GTK_OBJECT (delete_menu_item), "activate",
314 (gpointer) TRUE); 292 GTK_SIGNAL_FUNC (remove_file_from_list),
315 gtk_signal_connect (GTK_OBJECT (delete_menu_item), "activate", 293 (gpointer) NULL);
316 GTK_SIGNAL_FUNC (remove_file_from_list), 294
317 (gpointer) NULL); 295 /*
318 296 * show the main window
319 /* 297 */
320 * show the main window 298 gtk_widget_show (musicinsertdialog);
321 */
322 gtk_widget_show (musicinsertdialog);
323} 299}
324 300
325/** 301/**
@@ -329,18 +305,17 @@ show_musicinsertdialog ()
329 */ 305 */
330EXTRACTOR_KeywordList * 306EXTRACTOR_KeywordList *
331get_EXTRACTORKeywords (const EXTRACTOR_ExtractorList 307get_EXTRACTORKeywords (const EXTRACTOR_ExtractorList
332 * exList, const char *filename) 308 * exList, const char *filename)
333{ 309{
334 EXTRACTOR_KeywordList *keyList; 310 EXTRACTOR_KeywordList *keyList;
335 311
336 keyList = 312 keyList =
337 EXTRACTOR_getKeywords ((EXTRACTOR_ExtractorList *) exList, 313 EXTRACTOR_getKeywords ((EXTRACTOR_ExtractorList *) exList, filename);
338 filename); 314 keyList =
339 keyList = 315 EXTRACTOR_removeDuplicateKeywords (keyList,
340 EXTRACTOR_removeDuplicateKeywords (keyList, 316 EXTRACTOR_DUPLICATES_REMOVE_UNKNOWN);
341 EXTRACTOR_DUPLICATES_REMOVE_UNKNOWN); 317 keyList = EXTRACTOR_removeEmptyKeywords (keyList);
342 keyList = EXTRACTOR_removeEmptyKeywords (keyList); 318 return keyList;
343 return keyList;
344} 319}
345 320
346 321
@@ -352,90 +327,75 @@ get_EXTRACTORKeywords (const EXTRACTOR_ExtractorList
352void 327void
353set_File_Keywords (const gchar * filename) 328set_File_Keywords (const gchar * filename)
354{ 329{
355 char *keywords[7]; 330 char *keywords[7];
356 GtkTreeIter pIter; 331 GtkTreeIter pIter;
357 332
358 EXTRACTOR_KeywordList *KeywordList = 333 EXTRACTOR_KeywordList *KeywordList =
359 get_EXTRACTORKeywords (Extractors, filename); 334 get_EXTRACTORKeywords (Extractors, filename);
360 335
361 336
362 keywords[0] = 337 keywords[0] =
363 (char *) EXTRACTOR_extractLast (EXTRACTOR_FILENAME, 338 (char *) EXTRACTOR_extractLast (EXTRACTOR_FILENAME, KeywordList);
364 KeywordList); 339
365 340 keywords[1] =
366 keywords[1] = 341 (char *) EXTRACTOR_extractLast (EXTRACTOR_FILENAME, KeywordList);
367 (char *) EXTRACTOR_extractLast (EXTRACTOR_FILENAME, 342
368 KeywordList); 343 keywords[2] = (char *) EXTRACTOR_extractLast (EXTRACTOR_TITLE, KeywordList);
369 344
370 keywords[2] = 345 keywords[3] =
371 (char *) EXTRACTOR_extractLast (EXTRACTOR_TITLE, KeywordList); 346 (char *) EXTRACTOR_extractLast (EXTRACTOR_ARTIST, KeywordList);
372 347 if (keywords[3] != '\0'
373 keywords[3] = 348 &&
374 (char *) EXTRACTOR_extractLast (EXTRACTOR_ARTIST, 349 (g_list_find_custom
375 KeywordList); 350 (ArtistList, keywords[3], (GCompareFunc) strcmp) == NULL))
376 if (keywords[3] != '\0' 351 {
377 && 352 ArtistList = g_list_append (ArtistList, STRDUP (keywords[3]));
378 (g_list_find_custom 353 gtk_combo_box_append_text (GTK_COMBO_BOX (artistcombobox), keywords[3]);
379 (ArtistList, keywords[3], (GCompareFunc) strcmp) == NULL)) 354 }
380 { 355
381 ArtistList = g_list_append (ArtistList, STRDUP (keywords[3])); 356 keywords[4] = (char *) EXTRACTOR_extractLast (EXTRACTOR_ALBUM, KeywordList);
382 gtk_combo_box_append_text (GTK_COMBO_BOX 357 if (keywords[4] != '\0'
383 (artistcombobox), keywords[3]); 358 &&
384 } 359 (g_list_find_custom
385 360 (AlbumList, keywords[4], (GCompareFunc) strcmp)) == NULL)
386 keywords[4] = 361 {
387 (char *) EXTRACTOR_extractLast (EXTRACTOR_ALBUM, KeywordList); 362 AlbumList = g_list_append (AlbumList, STRDUP (keywords[4]));
388 if (keywords[4] != '\0' 363 gtk_combo_box_append_text (GTK_COMBO_BOX (albumcombobox), keywords[4]);
389 && 364 }
390 (g_list_find_custom 365
391 (AlbumList, keywords[4], (GCompareFunc) strcmp)) == NULL) 366 keywords[5] =
392 { 367 (char *) EXTRACTOR_extractLast (EXTRACTOR_MIMETYPE, KeywordList);
393 AlbumList = g_list_append (AlbumList, STRDUP (keywords[4])); 368 if (keywords[5] != '\0')
394 gtk_combo_box_append_text (GTK_COMBO_BOX 369 {
395 (albumcombobox), keywords[4]); 370 if ((g_list_find_custom
396 } 371 (TypeList, keywords[5], (GCompareFunc) strcmp)) == NULL)
397 372 TypeList = g_list_append (TypeList, STRDUP (keywords[5]));
398 keywords[5] = 373
399 (char *) EXTRACTOR_extractLast (EXTRACTOR_MIMETYPE, 374 if (strcmp (keywords[5], "application/ogg") == 0)
400 KeywordList); 375 gtk_combo_box_set_active (GTK_COMBO_BOX (typecombobox), FORMAT_OGG);
401 if (keywords[5] != '\0') 376 else if (strcmp (keywords[5], "audio/mpeg") == 0)
402 { 377 gtk_combo_box_set_active (GTK_COMBO_BOX (typecombobox), FORMAT_MP3);
403 if ((g_list_find_custom 378 else if (strcmp (keywords[5], "application/x-wav") == 0)
404 (TypeList, keywords[5], (GCompareFunc) strcmp)) == NULL) 379 gtk_combo_box_set_active (GTK_COMBO_BOX (typecombobox), FORMAT_WAV);
405 TypeList = 380 else if (strcmp (keywords[5], "audio/vnd.rn-realaudio") == 0)
406 g_list_append (TypeList, 381 gtk_combo_box_set_active (GTK_COMBO_BOX (typecombobox), FORMAT_REAL);
407 STRDUP (keywords[5])); 382 }
408 383 else
409 if (strcmp (keywords[5], "application/ogg") == 0) 384 {
410 gtk_combo_box_set_active (GTK_COMBO_BOX 385 TypeList = g_list_append (TypeList, STRDUP ("unspecified"));
411 (typecombobox), FORMAT_OGG); 386 }
412 else if (strcmp (keywords[5], "audio/mpeg") == 0) 387
413 gtk_combo_box_set_active 388 keywords[6] =
414 (GTK_COMBO_BOX (typecombobox), FORMAT_MP3); 389 (char *) EXTRACTOR_extractLast (EXTRACTOR_FORMAT, KeywordList);
415 else if (strcmp (keywords[5], "application/x-wav") == 0) 390
416 gtk_combo_box_set_active 391 gtk_list_store_append (filelist_store, &pIter);
417 (GTK_COMBO_BOX (typecombobox), FORMAT_WAV); 392 gtk_list_store_set (filelist_store, &pIter, REAL_FILENAME_COL,
418 else if (strcmp (keywords[5], "audio/vnd.rn-realaudio") == 0) 393 keywords[0], FILENAME_COL, keywords[1], TITLE_COL,
419 gtk_combo_box_set_active 394 keywords[2], ARTIST_COL, keywords[3], ALBUM_COL,
420 (GTK_COMBO_BOX (typecombobox), FORMAT_REAL); 395 keywords[4], TYPE_COL, keywords[5], FORMAT_COL,
421 } 396 keywords[6], KEYWORDS_COL, "", -1);
422 else 397 EXTRACTOR_freeKeywords (KeywordList);
423 { 398 return;
424 TypeList = g_list_append (TypeList, STRDUP ("unspecified"));
425 }
426
427 keywords[6] =
428 (char *) EXTRACTOR_extractLast (EXTRACTOR_FORMAT,
429 KeywordList);
430
431 gtk_list_store_append (filelist_store, &pIter);
432 gtk_list_store_set (filelist_store, &pIter, REAL_FILENAME_COL,
433 keywords[0], FILENAME_COL, keywords[1], TITLE_COL,
434 keywords[2], ARTIST_COL, keywords[3], ALBUM_COL,
435 keywords[4], TYPE_COL, keywords[5], FORMAT_COL,
436 keywords[6], KEYWORDS_COL, "", -1);
437 EXTRACTOR_freeKeywords (KeywordList);
438 return;
439} 399}
440 400
441/** 401/**
@@ -445,28 +405,28 @@ void
445activateComboBoxes () 405activateComboBoxes ()
446{ 406{
447 407
448 if (gtk_combo_box_get_active (GTK_COMBO_BOX (albumcombobox)) < 0 408 if (gtk_combo_box_get_active (GTK_COMBO_BOX (albumcombobox)) < 0
449 && 409 &&
450 gtk_tree_model_iter_n_children (gtk_combo_box_get_model 410 gtk_tree_model_iter_n_children (gtk_combo_box_get_model
451 (GTK_COMBO_BOX (albumcombobox)), 411 (GTK_COMBO_BOX (albumcombobox)),
452 NULL) != 0) 412 NULL) != 0)
453 gtk_combo_box_set_active (GTK_COMBO_BOX (albumcombobox), 0); 413 gtk_combo_box_set_active (GTK_COMBO_BOX (albumcombobox), 0);
454 414
455 if (gtk_combo_box_get_active (GTK_COMBO_BOX (artistcombobox)) < 0 415 if (gtk_combo_box_get_active (GTK_COMBO_BOX (artistcombobox)) < 0
456 && 416 &&
457 gtk_tree_model_iter_n_children (gtk_combo_box_get_model 417 gtk_tree_model_iter_n_children (gtk_combo_box_get_model
458 (GTK_COMBO_BOX (artistcombobox)), 418 (GTK_COMBO_BOX (artistcombobox)),
459 NULL) != 0) 419 NULL) != 0)
460 gtk_combo_box_set_active (GTK_COMBO_BOX (artistcombobox), 0); 420 gtk_combo_box_set_active (GTK_COMBO_BOX (artistcombobox), 0);
461 421
462 if (gtk_combo_box_get_active (GTK_COMBO_BOX (typecombobox)) < 0 422 if (gtk_combo_box_get_active (GTK_COMBO_BOX (typecombobox)) < 0
463 && 423 &&
464 gtk_tree_model_iter_n_children (gtk_combo_box_get_model 424 gtk_tree_model_iter_n_children (gtk_combo_box_get_model
465 (GTK_COMBO_BOX (typecombobox)), 425 (GTK_COMBO_BOX (typecombobox)),
466 NULL) != 0) 426 NULL) != 0)
467 gtk_combo_box_set_active (GTK_COMBO_BOX (typecombobox), 0); 427 gtk_combo_box_set_active (GTK_COMBO_BOX (typecombobox), 0);
468 428
469 return; 429 return;
470} 430}
471 431
472/** 432/**
@@ -475,205 +435,198 @@ activateComboBoxes ()
475void 435void
476updateColumns () 436updateColumns ()
477{ 437{
478 if (g_list_length (ArtistList) > 1) 438 if (g_list_length (ArtistList) > 1)
479 gtk_tree_view_column_set_visible (type_list_col, TRUE); 439 gtk_tree_view_column_set_visible (type_list_col, TRUE);
480 else 440 else
481 gtk_tree_view_column_set_visible (type_list_col, FALSE); 441 gtk_tree_view_column_set_visible (type_list_col, FALSE);
482 442
483 if (g_list_length (AlbumList) > 1) 443 if (g_list_length (AlbumList) > 1)
484 gtk_tree_view_column_set_visible (type_list_col, TRUE); 444 gtk_tree_view_column_set_visible (type_list_col, TRUE);
485 else 445 else
486 gtk_tree_view_column_set_visible (type_list_col, FALSE); 446 gtk_tree_view_column_set_visible (type_list_col, FALSE);
487 447
488 if (g_list_length (TypeList) > 1) 448 if (g_list_length (TypeList) > 1)
489 gtk_tree_view_column_set_visible (type_list_col, TRUE); 449 gtk_tree_view_column_set_visible (type_list_col, TRUE);
490 else 450 else
491 gtk_tree_view_column_set_visible (type_list_col, FALSE); 451 gtk_tree_view_column_set_visible (type_list_col, FALSE);
492 452
493 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE 453 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
494 (filelist_store), FILENAME_COL, 454 (filelist_store), FILENAME_COL,
495 GTK_SORT_ASCENDING); 455 GTK_SORT_ASCENDING);
496} 456}
497 457
498gboolean 458gboolean
499insertfiles () 459insertfiles ()
500{ 460{
501 struct ECRS_MetaData *dirmetadata; 461 struct ECRS_MetaData *dirmetadata;
502 struct ECRS_MetaData *tempmetadata; 462 struct ECRS_MetaData *tempmetadata;
503 GArray *filesmetadatas, *files; 463 GArray *filesmetadatas, *files;
504 gchar *temptext; 464 gchar *temptext;
505 gchar **dirkeywords; 465 gchar **dirkeywords;
506 gchararray *tempkeywords; 466 gchararray *tempkeywords;
507 gchar **tempmetas, *dirmetas[8]; 467 gchar **tempmetas, *dirmetas[8];
508 gchar *separator = ";"; 468 gchar *separator = ";";
509 int i, n; 469 int i, n;
510 guint useforallflags; 470 guint useforallflags;
511 GtkWidget *keywordsentry; 471 GtkWidget *keywordsentry;
512 GtkTreeIter fileiter; 472 GtkTreeIter fileiter;
513 GtkToggleButton *artisttogglebutton; 473 GtkToggleButton *artisttogglebutton;
514 GtkToggleButton *albumtogglebutton; 474 GtkToggleButton *albumtogglebutton;
515 GtkToggleButton *keywordstogglebutton; 475 GtkToggleButton *keywordstogglebutton;
516 GtkToggleButton *commentstogglebutton; 476 GtkToggleButton *commentstogglebutton;
517 477
518 /* Test if files are present */ 478 /* Test if files are present */
519 if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (filelist_store), 479 if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (filelist_store),
520 &fileiter)) 480 &fileiter))
521 { 481 {
522 gchar *error_message = 482 gchar *error_message =
523 STRDUP (_ 483 STRDUP (_
524 ("No files to insert ! Please add files to the list before validating.")); 484 ("No files to insert ! Please add files to the list before validating."));
525 GtkWidget *message_dialog = 485 GtkWidget *message_dialog =
526 gtk_message_dialog_new (GTK_WINDOW 486 gtk_message_dialog_new (GTK_WINDOW (musicinsertdialog),
527 (musicinsertdialog), 487 GTK_DIALOG_DESTROY_WITH_PARENT,
528 GTK_DIALOG_DESTROY_WITH_PARENT, 488 GTK_MESSAGE_ERROR,
529 GTK_MESSAGE_ERROR, 489 GTK_BUTTONS_CLOSE,
530 GTK_BUTTONS_CLOSE, 490 "%s", error_message);
531 "%s", error_message); 491 gtk_dialog_run (GTK_DIALOG (message_dialog));
532 gtk_dialog_run (GTK_DIALOG (message_dialog)); 492 gtk_widget_destroy (message_dialog);
533 gtk_widget_destroy (message_dialog); 493 FREE (error_message);
534 FREE (error_message); 494 return FALSE;
535 return FALSE; 495 }
536 } 496
537 497
538 498 /* Manage album metadatas */
539 /* Manage album metadatas */ 499
540 500 dirmetadata = ECRS_createMetaData ();
541 dirmetadata = ECRS_createMetaData (); 501
542 502 dirmetas[0] =
543 dirmetas[0] = 503 gtk_combo_box_get_active_text (GTK_COMBO_BOX (artistcombobox));
544 gtk_combo_box_get_active_text (GTK_COMBO_BOX 504 if (dirmetas[0])
545 (artistcombobox)); 505 ECRS_addToMetaData (dirmetadata, EXTRACTOR_ARTIST, dirmetas[0]);
546 if (dirmetas[0]) 506
547 ECRS_addToMetaData (dirmetadata, EXTRACTOR_ARTIST, dirmetas[0]); 507 dirmetas[1] = gtk_combo_box_get_active_text (GTK_COMBO_BOX (albumcombobox));
548 508 if (dirmetas[1])
549 dirmetas[1] = 509 ECRS_addToMetaData (dirmetadata, EXTRACTOR_ALBUM, dirmetas[1]);
550 gtk_combo_box_get_active_text (GTK_COMBO_BOX (albumcombobox)); 510
551 if (dirmetas[1]) 511 keywordsentry = glade_xml_get_widget (musicinsertXML, "keywordsentry");
552 ECRS_addToMetaData (dirmetadata, EXTRACTOR_ALBUM, dirmetas[1]); 512 temptext = (gchar *) gtk_entry_get_text (GTK_ENTRY (keywordsentry));
553 513 dirkeywords = NULL;
554 keywordsentry = 514 if (temptext)
555 glade_xml_get_widget (musicinsertXML, "keywordsentry"); 515 dirkeywords = g_strsplit (temptext, separator, 255);
556 temptext = (gchar *) gtk_entry_get_text (GTK_ENTRY (keywordsentry)); 516 n = 0;
557 dirkeywords = NULL; 517 while (dirkeywords[n])
558 if (temptext) 518 {
559 dirkeywords = g_strsplit (temptext, separator, 255); 519 ECRS_addToMetaData (dirmetadata, EXTRACTOR_KEYWORDS, dirkeywords[n]);
560 n = 0; 520 n++;
561 while (dirkeywords[n]) 521 }
562 { 522 /* Add a standard keyword to allow finding all available music albums
563 ECRS_addToMetaData (dirmetadata, EXTRACTOR_KEYWORDS, dirkeywords[n]); 523 * on AFS in one search */
564 n++; 524 ECRS_addToMetaData (dirmetadata, EXTRACTOR_KEYWORDS, "music album");
565 } 525
566 /* Add a standard keyword to allow finding all available music albums 526
567 * on AFS in one search */ 527 /* Manage files metadatas */
568 ECRS_addToMetaData (dirmetadata, 528 artisttogglebutton =
569 EXTRACTOR_KEYWORDS, 529 GTK_TOGGLE_BUTTON (glade_xml_get_widget
570 "music album"); 530 (musicinsertXML, "artisttogglebutton"));
571 531 albumtogglebutton =
572 532 GTK_TOGGLE_BUTTON (glade_xml_get_widget
573 /* Manage files metadatas */ 533 (musicinsertXML, "albumtogglebutton"));
574 artisttogglebutton = GTK_TOGGLE_BUTTON(glade_xml_get_widget (musicinsertXML, "artisttogglebutton")); 534 keywordstogglebutton =
575 albumtogglebutton = GTK_TOGGLE_BUTTON(glade_xml_get_widget (musicinsertXML, "albumtogglebutton")); 535 GTK_TOGGLE_BUTTON (glade_xml_get_widget
576 keywordstogglebutton = GTK_TOGGLE_BUTTON(glade_xml_get_widget (musicinsertXML, "keywordstogglebutton")); 536 (musicinsertXML, "keywordstogglebutton"));
577 commentstogglebutton = GTK_TOGGLE_BUTTON(glade_xml_get_widget (musicinsertXML, "commentstogglebutton")); 537 commentstogglebutton =
578 538 GTK_TOGGLE_BUTTON (glade_xml_get_widget
579 useforallflags = 0; 539 (musicinsertXML, "commentstogglebutton"));
580 useforallflags = gtk_toggle_button_get_active (artisttogglebutton) << 0; 540
581 useforallflags = gtk_toggle_button_get_active (albumtogglebutton) << 1; 541 useforallflags = 0;
582 useforallflags = gtk_toggle_button_get_active (keywordstogglebutton) << 2; 542 useforallflags = gtk_toggle_button_get_active (artisttogglebutton) << 0;
583 useforallflags = gtk_toggle_button_get_active (commentstogglebutton) << 3; 543 useforallflags = gtk_toggle_button_get_active (albumtogglebutton) << 1;
584 544 useforallflags = gtk_toggle_button_get_active (keywordstogglebutton) << 2;
585 filesmetadatas = g_array_sized_new (FALSE, FALSE, sizeof (struct ECRS_MetaData *), 20); 545 useforallflags = gtk_toggle_button_get_active (commentstogglebutton) << 3;
586 files = g_array_sized_new (FALSE, FALSE, sizeof (gchar *), 20); 546
587 i = 0; 547 filesmetadatas =
588 do 548 g_array_sized_new (FALSE, FALSE, sizeof (struct ECRS_MetaData *), 20);
589 { 549 files = g_array_sized_new (FALSE, FALSE, sizeof (gchar *), 20);
590 tempmetadata = ECRS_createMetaData(); 550 i = 0;
591 tempmetas = malloc (sizeof(gchar *) * 8); 551 do
592 g_array_append_val (filesmetadatas, tempmetadata); 552 {
593 gtk_tree_model_get (GTK_TREE_MODEL (filelist_store), 553 tempmetadata = ECRS_createMetaData ();
594 &fileiter, 554 tempmetas = malloc (sizeof (gchar *) * 8);
595 REAL_FILENAME_COL, &tempmetas[0], 555 g_array_append_val (filesmetadatas, tempmetadata);
596 FILENAME_COL, &tempmetas[1], 556 gtk_tree_model_get (GTK_TREE_MODEL (filelist_store),
597 TITLE_COL, &tempmetas[2], 557 &fileiter,
598 ARTIST_COL, &tempmetas[3], 558 REAL_FILENAME_COL, &tempmetas[0],
599 ALBUM_COL, &tempmetas[4], 559 FILENAME_COL, &tempmetas[1],
600 TYPE_COL, &tempmetas[5], 560 TITLE_COL, &tempmetas[2],
601 FORMAT_COL, &tempmetas[6], 561 ARTIST_COL, &tempmetas[3],
602 KEYWORDS_COL, &tempmetas[7], 562 ALBUM_COL, &tempmetas[4],
603 -1); 563 TYPE_COL, &tempmetas[5],
604 g_array_append_val (files, tempmetas[0]); 564 FORMAT_COL, &tempmetas[6],
605 565 KEYWORDS_COL, &tempmetas[7], -1);
606 566 g_array_append_val (files, tempmetas[0]);
607 if (tempmetas[1]) 567
608 ECRS_addToMetaData (tempmetadata, EXTRACTOR_FILENAME, 568
609 tempmetas[1]); 569 if (tempmetas[1])
610 if ((useforallflags & 0x1) && dirmetas[0]) 570 ECRS_addToMetaData (tempmetadata, EXTRACTOR_FILENAME, tempmetas[1]);
611 ECRS_addToMetaData (tempmetadata, EXTRACTOR_FILENAME, 571 if ((useforallflags & 0x1) && dirmetas[0])
612 dirmetas[0]); 572 ECRS_addToMetaData (tempmetadata, EXTRACTOR_FILENAME, dirmetas[0]);
613 else if (!(useforallflags & 0x1) && tempmetas[2]) 573 else if (!(useforallflags & 0x1) && tempmetas[2])
614 ECRS_addToMetaData (tempmetadata, EXTRACTOR_TITLE, 574 ECRS_addToMetaData (tempmetadata, EXTRACTOR_TITLE, tempmetas[2]);
615 tempmetas[2]); 575 if ((useforallflags & 0x2) && dirmetas[1])
616 if ((useforallflags & 0x2) && dirmetas[1]) 576 ECRS_addToMetaData (tempmetadata, EXTRACTOR_ARTIST, dirmetas[1]);
617 ECRS_addToMetaData (tempmetadata, EXTRACTOR_ARTIST, 577 else if (!(useforallflags & 0x2) && tempmetas[3])
618 dirmetas[1]); 578 ECRS_addToMetaData (tempmetadata, EXTRACTOR_FILENAME, tempmetas[3]);
619 else if (!(useforallflags & 0x2)&& tempmetas[3]) 579 if (tempmetas[4])
620 ECRS_addToMetaData (tempmetadata, EXTRACTOR_FILENAME, 580 ECRS_addToMetaData (tempmetadata, EXTRACTOR_ALBUM, tempmetas[4]);
621 tempmetas[3]); 581 if (tempmetas[5])
622 if (tempmetas[4]) 582 ECRS_addToMetaData (tempmetadata, EXTRACTOR_MIMETYPE, tempmetas[5]);
623 ECRS_addToMetaData (tempmetadata, EXTRACTOR_ALBUM, 583 if (tempmetas[6])
624 tempmetas[4]); 584 ECRS_addToMetaData (tempmetadata, EXTRACTOR_FORMAT, tempmetas[6]);
625 if (tempmetas[5]) 585
626 ECRS_addToMetaData (tempmetadata, EXTRACTOR_MIMETYPE, 586 if (!(useforallflags & 0x1))
627 tempmetas[5]); 587 {
628 if (tempmetas[6]) 588 n = 0;
629 ECRS_addToMetaData (tempmetadata, EXTRACTOR_FORMAT, 589 while (dirkeywords[n])
630 tempmetas[6]); 590 {
631 591 ECRS_addToMetaData (tempmetadata, EXTRACTOR_KEYWORDS,
632 if (!(useforallflags & 0x1)) 592 dirkeywords[n]);
633 { 593 n++;
634 n = 0; 594 }
635 while (dirkeywords[n]) 595 }
636 { 596 else if (tempmetas[7])
637 ECRS_addToMetaData (tempmetadata, EXTRACTOR_KEYWORDS, dirkeywords[n]); 597 {
638 n++; 598 tempkeywords = g_strsplit (temptext, separator, 255);
639 } 599 n = 0;
640 } 600 while (tempkeywords[n])
641 else if (tempmetas[7]) 601 {
642 { 602 ECRS_addToMetaData (tempmetadata,
643 tempkeywords = g_strsplit (temptext, separator, 255); 603 EXTRACTOR_KEYWORDS, tempkeywords[n]);
644 n = 0; 604 n++;
645 while (tempkeywords[n]) 605 }
646 { 606 g_strfreev (tempkeywords);
647 ECRS_addToMetaData (tempmetadata, 607 /* Add a standard keyword to allow finding all available music files
648 EXTRACTOR_KEYWORDS, 608 * on AFS in one search */
649 tempkeywords[n]); 609 ECRS_addToMetaData (tempmetadata, EXTRACTOR_KEYWORDS, "music");
650 n++; 610 }
651 } 611
652 g_strfreev (tempkeywords); 612 FREE (tempmetas);
653 /* Add a standard keyword to allow finding all available music files 613 i++;
654 * on AFS in one search */ 614 }
655 ECRS_addToMetaData (tempmetadata, 615 while (gtk_tree_model_iter_next
656 EXTRACTOR_KEYWORDS, 616 (GTK_TREE_MODEL (filelist_store), &fileiter));
657 "music"); 617
658 } 618 g_strfreev (dirkeywords);
659 619
660 FREE (tempmetas); 620 /* TODO : take care of the 'Insert as an album'/'Insert files separately' options
661 i++; 621 * and create or not a gnunet directory containing the files
662 } 622 *
663 while (gtk_tree_model_iter_next (GTK_TREE_MODEL(filelist_store), &fileiter)); 623 * TODO : Create a file and album description from metadatas - an idea :
664 624 * Artist: Song (Album) - Type and Format # for files
665 g_strfreev (dirkeywords); 625 * Artist: Album - Type and number of the files # or album
666 626 *
667 /* TODO : take care of the 'Insert as an album'/'Insert files separately' options 627 * TODO : really call FSUI_upload() to insert these files */
668 * and create or not a gnunet directory containing the files 628
669 * 629 return TRUE;
670 * TODO : Create a file and album description from metadatas - an idea :
671 * Artist: Song (Album) - Type and Format # for files
672 * Artist: Album - Type and number of the files # or album
673 *
674 * TODO : really call FSUI_upload() to insert these files */
675
676 return TRUE;
677} 630}
678 631
679/* Callback functions */ 632/* Callback functions */
@@ -684,9 +637,9 @@ insertfiles ()
684void 637void
685on_musicinsertdialog_destroy (GtkObject * object, gpointer user_data) 638on_musicinsertdialog_destroy (GtkObject * object, gpointer user_data)
686{ 639{
687 EXTRACTOR_removeAll (Extractors); 640 EXTRACTOR_removeAll (Extractors);
688 UNREF (musicinsertXML); 641 UNREF (musicinsertXML);
689 musicinsertXML = NULL; 642 musicinsertXML = NULL;
690} 643}
691 644
692/** 645/**
@@ -695,8 +648,8 @@ on_musicinsertdialog_destroy (GtkObject * object, gpointer user_data)
695void 648void
696on_cancelbutton_clicked (GtkButton * button, gpointer user_data) 649on_cancelbutton_clicked (GtkButton * button, gpointer user_data)
697{ 650{
698 gtk_widget_destroy (musicinsertdialog); 651 gtk_widget_destroy (musicinsertdialog);
699 return; 652 return;
700} 653}
701 654
702/** 655/**
@@ -705,9 +658,9 @@ on_cancelbutton_clicked (GtkButton * button, gpointer user_data)
705void 658void
706on_okbutton_clicked (GtkButton * button, gpointer user_data) 659on_okbutton_clicked (GtkButton * button, gpointer user_data)
707{ 660{
708 if (insertfiles ()) 661 if (insertfiles ())
709 gtk_widget_destroy (musicinsertdialog); 662 gtk_widget_destroy (musicinsertdialog);
710 return ; 663 return;
711} 664}
712 665
713/** 666/**
@@ -716,112 +669,98 @@ on_okbutton_clicked (GtkButton * button, gpointer user_data)
716void 669void
717on_diraddbutton_clicked (GtkButton * button, gpointer user_data) 670on_diraddbutton_clicked (GtkButton * button, gpointer user_data)
718{ 671{
719 gchar *path; 672 gchar *path;
720 GtkWidget *musicinsertdialog = 673 GtkWidget *musicinsertdialog =
721 glade_xml_get_widget (musicinsertXML, "musicinsertdialog"); 674 glade_xml_get_widget (musicinsertXML, "musicinsertdialog");
722 /* choose the directory to list */ 675 /* choose the directory to list */
723 GtkWidget *filechooser = 676 GtkWidget *filechooser =
724 gtk_file_chooser_dialog_new (_ 677 gtk_file_chooser_dialog_new (_("Choose the directory to insert..."),
725 ("Choose the directory to insert..."), 678 GTK_WINDOW (musicinsertdialog),
726GTK_WINDOW (musicinsertdialog), 679 GTK_FILE_CHOOSER_ACTION_OPEN,
727GTK_FILE_CHOOSER_ACTION_OPEN, 680 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
728GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 681 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
729GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, 682 NULL);
730NULL); 683 gtk_file_chooser_set_action (GTK_FILE_CHOOSER (filechooser),
731 gtk_file_chooser_set_action (GTK_FILE_CHOOSER (filechooser), 684 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
732 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); 685 gtk_window_set_modal (GTK_WINDOW (filechooser), TRUE);
733 gtk_window_set_modal (GTK_WINDOW (filechooser), TRUE); 686 switch (gtk_dialog_run (GTK_DIALOG (filechooser)))
734 switch (gtk_dialog_run (GTK_DIALOG (filechooser))) 687 {
735 { 688 case GTK_RESPONSE_ACCEPT:
736 case GTK_RESPONSE_ACCEPT: 689 /* get the path */
737 /* get the path */ 690 path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filechooser));
738 path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER 691 gtk_widget_destroy (filechooser);
739 (filechooser)); 692 break;
740 gtk_widget_destroy (filechooser); 693 default:
741 break; 694 gtk_widget_destroy (filechooser);
742 default: 695 return;
743 gtk_widget_destroy (filechooser); 696 }
744 return; 697
745 } 698 /* list directory and fill the fields */
746 699 GDir *directory;
747 /* list directory and fill the fields */ 700 GString *long_filename;
748 GDir *directory; 701 GError *dir_opening_error;
749 GString *long_filename; 702 GSList *file_error_list = NULL;
750 GError *dir_opening_error; 703 gchar *filename;
751 GSList *file_error_list = NULL; 704 if ((directory = g_dir_open (path, 0, &dir_opening_error)))
752 gchar *filename; 705 {
753 if ((directory = g_dir_open (path, 0, &dir_opening_error))) 706 while ((filename = (gchar *) g_dir_read_name (directory)))
754 { 707 {
755 while ((filename = (gchar *) g_dir_read_name (directory))) 708 long_filename = g_string_new (path);
756 { 709 g_string_append_c (long_filename, DIR_SEPARATOR);
757 long_filename = g_string_new (path); 710 g_string_append (long_filename, filename);
758 g_string_append_c (long_filename, DIR_SEPARATOR); 711 if (!(ACCESS (long_filename->str, F_OK | R_OK)))
759 g_string_append (long_filename, filename); 712 {
760 if (!(ACCESS (long_filename->str, F_OK | R_OK))) 713 if (!(g_file_test (long_filename->str, G_FILE_TEST_IS_DIR)))
761 { 714 set_File_Keywords (long_filename->str);
762 if (! 715 }
763 (g_file_test 716 else
764 (long_filename->str, 717 {
765 G_FILE_TEST_IS_DIR))) 718 file_error_list = g_slist_append (file_error_list, filename);
766 set_File_Keywords (long_filename-> 719 g_string_free (long_filename, TRUE);
767 str); 720 }
768 } 721 }
769 else 722
770 { 723 g_free (path);
771 file_error_list = 724 activateComboBoxes ();
772 g_slist_append (file_error_list, 725 updateColumns ();
773 filename); 726 if (g_slist_length (file_error_list) > 0)
774 g_string_free (long_filename, TRUE); 727 {
775 } 728 GString *file_error_message =
776 } 729 g_string_new (_
777 730 ("The following files won't be added for I could not read them :"));
778 g_free (path); 731 while ((file_error_list = g_slist_next (file_error_list)))
779 activateComboBoxes (); 732 {
780 updateColumns (); 733 g_string_append_c (file_error_message, '\n');
781 if (g_slist_length (file_error_list) > 0) 734 g_string_append (file_error_message,
782 { 735 (gchar *) file_error_list->data);
783 GString *file_error_message = 736 }
784 g_string_new (_ 737 GtkWidget *file_error_dialog =
785 ("The following files won't be added for I could not read them :")); 738 gtk_message_dialog_new (GTK_WINDOW (musicinsertdialog),
786 while ((file_error_list = 739 GTK_DIALOG_DESTROY_WITH_PARENT,
787 g_slist_next (file_error_list))) 740 GTK_MESSAGE_ERROR,
788 { 741 GTK_BUTTONS_CLOSE,
789 g_string_append_c (file_error_message, '\n'); 742 file_error_message->str);
790 g_string_append (file_error_message, 743 gtk_dialog_run (GTK_DIALOG (file_error_dialog));
791 (gchar *) file_error_list-> 744 gtk_widget_destroy (file_error_dialog);
792 data); 745 g_string_free (file_error_message, TRUE);
793 } 746 }
794 GtkWidget *file_error_dialog = 747 g_dir_close (directory);
795 gtk_message_dialog_new (GTK_WINDOW 748 }
796 (musicinsertdialog), 749 else
797 GTK_DIALOG_DESTROY_WITH_PARENT, 750 {
798 GTK_MESSAGE_ERROR, 751 gchar *error_message = STRDUP (_("Could not open the directory :\n"));
799 GTK_BUTTONS_CLOSE, 752 GtkWidget *message_dialog =
800 file_error_message-> 753 gtk_message_dialog_new (GTK_WINDOW (musicinsertdialog),
801 str); 754 GTK_DIALOG_DESTROY_WITH_PARENT,
802 gtk_dialog_run (GTK_DIALOG (file_error_dialog)); 755 GTK_MESSAGE_ERROR,
803 gtk_widget_destroy (file_error_dialog); 756 GTK_BUTTONS_CLOSE,
804 g_string_free (file_error_message, TRUE); 757 "%s%s", error_message,
805 } 758 dir_opening_error->message);
806 g_dir_close (directory); 759 gtk_dialog_run (GTK_DIALOG (message_dialog));
807 } 760 gtk_widget_destroy (message_dialog);
808 else 761 g_free (error_message);
809 { 762 g_error_free (dir_opening_error);
810 gchar *error_message = 763 }
811 STRDUP (_("Could not open the directory :\n"));
812 GtkWidget *message_dialog =
813 gtk_message_dialog_new (GTK_WINDOW
814 (musicinsertdialog),
815 GTK_DIALOG_DESTROY_WITH_PARENT,
816 GTK_MESSAGE_ERROR,
817 GTK_BUTTONS_CLOSE,
818 "%s%s", error_message,
819 dir_opening_error->message);
820 gtk_dialog_run (GTK_DIALOG (message_dialog));
821 gtk_widget_destroy (message_dialog);
822 g_free (error_message);
823 g_error_free (dir_opening_error);
824 }
825} 764}
826 765
827/** 766/**
@@ -830,82 +769,75 @@ NULL);
830void 769void
831on_fileaddbutton_clicked (GtkButton * button, gpointer user_data) 770on_fileaddbutton_clicked (GtkButton * button, gpointer user_data)
832{ 771{
833 GSList *pathlist; 772 GSList *pathlist;
834 GtkWidget *musicinsertdialog = 773 GtkWidget *musicinsertdialog =
835 glade_xml_get_widget (musicinsertXML, "musicinsertdialog"); 774 glade_xml_get_widget (musicinsertXML, "musicinsertdialog");
836 /* choose the file to add */ 775 /* choose the file to add */
837 GtkWidget *filechooser = 776 GtkWidget *filechooser =
838 gtk_file_chooser_dialog_new (_("Choose files to insert..."), 777 gtk_file_chooser_dialog_new (_("Choose files to insert..."),
839 GTK_WINDOW (musicinsertdialog), 778 GTK_WINDOW (musicinsertdialog),
840 GTK_FILE_CHOOSER_ACTION_OPEN, 779 GTK_FILE_CHOOSER_ACTION_OPEN,
841 GTK_STOCK_CANCEL, 780 GTK_STOCK_CANCEL,
842 GTK_RESPONSE_CANCEL, 781 GTK_RESPONSE_CANCEL,
843 GTK_STOCK_OPEN, 782 GTK_STOCK_OPEN,
844 GTK_RESPONSE_ACCEPT, NULL); 783 GTK_RESPONSE_ACCEPT, NULL);
845 gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (filechooser), 784 gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (filechooser), TRUE);
846 TRUE); 785 gtk_window_set_modal (GTK_WINDOW (filechooser), TRUE);
847 gtk_window_set_modal (GTK_WINDOW (filechooser), TRUE); 786
848 787 if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
849 if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT) 788 {
850 { 789 GSList *file_error_list = NULL;
851 GSList *file_error_list = NULL; 790 /* get the path */
852 /* get the path */ 791 pathlist =
853 pathlist = 792 gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser));
854 gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER 793 gtk_widget_destroy (filechooser);
855 (filechooser)); 794 do
856 gtk_widget_destroy (filechooser); 795 {
857 do 796 if (!(ACCESS (pathlist->data, F_OK | R_OK)))
858 { 797 {
859 if (!(ACCESS (pathlist->data, F_OK | R_OK))) 798 set_File_Keywords (pathlist->data);
860 { 799 }
861 set_File_Keywords (pathlist->data); 800 else
862 } 801 {
863 else 802 file_error_list =
864 { 803 g_slist_append (file_error_list, pathlist->data);
865 file_error_list = 804 }
866 g_slist_append (file_error_list, 805 }
867 pathlist->data); 806 while ((pathlist = g_slist_next (pathlist)));
868 } 807 g_slist_free (pathlist);
869 } 808
870 while ((pathlist = g_slist_next (pathlist))); 809 activateComboBoxes ();
871 g_slist_free (pathlist); 810 updateColumns ();
872 811
873 activateComboBoxes (); 812 if (g_slist_length (file_error_list) > 0)
874 updateColumns (); 813 {
875 814 GString *file_error_message =
876 if (g_slist_length (file_error_list) > 0) 815 g_string_new (_
877 { 816 ("The following files won't be added for I could not read them :"));
878 GString *file_error_message = 817 while ((file_error_list = g_slist_next (file_error_list)))
879 g_string_new (_ 818 {
880 ("The following files won't be added for I could not read them :")); 819 g_string_append_c (file_error_message, '\n');
881 while ((file_error_list = 820 g_string_append (file_error_message,
882 g_slist_next (file_error_list))) 821 (gchar *) file_error_list->data);
883 { 822 }
884 g_string_append_c (file_error_message, '\n'); 823
885 g_string_append (file_error_message, 824 GtkWidget *file_error_dialog =
886 (gchar *) file_error_list-> 825 gtk_message_dialog_new (GTK_WINDOW (musicinsertdialog),
887 data); 826 GTK_DIALOG_DESTROY_WITH_PARENT,
888 } 827 GTK_MESSAGE_ERROR,
889 828 GTK_BUTTONS_CLOSE,
890 GtkWidget *file_error_dialog = 829 file_error_message->str);
891 gtk_message_dialog_new (GTK_WINDOW 830 gtk_dialog_run (GTK_DIALOG (file_error_dialog));
892 (musicinsertdialog), 831 g_string_free (file_error_message, TRUE);
893 GTK_DIALOG_DESTROY_WITH_PARENT, 832 gtk_widget_destroy (file_error_dialog);
894 GTK_MESSAGE_ERROR, 833 }
895 GTK_BUTTONS_CLOSE, 834 return;
896 file_error_message-> 835 }
897 str); 836 else
898 gtk_dialog_run (GTK_DIALOG (file_error_dialog)); 837 {
899 g_string_free (file_error_message, TRUE); 838 gtk_widget_destroy (filechooser);
900 gtk_widget_destroy (file_error_dialog); 839 return;
901 } 840 }
902 return;
903 }
904 else
905 {
906 gtk_widget_destroy (filechooser);
907 return;
908 }
909} 841}
910 842
911/** 843/**
@@ -914,10 +846,9 @@ on_fileaddbutton_clicked (GtkButton * button, gpointer user_data)
914void 846void
915on_radioinsert_toggled (GtkRadioButton * radiobutton, gpointer user_data) 847on_radioinsert_toggled (GtkRadioButton * radiobutton, gpointer user_data)
916{ 848{
917 gtk_widget_set_sensitive (GTK_WIDGET 849 gtk_widget_set_sensitive (GTK_WIDGET
918 (glade_xml_get_widget 850 (glade_xml_get_widget
919 (musicinsertXML, "copyfilesbutton")), 851 (musicinsertXML, "copyfilesbutton")), FALSE);
920 FALSE);
921} 852}
922 853
923/** 854/**
@@ -926,75 +857,73 @@ on_radioinsert_toggled (GtkRadioButton * radiobutton, gpointer user_data)
926void 857void
927on_radioindex_toggled (GtkRadioButton * radiobutton, gpointer user_data) 858on_radioindex_toggled (GtkRadioButton * radiobutton, gpointer user_data)
928{ 859{
929 gtk_widget_set_sensitive 860 gtk_widget_set_sensitive
930 (GTK_WIDGET 861 (GTK_WIDGET
931 (glade_xml_get_widget (musicinsertXML, "copyfilesbutton")), 862 (glade_xml_get_widget (musicinsertXML, "copyfilesbutton")), TRUE);
932 TRUE);
933} 863}
934 864
935/** 865/**
936 * @brief Hide or show the album column when needed 866 * @brief Hide or show the album column when needed
937 */ 867 */
938void on_albumtogglebutton_toggled 868void on_albumtogglebutton_toggled
939 (GtkToggleButton * togglebutton, gpointer user_data) 869 (GtkToggleButton * togglebutton, gpointer user_data)
940{ 870{
941 if (gtk_toggle_button_get_active (togglebutton)) 871 if (gtk_toggle_button_get_active (togglebutton))
942 gtk_tree_view_column_set_visible (album_list_col, FALSE); 872 gtk_tree_view_column_set_visible (album_list_col, FALSE);
943 else 873 else
944 gtk_tree_view_column_set_visible (album_list_col, TRUE); 874 gtk_tree_view_column_set_visible (album_list_col, TRUE);
945} 875}
946 876
947/** 877/**
948 * @brief Hide or show the artist column when needed 878 * @brief Hide or show the artist column when needed
949 */ 879 */
950void on_artisttogglebutton_toggled 880void on_artisttogglebutton_toggled
951 (GtkToggleButton * togglebutton, gpointer user_data) 881 (GtkToggleButton * togglebutton, gpointer user_data)
952{ 882{
953 if (gtk_toggle_button_get_active (togglebutton)) 883 if (gtk_toggle_button_get_active (togglebutton))
954 gtk_tree_view_column_set_visible (artist_list_col, FALSE); 884 gtk_tree_view_column_set_visible (artist_list_col, FALSE);
955 else 885 else
956 gtk_tree_view_column_set_visible (artist_list_col, TRUE); 886 gtk_tree_view_column_set_visible (artist_list_col, TRUE);
957} 887}
958 888
959/** 889/**
960 * @brief Hide or show the keywords column when needed 890 * @brief Hide or show the keywords column when needed
961 */ 891 */
962void on_keywordstogglebutton_toggled 892void on_keywordstogglebutton_toggled
963 (GtkToggleButton * togglebutton, gpointer user_data) 893 (GtkToggleButton * togglebutton, gpointer user_data)
964{ 894{
965 if (gtk_toggle_button_get_active (togglebutton)) 895 if (gtk_toggle_button_get_active (togglebutton))
966 gtk_tree_view_column_set_visible (keywords_list_col, FALSE); 896 gtk_tree_view_column_set_visible (keywords_list_col, FALSE);
967 else 897 else
968 gtk_tree_view_column_set_visible (keywords_list_col, TRUE); 898 gtk_tree_view_column_set_visible (keywords_list_col, TRUE);
969} 899}
970 900
971/** 901/**
972 * @brief Make to user able to modify the per-file data 902 * @brief Make to user able to modify the per-file data
973 */ 903 */
974void on_renderer_edited 904void on_renderer_edited
975 (GtkCellRendererText * 905 (GtkCellRendererText *
976 cellrenderertext, 906 cellrenderertext,
977 gchar * path_string, gchar * new_text, gpointer user_data) 907 gchar * path_string, gchar * new_text, gpointer user_data)
978{ 908{
979 GtkTreePath *path = gtk_tree_path_new_from_string (path_string); 909 GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
980 GtkTreeIter iter; 910 GtkTreeIter iter;
981 gtk_tree_model_get_iter (GTK_TREE_MODEL (filelist_store), &iter, 911 gtk_tree_model_get_iter (GTK_TREE_MODEL (filelist_store), &iter, path);
982 path); 912 gtk_list_store_set (filelist_store, &iter,
983 gtk_list_store_set (filelist_store, &iter, 913 (gint) * ((gint *) user_data), new_text, -1);
984 (gint) * ((gint *) user_data), new_text, -1); 914 gtk_tree_path_free (path);
985 gtk_tree_path_free (path);
986} 915}
987 916
988gboolean 917gboolean
989popup_delete (GtkWidget * widget, GdkEventButton * event, gpointer user_data) 918popup_delete (GtkWidget * widget, GdkEventButton * event, gpointer user_data)
990{ 919{
991 if ((event->type == GDK_BUTTON_PRESS) && (event->button == 3)) 920 if ((event->type == GDK_BUTTON_PRESS) && (event->button == 3))
992 { 921 {
993 gtk_menu_popup (GTK_MENU (filelist_popup), NULL, NULL, NULL, 922 gtk_menu_popup (GTK_MENU (filelist_popup), NULL, NULL, NULL,
994 NULL, event->button, event->time); 923 NULL, event->button, event->time);
995 return TRUE; 924 return TRUE;
996 } 925 }
997 return FALSE; 926 return FALSE;
998} 927}
999 928
1000/** 929/**
@@ -1003,43 +932,40 @@ popup_delete (GtkWidget * widget, GdkEventButton * event, gpointer user_data)
1003void 932void
1004remove_file_from_list (gpointer user_data) 933remove_file_from_list (gpointer user_data)
1005{ 934{
1006 GtkTreeIter iter; 935 GtkTreeIter iter;
1007 GtkWidget *filelist = 936 GtkWidget *filelist = glade_xml_get_widget (musicinsertXML, "filelist");
1008 glade_xml_get_widget (musicinsertXML, "filelist"); 937 GtkTreeSelection *selection =
1009 GtkTreeSelection *selection = 938 gtk_tree_view_get_selection (GTK_TREE_VIEW (filelist));
1010 gtk_tree_view_get_selection (GTK_TREE_VIEW (filelist)); 939 GList *selected_paths = gtk_tree_selection_get_selected_rows (selection,
1011 GList *selected_paths = 940 (GtkTreeModel
1012 gtk_tree_selection_get_selected_rows (selection, 941 **) &
1013 (GtkTreeModel **) 942 filelist_store);
1014 &filelist_store); 943 GList *selected_refs = NULL;
1015 GList *selected_refs = NULL; 944 GtkTreePath *path;
1016 GtkTreePath *path;
1017/* Get static references from paths */ 945/* Get static references from paths */
1018 while (selected_paths) 946 while (selected_paths)
1019 { 947 {
1020 selected_refs = g_list_append (selected_refs, 948 selected_refs = g_list_append (selected_refs,
1021 gtk_tree_row_reference_new 949 gtk_tree_row_reference_new
1022 (GTK_TREE_MODEL 950 (GTK_TREE_MODEL
1023 (filelist_store), 951 (filelist_store),
1024 selected_paths->data)); 952 selected_paths->data));
1025 selected_paths = g_list_next (selected_paths); 953 selected_paths = g_list_next (selected_paths);
1026 } 954 }
1027 g_list_foreach (selected_paths, (GFunc) gtk_tree_path_free, NULL); 955 g_list_foreach (selected_paths, (GFunc) gtk_tree_path_free, NULL);
1028 g_list_free (selected_paths); 956 g_list_free (selected_paths);
1029 957
1030/* Remove items from references */ 958/* Remove items from references */
1031 while (selected_refs) 959 while (selected_refs)
1032 { 960 {
1033 path = gtk_tree_row_reference_get_path (selected_refs->data); 961 path = gtk_tree_row_reference_get_path (selected_refs->data);
1034 gtk_tree_model_get_iter (GTK_TREE_MODEL (filelist_store), 962 gtk_tree_model_get_iter (GTK_TREE_MODEL (filelist_store), &iter, path);
1035 &iter, path); 963 gtk_list_store_remove (filelist_store, &iter);
1036 gtk_list_store_remove (filelist_store, &iter); 964 gtk_tree_path_free (path);
1037 gtk_tree_path_free (path); 965 selected_refs = g_list_next (selected_refs);
1038 selected_refs = g_list_next (selected_refs); 966 }
1039 } 967 g_list_foreach (selected_paths, (GFunc) gtk_tree_row_reference_free, NULL);
1040 g_list_foreach (selected_paths, (GFunc) gtk_tree_row_reference_free, 968 g_list_free (selected_paths);
1041 NULL);
1042 g_list_free (selected_paths);
1043} 969}
1044 970
1045/** 971/**
@@ -1048,9 +974,8 @@ remove_file_from_list (gpointer user_data)
1048void 974void
1049select_all_files (gpointer user_data) 975select_all_files (gpointer user_data)
1050{ 976{
1051 GtkWidget *filelist = 977 GtkWidget *filelist = glade_xml_get_widget (musicinsertXML, "filelist");
1052 glade_xml_get_widget (musicinsertXML, "filelist"); 978 GtkTreeSelection *selection =
1053 GtkTreeSelection *selection = 979 gtk_tree_view_get_selection (GTK_TREE_VIEW (filelist));
1054 gtk_tree_view_get_selection (GTK_TREE_VIEW (filelist)); 980 gtk_tree_selection_select_all (selection);
1055 gtk_tree_selection_select_all (selection);
1056} 981}
diff --git a/src/plugins/fs/extensions/musicinsert.h b/src/plugins/fs/extensions/musicinsert.h
index fcfb07c1..40d6ef55 100644
--- a/src/plugins/fs/extensions/musicinsert.h
+++ b/src/plugins/fs/extensions/musicinsert.h
@@ -76,7 +76,7 @@ const gint keywords_col_num = KEYWORDS_COL;
76 76
77 77
78EXTRACTOR_KeywordList *get_EXTRACTORKeywords (const EXTRACTOR_ExtractorList * 78EXTRACTOR_KeywordList *get_EXTRACTORKeywords (const EXTRACTOR_ExtractorList *
79 exList, const gchar * filename); 79 exList, const gchar * filename);
80void set_File_Keywords (const gchar * filename); 80void set_File_Keywords (const gchar * filename);
81void activateComboBoxes (); 81void activateComboBoxes ();
82void updateColumns (); 82void updateColumns ();
@@ -101,26 +101,26 @@ void on_radioindex_toggled (GtkRadioButton * radiobutton, gpointer user_data);
101 101
102void 102void
103on_albumtogglebutton_toggled (GtkToggleButton * togglebutton, 103on_albumtogglebutton_toggled (GtkToggleButton * togglebutton,
104 gpointer user_data); 104 gpointer user_data);
105 105
106void 106void
107on_artisttogglebutton_toggled (GtkToggleButton * togglebutton, 107on_artisttogglebutton_toggled (GtkToggleButton * togglebutton,
108 gpointer user_data); 108 gpointer user_data);
109 109
110void 110void
111on_typetogglebutton_toggled (GtkToggleButton * togglebutton, 111on_typetogglebutton_toggled (GtkToggleButton * togglebutton,
112 gpointer user_data); 112 gpointer user_data);
113 113
114void 114void
115on_keywordstogglebutton_toggled (GtkToggleButton * togglebutton, 115on_keywordstogglebutton_toggled (GtkToggleButton * togglebutton,
116 gpointer user_data); 116 gpointer user_data);
117 117
118void 118void
119on_renderer_edited (GtkCellRendererText * cellrenderertext, 119on_renderer_edited (GtkCellRendererText * cellrenderertext,
120 gchar * arg1, gchar * arg2, gpointer user_data); 120 gchar * arg1, gchar * arg2, gpointer user_data);
121 121
122gboolean popup_delete (GtkWidget * widget, 122gboolean popup_delete (GtkWidget * widget,
123 GdkEventButton * event, gpointer user_data); 123 GdkEventButton * event, gpointer user_data);
124 124
125void remove_file_from_list (gpointer user_data); 125void remove_file_from_list (gpointer user_data);
126 126
diff --git a/src/plugins/fs/fs.c b/src/plugins/fs/fs.c
index 6661cae5..aae21346 100644
--- a/src/plugins/fs/fs.c
+++ b/src/plugins/fs/fs.c
@@ -35,23 +35,23 @@
35#include "collection.h" 35#include "collection.h"
36#include "namespace.h" 36#include "namespace.h"
37 37
38struct FSUI_Context * ctx; 38struct FSUI_Context *ctx;
39 39
40struct GE_Context * ectx; 40struct GE_Context *ectx;
41 41
42struct GC_Configuration * cfg; 42struct GC_Configuration *cfg;
43 43
44SearchList * search_head; 44SearchList *search_head;
45 45
46DownloadList * download_head; 46DownloadList *download_head;
47 47
48UploadList * upload_head; 48UploadList *upload_head;
49 49
50GtkListStore * search_summary; 50GtkListStore *search_summary;
51 51
52GtkTreeStore * download_summary; 52GtkTreeStore *download_summary;
53 53
54GtkTreeStore * upload_summary; 54GtkTreeStore *upload_summary;
55 55
56/** 56/**
57 * Last right-click event coordinates in summary. 57 * Last right-click event coordinates in summary.
@@ -64,22 +64,24 @@ static unsigned int last_x;
64static unsigned int last_y; 64static unsigned int last_y;
65 65
66 66
67void on_updateIntervalComboEntry_changed_fs(GtkWidget * button, 67void
68 GtkWidget * entryBox) { 68on_updateIntervalComboEntry_changed_fs (GtkWidget * button,
69 const char * time; 69 GtkWidget * entryBox)
70{
71 const char *time;
70 TIME_T t; 72 TIME_T t;
71 GtkEntry * entry; 73 GtkEntry *entry;
72 74
73 entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(entryBox))); 75 entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (entryBox)));
74 time = gtk_entry_get_text(entry); 76 time = gtk_entry_get_text (entry);
75 if (OK != parseTimeInterval(time, 77 if (OK != parseTimeInterval (time, &t))
76 &t)) { 78 {
77 gtk_widget_set_sensitive(button, 79 gtk_widget_set_sensitive (button, FALSE);
78 FALSE); 80 }
79 } else { 81 else
80 gtk_widget_set_sensitive(button, 82 {
81 TRUE); 83 gtk_widget_set_sensitive (button, TRUE);
82 } 84 }
83} 85}
84 86
85 87
@@ -87,305 +89,295 @@ void on_updateIntervalComboEntry_changed_fs(GtkWidget * button,
87 * The selection of the download summary changed. 89 * The selection of the download summary changed.
88 * Update button status. 90 * Update button status.
89 */ 91 */
90void on_anonymity_spin_changed_fs(GtkWidget * w, 92void
91 gpointer dummy) { 93on_anonymity_spin_changed_fs (GtkWidget * w, gpointer dummy)
94{
92 gint val; 95 gint val;
93 GdkColor color; 96 GdkColor color;
94 GtkSpinButton * spin; 97 GtkSpinButton *spin;
95 98
96 spin = GTK_SPIN_BUTTON(w); 99 spin = GTK_SPIN_BUTTON (w);
97 if (spin == NULL) { 100 if (spin == NULL)
98 GE_BREAK(NULL, 0); 101 {
99 return; 102 GE_BREAK (NULL, 0);
100 } 103 return;
101 val = gtk_spin_button_get_value_as_int(spin); 104 }
102 if (val == 0) { 105 val = gtk_spin_button_get_value_as_int (spin);
103 if ( (TRUE == gdk_color_parse("red", 106 if (val == 0)
104 &color)) && 107 {
105 (TRUE == gdk_colormap_alloc_color(gdk_colormap_get_system(), 108 if ((TRUE == gdk_color_parse ("red",
106 &color, 109 &color)) &&
107 FALSE, 110 (TRUE == gdk_colormap_alloc_color (gdk_colormap_get_system (),
108 TRUE)) ) 111 &color, FALSE, TRUE)))
109 gtk_widget_modify_base(w, 112 gtk_widget_modify_base (w, GTK_STATE_NORMAL, &color);
110 GTK_STATE_NORMAL, 113 }
111 &color); 114 else
112 } else 115 gtk_widget_modify_base (w, GTK_STATE_NORMAL, NULL);
113 gtk_widget_modify_base(w,
114 GTK_STATE_NORMAL,
115 NULL);
116 116
117 117
118} 118}
119 119
120static void * 120static void *
121saveEventProcessor(void * cls) { 121saveEventProcessor (void *cls)
122 const FSUI_Event * event = cls; 122{
123 void * ret; 123 const FSUI_Event *event = cls;
124 void *ret;
124 125
125 ret = NULL; 126 ret = NULL;
126 switch (event->type) { 127 switch (event->type)
127 /* search events */ 128 {
128 case FSUI_search_started: 129 /* search events */
129 ret = fs_search_started(event->data.SearchStarted.sc.pos, 130 case FSUI_search_started:
130 event->data.SearchStarted.searchURI, 131 ret = fs_search_started (event->data.SearchStarted.sc.pos,
131 event->data.SearchStarted.anonymityLevel, 132 event->data.SearchStarted.searchURI,
132 0, 133 event->data.SearchStarted.anonymityLevel,
133 NULL, 134 0, NULL, FSUI_ACTIVE);
134 FSUI_ACTIVE); 135 break;
135 break; 136 case FSUI_search_result:
136 case FSUI_search_result: 137 fs_search_result_received (event->data.SearchResult.sc.cctx,
137 fs_search_result_received(event->data.SearchResult.sc.cctx, 138 &event->data.SearchResult.fi,
138 &event->data.SearchResult.fi, 139 event->data.SearchResult.searchURI);
139 event->data.SearchResult.searchURI); 140 break;
140 break; 141 case FSUI_search_error:
141 case FSUI_search_error: 142 fs_search_aborted (event->data.SearchError.sc.cctx);
142 fs_search_aborted(event->data.SearchError.sc.cctx); 143 break;
143 break; 144 case FSUI_search_aborted:
144 case FSUI_search_aborted: 145 fs_search_aborted (event->data.SearchAborted.sc.cctx);
145 fs_search_aborted(event->data.SearchAborted.sc.cctx); 146 break;
146 break; 147 case FSUI_search_completed:
147 case FSUI_search_completed: 148 // FIXME...
148 // FIXME... 149 fs_search_aborted (event->data.SearchCompleted.sc.cctx);
149 fs_search_aborted(event->data.SearchCompleted.sc.cctx); 150 break;
150 break; 151 case FSUI_search_suspended:
151 case FSUI_search_suspended: 152 fs_search_aborted (event->data.SearchSuspended.sc.cctx);
152 fs_search_aborted(event->data.SearchSuspended.sc.cctx); 153 break;
153 break; 154 case FSUI_search_resumed:
154 case FSUI_search_resumed: 155 ret = fs_search_started (event->data.SearchResumed.sc.pos,
155 ret = fs_search_started(event->data.SearchResumed.sc.pos, 156 event->data.SearchResumed.searchURI,
156 event->data.SearchResumed.searchURI, 157 event->data.SearchResumed.anonymityLevel,
157 event->data.SearchResumed.anonymityLevel, 158 event->data.SearchResumed.fisSize,
158 event->data.SearchResumed.fisSize, 159 event->data.SearchResumed.fis,
159 event->data.SearchResumed.fis, 160 event->data.SearchResumed.state);
160 event->data.SearchResumed.state); 161 break;
161 break; 162 case FSUI_search_stopped:
162 case FSUI_search_stopped: 163 fs_search_stopped (event->data.SearchStopped.sc.cctx);
163 fs_search_stopped(event->data.SearchStopped.sc.cctx); 164 break;
164 break; 165
165 166 /* download events */
166 /* download events */ 167 case FSUI_download_aborted:
167 case FSUI_download_aborted: 168 fs_download_aborted (event->data.DownloadAborted.dc.cctx);
168 fs_download_aborted(event->data.DownloadAborted.dc.cctx); 169 break;
169 break; 170 case FSUI_download_error:
170 case FSUI_download_error: 171 fs_download_aborted (event->data.DownloadError.dc.cctx);
171 fs_download_aborted(event->data.DownloadError.dc.cctx); 172 break;
172 break; 173 case FSUI_download_suspended:
173 case FSUI_download_suspended: 174 fs_download_stopped (event->data.DownloadSuspended.dc.cctx);
174 fs_download_stopped(event->data.DownloadSuspended.dc.cctx); 175 break;
175 break; 176 case FSUI_download_progress:
176 case FSUI_download_progress: 177 fs_download_update (event->data.DownloadProgress.dc.cctx,
177 fs_download_update(event->data.DownloadProgress.dc.cctx, 178 event->data.DownloadProgress.completed,
178 event->data.DownloadProgress.completed, 179 event->data.DownloadProgress.last_block,
179 event->data.DownloadProgress.last_block, 180 event->data.DownloadProgress.last_size);
180 event->data.DownloadProgress.last_size); 181 break;
181 break; 182 case FSUI_download_completed:
182 case FSUI_download_completed: 183 fs_download_completed (event->data.DownloadCompleted.dc.cctx);
183 fs_download_completed(event->data.DownloadCompleted.dc.cctx); 184 break;
184 break; 185 case FSUI_download_stopped:
185 case FSUI_download_stopped: 186 fs_download_stopped (event->data.DownloadStopped.dc.cctx);
186 fs_download_stopped(event->data.DownloadStopped.dc.cctx); 187 break;
187 break; 188 case FSUI_download_started:
188 case FSUI_download_started: 189 ret = fs_download_started (event->data.DownloadStarted.dc.pos,
189 ret = fs_download_started(event->data.DownloadStarted.dc.pos, 190 event->data.DownloadStarted.dc.pcctx,
190 event->data.DownloadStarted.dc.pcctx, 191 event->data.DownloadStarted.dc.sctx,
191 event->data.DownloadStarted.dc.sctx, 192 event->data.DownloadStarted.total,
192 event->data.DownloadStarted.total, 193 event->data.DownloadStarted.anonymityLevel,
193 event->data.DownloadStarted.anonymityLevel, 194 &event->data.DownloadStarted.fi,
194 &event->data.DownloadStarted.fi, 195 event->data.DownloadStarted.filename,
195 event->data.DownloadStarted.filename, 196 0, get_time (), FSUI_ACTIVE);
196 0, 197 break;
197 get_time(), 198 case FSUI_download_resumed:
198 FSUI_ACTIVE); 199 ret = fs_download_started (event->data.DownloadResumed.dc.pos,
199 break; 200 event->data.DownloadResumed.dc.pcctx,
200 case FSUI_download_resumed: 201 event->data.DownloadResumed.dc.sctx,
201 ret = fs_download_started(event->data.DownloadResumed.dc.pos, 202 event->data.DownloadResumed.total,
202 event->data.DownloadResumed.dc.pcctx, 203 event->data.DownloadResumed.anonymityLevel,
203 event->data.DownloadResumed.dc.sctx, 204 &event->data.DownloadResumed.fi,
204 event->data.DownloadResumed.total, 205 event->data.DownloadResumed.filename,
205 event->data.DownloadResumed.anonymityLevel, 206 event->data.DownloadResumed.completed,
206 &event->data.DownloadResumed.fi, 207 event->data.DownloadResumed.eta,
207 event->data.DownloadResumed.filename, 208 event->data.DownloadResumed.state);
208 event->data.DownloadResumed.completed, 209 break;
209 event->data.DownloadResumed.eta, 210
210 event->data.DownloadResumed.state); 211 /* upload events */
211 break; 212 case FSUI_upload_progress:
212 213 fs_upload_update (event->data.UploadProgress.uc.cctx,
213 /* upload events */ 214 event->data.UploadProgress.completed);
214 case FSUI_upload_progress: 215 break;
215 fs_upload_update(event->data.UploadProgress.uc.cctx, 216 case FSUI_upload_completed:
216 event->data.UploadProgress.completed); 217 fs_upload_complete (event->data.UploadCompleted.uc.cctx,
217 break; 218 event->data.UploadCompleted.uri);
218 case FSUI_upload_completed: 219 break;
219 fs_upload_complete(event->data.UploadCompleted.uc.cctx, 220 case FSUI_upload_error:
220 event->data.UploadCompleted.uri); 221 fs_upload_error (event->data.UploadError.uc.cctx);
221 break; 222 break;
222 case FSUI_upload_error: 223 case FSUI_upload_aborted:
223 fs_upload_error(event->data.UploadError.uc.cctx); 224 fs_upload_error (event->data.UploadAborted.uc.cctx);
224 break; 225 break;
225 case FSUI_upload_aborted: 226 case FSUI_upload_stopped:
226 fs_upload_error(event->data.UploadAborted.uc.cctx); 227 fs_upload_stopped (event->data.UploadStopped.uc.cctx);
227 break; 228 break;
228 case FSUI_upload_stopped: 229 case FSUI_upload_suspended:
229 fs_upload_stopped(event->data.UploadStopped.uc.cctx); 230 fs_upload_stopped (event->data.UploadSuspended.uc.cctx);
230 break; 231 break;
231 case FSUI_upload_suspended: 232 case FSUI_upload_started:
232 fs_upload_stopped(event->data.UploadSuspended.uc.cctx); 233 ret = fs_upload_started (event->data.UploadStarted.uc.pos,
233 break; 234 event->data.UploadStarted.uc.pcctx,
234 case FSUI_upload_started: 235 event->data.UploadStarted.filename,
235 ret = fs_upload_started(event->data.UploadStarted.uc.pos, 236 NULL,
236 event->data.UploadStarted.uc.pcctx, 237 event->data.UploadStarted.total,
237 event->data.UploadStarted.filename, 238 0, FSUI_ACTIVE);
238 NULL, 239 break;
239 event->data.UploadStarted.total, 240 case FSUI_upload_resumed:
240 0, 241 ret = fs_upload_started (event->data.UploadResumed.uc.pos,
241 FSUI_ACTIVE); 242 event->data.UploadResumed.uc.pcctx,
242 break; 243 event->data.UploadResumed.filename,
243 case FSUI_upload_resumed: 244 event->data.UploadResumed.uri,
244 ret = fs_upload_started(event->data.UploadResumed.uc.pos, 245 event->data.UploadResumed.total,
245 event->data.UploadResumed.uc.pcctx, 246 event->data.UploadResumed.completed,
246 event->data.UploadResumed.filename, 247 event->data.UploadResumed.state);
247 event->data.UploadResumed.uri, 248 break;
248 event->data.UploadResumed.total, 249 /* TODO: unindex events */
249 event->data.UploadResumed.completed, 250 default:
250 event->data.UploadResumed.state); 251 GE_BREAK (ectx, 0);
251 break; 252 GE_LOG (ectx,
252 /* TODO: unindex events */ 253 GE_ERROR,
253 default: 254 _("Unhandled (unknown) FSUI event: %u.\n"), event->type);
254 GE_BREAK(ectx, 0); 255 break;
255 GE_LOG(ectx, 256 }
256 GE_ERROR,
257 _("Unhandled (unknown) FSUI event: %u.\n"),
258 event->type);
259 break;
260 }
261 return ret; 257 return ret;
262} 258}
263 259
264static void * 260static void *
265eventProcessor(void * unused, 261eventProcessor (void *unused, const FSUI_Event * event)
266 const FSUI_Event * event) { 262{
267 return gtkSaveCall(&saveEventProcessor, 263 return gtkSaveCall (&saveEventProcessor, (void *) event);
268 (void*) event);
269} 264}
270 265
271/** 266/**
272 * The selection of the upload summary changed. 267 * The selection of the upload summary changed.
273 * Update button status. 268 * Update button status.
274 */ 269 */
275static void on_upload_summary_selection_changed(gpointer signal, 270static void
276 gpointer cls) { 271on_upload_summary_selection_changed (gpointer signal, gpointer cls)
277 GtkTreeSelection * selection; 272{
278 GtkWidget * button; 273 GtkTreeSelection *selection;
279 274 GtkWidget *button;
280 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(getMainXML(), 275
281 "activeUploadsList"))); 276 selection =
282 button 277 gtk_tree_view_get_selection (GTK_TREE_VIEW
283 = glade_xml_get_widget(getMainXML(), 278 (glade_xml_get_widget
284 "cancelUploadButton"); 279 (getMainXML (), "activeUploadsList")));
285 gtk_widget_set_sensitive(button, 280 button = glade_xml_get_widget (getMainXML (), "cancelUploadButton");
286 gtk_tree_selection_count_selected_rows(selection) > 0); 281 gtk_widget_set_sensitive (button,
287 button 282 gtk_tree_selection_count_selected_rows (selection)
288 = glade_xml_get_widget(getMainXML(), 283 > 0);
289 "stopUploadButton"); 284 button = glade_xml_get_widget (getMainXML (), "stopUploadButton");
290 gtk_widget_set_sensitive(button, 285 gtk_widget_set_sensitive (button,
291 gtk_tree_selection_count_selected_rows(selection) > 0); 286 gtk_tree_selection_count_selected_rows (selection)
287 > 0);
292} 288}
293 289
294/** 290/**
295 * The selection of the download summary changed. 291 * The selection of the download summary changed.
296 * Update button status. 292 * Update button status.
297 */ 293 */
298static void on_download_summary_selection_changed(gpointer signal, 294static void
299 gpointer cls) { 295on_download_summary_selection_changed (gpointer signal, gpointer cls)
300 GtkTreeSelection * selection; 296{
301 GtkWidget * button; 297 GtkTreeSelection *selection;
302 298 GtkWidget *button;
303 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(getMainXML(), 299
304 "activeDownloadsList"))); 300 selection =
305 button 301 gtk_tree_view_get_selection (GTK_TREE_VIEW
306 = glade_xml_get_widget(getMainXML(), 302 (glade_xml_get_widget
307 "abortDownloadButton"); 303 (getMainXML (), "activeDownloadsList")));
308 gtk_widget_set_sensitive(button, 304 button = glade_xml_get_widget (getMainXML (), "abortDownloadButton");
309 gtk_tree_selection_count_selected_rows(selection) > 0); 305 gtk_widget_set_sensitive (button,
310 button 306 gtk_tree_selection_count_selected_rows (selection)
311 = glade_xml_get_widget(getMainXML(), 307 > 0);
312 "stopDownloadButton"); 308 button = glade_xml_get_widget (getMainXML (), "stopDownloadButton");
313 gtk_widget_set_sensitive(button, 309 gtk_widget_set_sensitive (button,
314 gtk_tree_selection_count_selected_rows(selection) > 0); 310 gtk_tree_selection_count_selected_rows (selection)
311 > 0);
315} 312}
316 313
317/** 314/**
318 * The selection of the download summary changed. 315 * The selection of the download summary changed.
319 * Update button status. 316 * Update button status.
320 */ 317 */
321static void on_search_summary_selection_changed(gpointer signal, 318static void
322 gpointer cls) { 319on_search_summary_selection_changed (gpointer signal, gpointer cls)
323 GtkTreeSelection * selection; 320{
324 GtkWidget * button; 321 GtkTreeSelection *selection;
325 322 GtkWidget *button;
326 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(getMainXML(), 323
327 "activeSearchesSummary"))); 324 selection =
328 button 325 gtk_tree_view_get_selection (GTK_TREE_VIEW
329 = glade_xml_get_widget(getMainXML(), 326 (glade_xml_get_widget
330 "cancelSearchButton"); 327 (getMainXML (), "activeSearchesSummary")));
331 gtk_widget_set_sensitive(button, 328 button = glade_xml_get_widget (getMainXML (), "cancelSearchButton");
332 gtk_tree_selection_count_selected_rows(selection) > 0); 329 gtk_widget_set_sensitive (button,
333 button 330 gtk_tree_selection_count_selected_rows (selection)
334 = glade_xml_get_widget(getMainXML(), 331 > 0);
335 "stopSearchButton"); 332 button = glade_xml_get_widget (getMainXML (), "stopSearchButton");
336 gtk_widget_set_sensitive(button, 333 gtk_widget_set_sensitive (button,
337 gtk_tree_selection_count_selected_rows(selection) > 0); 334 gtk_tree_selection_count_selected_rows (selection)
335 > 0);
338} 336}
339 337
340static int 338static int
341on_upload_copy_uri_activate(void * cls, 339on_upload_copy_uri_activate (void *cls, GtkWidget * searchEntry)
342 GtkWidget * searchEntry) { 340{
343 GtkTreeView * uploadList = cls; 341 GtkTreeView *uploadList = cls;
344 GtkTreePath *path; 342 GtkTreePath *path;
345 GtkTreeIter iter; 343 GtkTreeIter iter;
346 struct ECRS_URI * uri; 344 struct ECRS_URI *uri;
347 char * str; 345 char *str;
348 GtkClipboard * clip; 346 GtkClipboard *clip;
349 347
350 path = NULL; 348 path = NULL;
351 if (FALSE == gtk_tree_view_get_path_at_pos(uploadList, 349 if (FALSE == gtk_tree_view_get_path_at_pos (uploadList,
352 last_x, 350 last_x,
353 last_y, 351 last_y,
354 &path, 352 &path, NULL, NULL, NULL))
355 NULL, 353 {
356 NULL, 354 GE_BREAK (NULL, 0);
357 NULL)) { 355 return FALSE;
358 GE_BREAK(NULL, 0); 356 }
359 return FALSE; 357 if (FALSE == gtk_tree_model_get_iter (GTK_TREE_MODEL (upload_summary),
360 } 358 &iter, path))
361 if (FALSE == gtk_tree_model_get_iter(GTK_TREE_MODEL(upload_summary), 359 {
362 &iter, 360 GE_BREAK (NULL, 0);
363 path)) { 361 gtk_tree_path_free (path);
364 GE_BREAK(NULL, 0); 362 return FALSE;
365 gtk_tree_path_free(path); 363 }
366 return FALSE; 364 gtk_tree_path_free (path);
367 }
368 gtk_tree_path_free(path);
369 uri = NULL; 365 uri = NULL;
370 gtk_tree_model_get(GTK_TREE_MODEL(upload_summary), 366 gtk_tree_model_get (GTK_TREE_MODEL (upload_summary),
371 &iter, 367 &iter, UPLOAD_URISTRING, &str, -1);
372 UPLOAD_URISTRING, &str, 368 clip = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
373 -1); 369 gtk_clipboard_set_text (clip, str, strlen (str));
374 clip = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); 370 FREE (str);
375 gtk_clipboard_set_text(clip,
376 str,
377 strlen(str));
378 FREE(str);
379 return FALSE; 371 return FALSE;
380} 372}
381 373
382static gint 374static gint
383upload_click_handler(void * cls, 375upload_click_handler (void *cls, GdkEvent * event)
384 GdkEvent *event) { 376{
385 GtkTreeView * uploadList = cls; 377 GtkTreeView *uploadList = cls;
386 GtkMenu * menu; 378 GtkMenu *menu;
387 GtkWidget * entry; 379 GtkWidget *entry;
388 GdkEventButton * event_button; 380 GdkEventButton *event_button;
389 381
390 g_return_val_if_fail (event != NULL, FALSE); 382 g_return_val_if_fail (event != NULL, FALSE);
391 if (event->type != GDK_BUTTON_PRESS) 383 if (event->type != GDK_BUTTON_PRESS)
@@ -395,24 +387,19 @@ upload_click_handler(void * cls,
395 return FALSE; 387 return FALSE;
396 last_x = event_button->x; 388 last_x = event_button->x;
397 last_y = event_button->y; 389 last_y = event_button->y;
398 entry = gtk_menu_item_new_with_label(_("_Copy URI to Clipboard")); 390 entry = gtk_menu_item_new_with_label (_("_Copy URI to Clipboard"));
399 g_signal_connect_swapped (entry, 391 g_signal_connect_swapped (entry,
400 "activate", 392 "activate",
401 G_CALLBACK(on_upload_copy_uri_activate), 393 G_CALLBACK (on_upload_copy_uri_activate),
402 uploadList); 394 uploadList);
403 gtk_label_set_use_underline(GTK_LABEL(gtk_bin_get_child(GTK_BIN(entry))), 395 gtk_label_set_use_underline (GTK_LABEL
404 TRUE); 396 (gtk_bin_get_child (GTK_BIN (entry))), TRUE);
405 gtk_widget_show(entry); 397 gtk_widget_show (entry);
406 menu = GTK_MENU(gtk_menu_new()); 398 menu = GTK_MENU (gtk_menu_new ());
407 gtk_menu_shell_append(GTK_MENU_SHELL(menu), 399 gtk_menu_shell_append (GTK_MENU_SHELL (menu), entry);
408 entry);
409 gtk_menu_popup (menu, 400 gtk_menu_popup (menu,
410 NULL, 401 NULL,
411 NULL, 402 NULL, NULL, NULL, event_button->button, event_button->time);
412 NULL,
413 NULL,
414 event_button->button,
415 event_button->time);
416 return TRUE; 403 return TRUE;
417} 404}
418 405
@@ -420,328 +407,297 @@ upload_click_handler(void * cls,
420 * Setup the summary views (in particular the models 407 * Setup the summary views (in particular the models
421 * and the renderers). 408 * and the renderers).
422 */ 409 */
423static void fs_summary_start() { 410static void
424 GtkComboBoxEntry * searchCB; 411fs_summary_start ()
425 GtkWidget * uploadEntry; 412{
426 GtkTreeView * searchList; 413 GtkComboBoxEntry *searchCB;
427 GtkTreeView * downloadList; 414 GtkWidget *uploadEntry;
428 GtkTreeView * uploadList; 415 GtkTreeView *searchList;
429 GtkListStore * model; 416 GtkTreeView *downloadList;
430 GtkCellRenderer * renderer; 417 GtkTreeView *uploadList;
431 GtkTreeViewColumn * column; 418 GtkListStore *model;
419 GtkCellRenderer *renderer;
420 GtkTreeViewColumn *column;
432 int col; 421 int col;
433 422
434 /* keyword list setup */ 423 /* keyword list setup */
435 searchCB 424 searchCB
436 = GTK_COMBO_BOX_ENTRY(glade_xml_get_widget(getMainXML(), 425 = GTK_COMBO_BOX_ENTRY (glade_xml_get_widget (getMainXML (),
437 "fssearchKeywordComboBoxEntry")); 426 "fssearchKeywordComboBoxEntry"));
438 model = gtk_list_store_new(1, 427 model = gtk_list_store_new (1, G_TYPE_STRING /* search string */ );
439 G_TYPE_STRING /* search string*/ ); 428 gtk_combo_box_set_model (GTK_COMBO_BOX (searchCB), GTK_TREE_MODEL (model));
440 gtk_combo_box_set_model(GTK_COMBO_BOX(searchCB), 429 gtk_combo_box_entry_set_text_column (searchCB, 0);
441 GTK_TREE_MODEL(model));
442 gtk_combo_box_entry_set_text_column(searchCB,
443 0);
444 430
445 /* search namespace selection setup */ 431 /* search namespace selection setup */
446 searchCB 432 searchCB
447 = GTK_COMBO_BOX_ENTRY(glade_xml_get_widget(getMainXML(), 433 = GTK_COMBO_BOX_ENTRY (glade_xml_get_widget (getMainXML (),
448 "searchNamespaceComboBoxEntry")); 434 "searchNamespaceComboBoxEntry"));
449 435
450 model = gtk_list_store_new(NS_SEARCH_NUM, 436 model = gtk_list_store_new (NS_SEARCH_NUM, G_TYPE_STRING, /* what we show */
451 G_TYPE_STRING, /* what we show */ 437 G_TYPE_STRING, /* EncName of namespace */
452 G_TYPE_STRING, /* EncName of namespace */ 438 G_TYPE_POINTER, /* ECRS MetaData */
453 G_TYPE_POINTER, /* ECRS MetaData */ 439 G_TYPE_INT); /* Meta-data about namespace */
454 G_TYPE_INT); /* Meta-data about namespace */ 440 gtk_combo_box_set_model (GTK_COMBO_BOX (searchCB), GTK_TREE_MODEL (model));
455 gtk_combo_box_set_model(GTK_COMBO_BOX(searchCB), 441 gtk_combo_box_entry_set_text_column (searchCB, NS_SEARCH_DESCRIPTION);
456 GTK_TREE_MODEL(model));
457 gtk_combo_box_entry_set_text_column(searchCB,
458 NS_SEARCH_DESCRIPTION);
459 442
460 /* search summary setup */ 443 /* search summary setup */
461 searchList = GTK_TREE_VIEW(glade_xml_get_widget(getMainXML(), 444 searchList = GTK_TREE_VIEW (glade_xml_get_widget (getMainXML (),
462 "activeSearchesSummary")); 445 "activeSearchesSummary"));
463 search_summary = 446 search_summary = gtk_list_store_new (SEARCH_SUMMARY_NUM, G_TYPE_STRING, /* name */
464 gtk_list_store_new(SEARCH_SUMMARY_NUM, 447 G_TYPE_INT, /* # results */
465 G_TYPE_STRING, /* name */ 448 G_TYPE_POINTER); /* internal: search list */
466 G_TYPE_INT, /* # results */ 449 gtk_tree_view_set_model (searchList, GTK_TREE_MODEL (search_summary));
467 G_TYPE_POINTER); /* internal: search list */ 450 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (searchList),
468 gtk_tree_view_set_model(searchList, 451 GTK_SELECTION_MULTIPLE);
469 GTK_TREE_MODEL(search_summary)); 452 g_signal_connect_data (gtk_tree_view_get_selection (searchList),
470 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(searchList), 453 "changed",
471 GTK_SELECTION_MULTIPLE); 454 G_CALLBACK (&on_search_summary_selection_changed),
472 g_signal_connect_data(gtk_tree_view_get_selection(searchList), 455 NULL, NULL, 0);
473 "changed", 456
474 G_CALLBACK(&on_search_summary_selection_changed), 457 renderer = gtk_cell_renderer_text_new ();
475 NULL, 458 col = gtk_tree_view_insert_column_with_attributes (searchList,
476 NULL, 459 -1,
477 0); 460 _("Query"),
478 461 renderer,
479 renderer = gtk_cell_renderer_text_new(); 462 "text",
480 col = gtk_tree_view_insert_column_with_attributes(searchList, 463 SEARCH_SUMMARY_NAME,
481 -1, 464 NULL);
482 _("Query"), 465 column = gtk_tree_view_get_column (searchList, col - 1);
483 renderer, 466 gtk_tree_view_column_set_resizable (column, TRUE);
484 "text", SEARCH_SUMMARY_NAME, 467 gtk_tree_view_column_set_clickable (column, TRUE);
485 NULL); 468 gtk_tree_view_column_set_reorderable (column, TRUE);
486 column = gtk_tree_view_get_column(searchList, 469 gtk_tree_view_column_set_sort_column_id (column, SEARCH_SUMMARY_NAME);
487 col - 1); 470 gtk_tree_view_column_set_resizable (column, TRUE);
488 gtk_tree_view_column_set_resizable(column, TRUE); 471 renderer = gtk_cell_renderer_text_new ();
489 gtk_tree_view_column_set_clickable(column, TRUE); 472 col = gtk_tree_view_insert_column_with_attributes (searchList,
490 gtk_tree_view_column_set_reorderable(column, TRUE); 473 -1,
491 gtk_tree_view_column_set_sort_column_id(column, SEARCH_SUMMARY_NAME); 474 _("Results"),
492 gtk_tree_view_column_set_resizable(column, TRUE); 475 renderer,
493 renderer = gtk_cell_renderer_text_new(); 476 "text",
494 col = gtk_tree_view_insert_column_with_attributes(searchList, 477 SEARCH_SUMMARY_RESULT_COUNT,
495 -1, 478 NULL);
496 _("Results"), 479 column = gtk_tree_view_get_column (searchList, col - 1);
497 renderer, 480 gtk_tree_view_column_set_resizable (column, TRUE);
498 "text", SEARCH_SUMMARY_RESULT_COUNT, 481 gtk_tree_view_column_set_clickable (column, TRUE);
499 NULL); 482 gtk_tree_view_column_set_reorderable (column, TRUE);
500 column = gtk_tree_view_get_column(searchList, 483 gtk_tree_view_column_set_sort_column_id (column,
501 col - 1); 484 SEARCH_SUMMARY_RESULT_COUNT);
502 gtk_tree_view_column_set_resizable(column, TRUE); 485 gtk_tree_view_column_set_resizable (column, TRUE);
503 gtk_tree_view_column_set_clickable(column, TRUE);
504 gtk_tree_view_column_set_reorderable(column, TRUE);
505 gtk_tree_view_column_set_sort_column_id(column, SEARCH_SUMMARY_RESULT_COUNT);
506 gtk_tree_view_column_set_resizable(column, TRUE);
507 486
508 /* download summary setup */ 487 /* download summary setup */
509 downloadList = GTK_TREE_VIEW(glade_xml_get_widget(getMainXML(), 488 downloadList = GTK_TREE_VIEW (glade_xml_get_widget (getMainXML (),
510 "activeDownloadsList")); 489 "activeDownloadsList"));
511 download_summary = 490 download_summary = gtk_tree_store_new (DOWNLOAD_NUM, G_TYPE_STRING, /* name (full-path file name) */
512 gtk_tree_store_new(DOWNLOAD_NUM, 491 G_TYPE_STRING, /* name (user-friendly name) */
513 G_TYPE_STRING, /* name (full-path file name) */ 492 G_TYPE_UINT64, /* size */
514 G_TYPE_STRING, /* name (user-friendly name) */ 493 G_TYPE_STRING, /* human readable size */
515 G_TYPE_UINT64, /* size */ 494 G_TYPE_INT, /* progress */
516 G_TYPE_STRING, /* human readable size */ 495 G_TYPE_STRING, /* uri as string */
517 G_TYPE_INT, /* progress */ 496 G_TYPE_POINTER); /* internal download list ptr */
518 G_TYPE_STRING, /* uri as string */ 497 gtk_tree_view_set_model (downloadList, GTK_TREE_MODEL (download_summary));
519 G_TYPE_POINTER); /* internal download list ptr */ 498 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (downloadList),
520 gtk_tree_view_set_model(downloadList, 499 GTK_SELECTION_MULTIPLE);
521 GTK_TREE_MODEL(download_summary)); 500 g_signal_connect_data (gtk_tree_view_get_selection (downloadList),
522 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(downloadList), 501 "changed",
523 GTK_SELECTION_MULTIPLE); 502 G_CALLBACK (&on_download_summary_selection_changed),
524 g_signal_connect_data(gtk_tree_view_get_selection(downloadList), 503 NULL, NULL, 0);
525 "changed", 504
526 G_CALLBACK(&on_download_summary_selection_changed), 505 renderer = gtk_cell_renderer_text_new ();
527 NULL,
528 NULL,
529 0);
530
531 renderer = gtk_cell_renderer_text_new();
532 g_object_set (renderer, "xalign", 1.00, NULL); 506 g_object_set (renderer, "xalign", 1.00, NULL);
533 col = gtk_tree_view_insert_column_with_attributes(downloadList, 507 col = gtk_tree_view_insert_column_with_attributes (downloadList,
534 -1, 508 -1,
535 _("Size"), 509 _("Size"),
536 renderer, 510 renderer,
537 "text", DOWNLOAD_HSIZE, 511 "text", DOWNLOAD_HSIZE,
538 NULL); 512 NULL);
539 513
540 column = gtk_tree_view_get_column(downloadList, 514 column = gtk_tree_view_get_column (downloadList, col - 1);
541 col - 1); 515 gtk_tree_view_column_set_resizable (column, TRUE);
542 gtk_tree_view_column_set_resizable(column, TRUE); 516 gtk_tree_view_column_set_clickable (column, TRUE);
543 gtk_tree_view_column_set_clickable(column, TRUE); 517 gtk_tree_view_column_set_reorderable (column, TRUE);
544 gtk_tree_view_column_set_reorderable(column, TRUE); 518 gtk_tree_view_column_set_sort_column_id (column, DOWNLOAD_SIZE);
545 gtk_tree_view_column_set_sort_column_id(column, DOWNLOAD_SIZE); 519 gtk_tree_view_column_set_resizable (column, TRUE);
546 gtk_tree_view_column_set_resizable(column, TRUE); 520
547 521 renderer = gtk_cell_renderer_progress_new ();
548 renderer = gtk_cell_renderer_progress_new(); 522 col = gtk_tree_view_insert_column_with_attributes (downloadList,
549 col = gtk_tree_view_insert_column_with_attributes(downloadList, 523 -1,
550 -1, 524 _("Name"),
551 _("Name"), 525 renderer,
552 renderer, 526 "value",
553 "value", DOWNLOAD_PROGRESS, 527 DOWNLOAD_PROGRESS,
554 "text", DOWNLOAD_SHORTNAME, 528 "text",
555 NULL); 529 DOWNLOAD_SHORTNAME,
556 g_object_set(G_OBJECT(renderer), 530 NULL);
557 "width", 400, 531 g_object_set (G_OBJECT (renderer), "width", 400, NULL);
558 NULL); 532 column = gtk_tree_view_get_column (downloadList, col - 1);
559 column = gtk_tree_view_get_column(downloadList, 533 gtk_tree_view_column_set_resizable (column, TRUE);
560 col - 1); 534 gtk_tree_view_column_set_clickable (column, TRUE);
561 gtk_tree_view_column_set_resizable(column, TRUE); 535 gtk_tree_view_column_set_reorderable (column, TRUE);
562 gtk_tree_view_column_set_clickable(column, TRUE); 536 gtk_tree_view_column_set_sort_column_id (column, DOWNLOAD_PROGRESS);
563 gtk_tree_view_column_set_reorderable(column, TRUE); 537 gtk_tree_view_column_set_resizable (column, TRUE);
564 gtk_tree_view_column_set_sort_column_id(column, DOWNLOAD_PROGRESS); 538
565 gtk_tree_view_column_set_resizable(column, TRUE); 539 renderer = gtk_cell_renderer_text_new ();
566 540 col = gtk_tree_view_insert_column_with_attributes (downloadList,
567 renderer = gtk_cell_renderer_text_new(); 541 -1,
568 col = gtk_tree_view_insert_column_with_attributes(downloadList, 542 _("URI"),
569 -1, 543 renderer,
570 _("URI"), 544 "text",
571 renderer, 545 DOWNLOAD_URISTRING,
572 "text", DOWNLOAD_URISTRING, 546 NULL);
573 NULL); 547 g_object_set (G_OBJECT (renderer), "wrap-width", 30, "width-chars", 30,
574 g_object_set(G_OBJECT(renderer), 548 "ellipsize", PANGO_ELLIPSIZE_END, NULL);
575 "wrap-width", 30, 549 column = gtk_tree_view_get_column (downloadList, col - 1);
576 "width-chars", 30, 550 gtk_tree_view_column_set_resizable (column, TRUE);
577 "ellipsize", PANGO_ELLIPSIZE_END, 551 gtk_tree_view_column_set_reorderable (column, TRUE);
578 NULL); 552 gtk_tree_view_column_set_resizable (column, TRUE);
579 column = gtk_tree_view_get_column(downloadList,
580 col - 1);
581 gtk_tree_view_column_set_resizable(column, TRUE);
582 gtk_tree_view_column_set_reorderable(column, TRUE);
583 gtk_tree_view_column_set_resizable(column, TRUE);
584 553
585 /* upload summary setup */ 554 /* upload summary setup */
586 uploadList = GTK_TREE_VIEW(glade_xml_get_widget(getMainXML(), 555 uploadList = GTK_TREE_VIEW (glade_xml_get_widget (getMainXML (),
587 "activeUploadsList")); 556 "activeUploadsList"));
588 g_signal_connect_swapped (uploadList, 557 g_signal_connect_swapped (uploadList,
589 "button-press-event", 558 "button-press-event",
590 G_CALLBACK(upload_click_handler), 559 G_CALLBACK (upload_click_handler), uploadList);
591 uploadList); 560 upload_summary = gtk_tree_store_new (UPLOAD_NUM, G_TYPE_STRING, /* filename */
592 upload_summary = 561 G_TYPE_INT, /* progress */
593 gtk_tree_store_new(UPLOAD_NUM, 562 G_TYPE_STRING, /* URI as string */
594 G_TYPE_STRING, /* filename */ 563 G_TYPE_POINTER); /* UploadList */
595 G_TYPE_INT, /* progress */ 564 gtk_tree_view_set_model (uploadList, GTK_TREE_MODEL (upload_summary));
596 G_TYPE_STRING, /* URI as string */ 565 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (uploadList),
597 G_TYPE_POINTER); /* UploadList */ 566 GTK_SELECTION_MULTIPLE);
598 gtk_tree_view_set_model(uploadList, 567 g_signal_connect_data (gtk_tree_view_get_selection (uploadList),
599 GTK_TREE_MODEL(upload_summary)); 568 "changed",
600 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(uploadList), 569 G_CALLBACK (&on_upload_summary_selection_changed),
601 GTK_SELECTION_MULTIPLE); 570 NULL, NULL, 0);
602 g_signal_connect_data(gtk_tree_view_get_selection(uploadList), 571
603 "changed", 572 renderer = gtk_cell_renderer_progress_new ();
604 G_CALLBACK(&on_upload_summary_selection_changed), 573 col = gtk_tree_view_insert_column_with_attributes (uploadList,
605 NULL, 574 -1,
606 NULL, 575 _("Filename"),
607 0); 576 renderer,
608 577 "text", UPLOAD_FILENAME,
609 renderer = gtk_cell_renderer_progress_new(); 578 "value", UPLOAD_PROGRESS,
610 col = gtk_tree_view_insert_column_with_attributes(uploadList, 579 NULL);
611 -1, 580 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (uploadList,
612 _("Filename"), 581 col - 1),
613 renderer, 582 TRUE);
614 "text", UPLOAD_FILENAME, 583
615 "value", UPLOAD_PROGRESS, 584 renderer = gtk_cell_renderer_text_new ();
616 NULL); 585 col = gtk_tree_view_insert_column_with_attributes (uploadList,
617 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(uploadList, 586 -1,
618 col - 1), 587 _("URI"),
619 TRUE); 588 renderer,
620 589 "text", UPLOAD_URISTRING,
621 renderer = gtk_cell_renderer_text_new(); 590 NULL);
622 col = gtk_tree_view_insert_column_with_attributes(uploadList, 591 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (uploadList,
623 -1, 592 col - 1),
624 _("URI"), 593 TRUE);
625 renderer,
626 "text", UPLOAD_URISTRING,
627 NULL);
628 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(uploadList,
629 col - 1),
630 TRUE);
631 /* upload entry setup */ 594 /* upload entry setup */
632 uploadEntry 595 uploadEntry
633 = glade_xml_get_widget(getMainXML(), 596 = glade_xml_get_widget (getMainXML (), "uploadFilenameComboBoxEntry");
634 "uploadFilenameComboBoxEntry"); 597
635 598 model = gtk_list_store_new (1, G_TYPE_STRING);
636 model = gtk_list_store_new(1, G_TYPE_STRING); 599 gtk_combo_box_set_model (GTK_COMBO_BOX (uploadEntry),
637 gtk_combo_box_set_model(GTK_COMBO_BOX(uploadEntry), 600 GTK_TREE_MODEL (model));
638 GTK_TREE_MODEL(model)); 601 gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (uploadEntry), 0);
639 gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(uploadEntry),
640 0);
641} 602}
642 603
643/** 604/**
644 * Shutdown the summary dialogs. 605 * Shutdown the summary dialogs.
645 */ 606 */
646static void fs_summary_stop() { 607static void
647 struct ECRS_MetaData * meta; 608fs_summary_stop ()
648 GtkComboBox * searchCB; 609{
649 GtkTreeModel * model; 610 struct ECRS_MetaData *meta;
611 GtkComboBox *searchCB;
612 GtkTreeModel *model;
650 GtkTreeIter iter; 613 GtkTreeIter iter;
651 614
652 searchCB 615 searchCB
653 = GTK_COMBO_BOX(glade_xml_get_widget(getMainXML(), 616 = GTK_COMBO_BOX (glade_xml_get_widget (getMainXML (),
654 "searchNamespaceComboBoxEntry")); 617 "searchNamespaceComboBoxEntry"));
655 model = gtk_combo_box_get_model(searchCB); 618 model = gtk_combo_box_get_model (searchCB);
656 if (gtk_tree_model_get_iter_first(model, 619 if (gtk_tree_model_get_iter_first (model, &iter))
657 &iter)) { 620 {
658 do { 621 do
659 gtk_tree_model_get(model, 622 {
660 &iter, 623 gtk_tree_model_get (model, &iter, NS_SEARCH_METADATA, &meta, -1);
661 NS_SEARCH_METADATA, &meta, 624 gtk_list_store_set (GTK_LIST_STORE (model),
662 -1); 625 &iter, NS_SEARCH_METADATA, NULL, -1);
663 gtk_list_store_set(GTK_LIST_STORE(model), 626 if (meta != NULL)
664 &iter, 627 ECRS_freeMetaData (meta);
665 NS_SEARCH_METADATA, NULL, 628 }
666 -1); 629 while (gtk_list_store_remove (GTK_LIST_STORE (model), &iter));
667 if (meta != NULL) 630 }
668 ECRS_freeMetaData(meta);
669 } while (gtk_list_store_remove(GTK_LIST_STORE(model),
670 &iter));
671 }
672 631
673} 632}
674 633
675void init_fs(struct GE_Context * e, 634void
676 struct GC_Configuration * c) { 635init_fs (struct GE_Context *e, struct GC_Configuration *c)
677 GtkWidget * tab; 636{
678 GtkWidget * book; 637 GtkWidget *tab;
638 GtkWidget *book;
679 gint num; 639 gint num;
680 640
681 ectx = e; 641 ectx = e;
682 cfg = c; 642 cfg = c;
683 CO_init(ectx, cfg); 643 CO_init (ectx, cfg);
684 tab 644 tab = glade_xml_get_widget (getMainXML (), "fsnotebook");
685 = glade_xml_get_widget(getMainXML(), 645 gtk_widget_show (tab);
686 "fsnotebook"); 646 book = glade_xml_get_widget (getMainXML (), "mainnotebook");
687 gtk_widget_show(tab); 647 num = gtk_notebook_get_current_page (GTK_NOTEBOOK (book));
688 book 648 gtk_notebook_set_current_page (GTK_NOTEBOOK (book), 1);
689 = glade_xml_get_widget(getMainXML(), "mainnotebook"); 649 gtk_notebook_set_current_page (GTK_NOTEBOOK (book), num);
690 num = gtk_notebook_get_current_page(GTK_NOTEBOOK(book)); 650 fs_summary_start ();
691 gtk_notebook_set_current_page(GTK_NOTEBOOK(book), 1); 651 fs_collection_start ();
692 gtk_notebook_set_current_page(GTK_NOTEBOOK(book), num); 652 fs_namespace_start ();
693 fs_summary_start(); 653 ctx = FSUI_start (ectx, cfg, "gnunet-gtk", 8, /* FIXME: allow user to configure download parallelism */
694 fs_collection_start(); 654 YES, &eventProcessor, NULL);
695 fs_namespace_start();
696 ctx = FSUI_start(ectx,
697 cfg,
698 "gnunet-gtk",
699 8, /* FIXME: allow user to configure download parallelism */
700 YES,
701 &eventProcessor,
702 NULL);
703} 655}
704 656
705static void * hide_save_call(void * arg) { 657static void *
706 GtkWidget * tab; 658hide_save_call (void *arg)
659{
660 GtkWidget *tab;
707 661
708 tab 662 tab = glade_xml_get_widget (getMainXML (), "fsnotebook");
709 = glade_xml_get_widget(getMainXML(), 663 gtk_widget_hide (tab);
710 "fsnotebook");
711 gtk_widget_hide(tab);
712 return NULL; 664 return NULL;
713} 665}
714 666
715static void * cleanup_save_call(void * arg) { 667static void *
716 fs_summary_stop(); 668cleanup_save_call (void *arg)
717 fs_namespace_stop(); 669{
670 fs_summary_stop ();
671 fs_namespace_stop ();
718 return NULL; 672 return NULL;
719} 673}
720 674
721void done_fs() { 675void
722 gtkSaveCall(&hide_save_call, NULL); 676done_fs ()
723 FSUI_stop(ctx); 677{
724 gtkSaveCall(&cleanup_save_call, NULL); 678 gtkSaveCall (&hide_save_call, NULL);
725 CO_done(); 679 FSUI_stop (ctx);
680 gtkSaveCall (&cleanup_save_call, NULL);
681 CO_done ();
726} 682}
727 683
728 684
729const char * getColorCode(enum URITRACK_STATE state) { 685const char *
686getColorCode (enum URITRACK_STATE state)
687{
730 if (state & (URITRACK_DIRECTORY_ADDED)) 688 if (state & (URITRACK_DIRECTORY_ADDED))
731 return "blue"; 689 return "blue";
732 if (state & (URITRACK_INSERTED || URITRACK_INDEXED)) 690 if (state & (URITRACK_INSERTED || URITRACK_INDEXED))
733 return "cyan"; 691 return "cyan";
734 if ( (state & URITRACK_DOWNLOAD_STARTED) && 692 if ((state & URITRACK_DOWNLOAD_STARTED) &&
735 (0 == (state & 693 (0 == (state &
736 (URITRACK_DOWNLOAD_COMPLETED | 694 (URITRACK_DOWNLOAD_COMPLETED | URITRACK_DOWNLOAD_ABORTED))))
737 URITRACK_DOWNLOAD_ABORTED)) ) )
738 return "yellow"; 695 return "yellow";
739 if (state & URITRACK_DOWNLOAD_COMPLETED) 696 if (state & URITRACK_DOWNLOAD_COMPLETED)
740 return "springgreen"; 697 return "springgreen";
741 if (state & URITRACK_DOWNLOAD_ABORTED) 698 if (state & URITRACK_DOWNLOAD_ABORTED)
742 return "red"; 699 return "red";
743 if (state & (URITRACK_SEARCH_RESULT | 700 if (state & (URITRACK_SEARCH_RESULT | URITRACK_DIRECTORY_FOUND))
744 URITRACK_DIRECTORY_FOUND) )
745 return "gray"; 701 return "gray";
746 return "white"; 702 return "white";
747} 703}
diff --git a/src/plugins/fs/fs.h b/src/plugins/fs/fs.h
index 2e54415b..14b691e0 100644
--- a/src/plugins/fs/fs.h
+++ b/src/plugins/fs/fs.h
@@ -36,7 +36,8 @@
36 * On search box, for namespace selection 36 * On search box, for namespace selection
37 * (for input of search URI; lists known namespaces). 37 * (for input of search URI; lists known namespaces).
38 */ 38 */
39enum { 39enum
40{
40 NS_SEARCH_DESCRIPTION = 0, 41 NS_SEARCH_DESCRIPTION = 0,
41 NS_SEARCH_ENCNAME, 42 NS_SEARCH_ENCNAME,
42 NS_SEARCH_METADATA, 43 NS_SEARCH_METADATA,
@@ -48,7 +49,8 @@ enum {
48 * For listing of search results for main search. 49 * For listing of search results for main search.
49 * Represents a search result. 50 * Represents a search result.
50 */ 51 */
51enum { 52enum
53{
52 SEARCH_NAME = 0, 54 SEARCH_NAME = 0,
53 SEARCH_SIZE, 55 SEARCH_SIZE,
54 SEARCH_HSIZE, 56 SEARCH_HSIZE,
@@ -68,7 +70,8 @@ enum {
68 * Search entry in search summary list. 70 * Search entry in search summary list.
69 * Represents a search process. 71 * Represents a search process.
70 */ 72 */
71enum { 73enum
74{
72 SEARCH_SUMMARY_NAME = 0, 75 SEARCH_SUMMARY_NAME = 0,
73 SEARCH_SUMMARY_RESULT_COUNT, 76 SEARCH_SUMMARY_RESULT_COUNT,
74 SEARCH_SUMMARY_INTERNAL, 77 SEARCH_SUMMARY_INTERNAL,
@@ -78,18 +81,20 @@ enum {
78/** 81/**
79 * Entry in download summary. 82 * Entry in download summary.
80 */ 83 */
81enum { 84enum
85{
82 DOWNLOAD_FILENAME = 0, 86 DOWNLOAD_FILENAME = 0,
83 DOWNLOAD_SHORTNAME, 87 DOWNLOAD_SHORTNAME,
84 DOWNLOAD_SIZE, 88 DOWNLOAD_SIZE,
85 DOWNLOAD_HSIZE, 89 DOWNLOAD_HSIZE,
86 DOWNLOAD_PROGRESS, 90 DOWNLOAD_PROGRESS,
87 DOWNLOAD_URISTRING, 91 DOWNLOAD_URISTRING,
88 DOWNLOAD_INTERNAL, /* struct DL */ 92 DOWNLOAD_INTERNAL, /* struct DL */
89 DOWNLOAD_NUM 93 DOWNLOAD_NUM
90}; 94};
91 95
92enum { 96enum
97{
93 NAMESPACE_FILENAME = 0, 98 NAMESPACE_FILENAME = 0,
94 NAMESPACE_SIZE, 99 NAMESPACE_SIZE,
95 NAMESPACE_HSIZE, 100 NAMESPACE_HSIZE,
@@ -99,7 +104,8 @@ enum {
99 NAMESPACE_NUM 104 NAMESPACE_NUM
100}; 105};
101 106
102enum { 107enum
108{
103 IN_NAMESPACE_FILENAME = 0, 109 IN_NAMESPACE_FILENAME = 0,
104 IN_NAMESPACE_SIZE, 110 IN_NAMESPACE_SIZE,
105 IN_NAMESPACE_HSIZE, 111 IN_NAMESPACE_HSIZE,
@@ -117,7 +123,8 @@ enum {
117/** 123/**
118 * Entry in upload summary. 124 * Entry in upload summary.
119 */ 125 */
120enum { 126enum
127{
121 UPLOAD_FILENAME = 0, 128 UPLOAD_FILENAME = 0,
122 UPLOAD_PROGRESS, 129 UPLOAD_PROGRESS,
123 UPLOAD_URISTRING, 130 UPLOAD_URISTRING,
@@ -125,14 +132,16 @@ enum {
125 UPLOAD_NUM 132 UPLOAD_NUM
126}; 133};
127 134
128enum { 135enum
136{
129 META_TYPE = 0, 137 META_TYPE = 0,
130 META_STYPE, 138 META_STYPE,
131 META_VALUE, 139 META_VALUE,
132 META_NUM, 140 META_NUM,
133}; 141};
134 142
135enum { 143enum
144{
136 KTYPE_STRING = 0, 145 KTYPE_STRING = 0,
137 KTYPE_TYPE, 146 KTYPE_TYPE,
138 KTYPE_NUM, 147 KTYPE_NUM,
@@ -142,62 +151,63 @@ enum {
142/** 151/**
143 * @brief linked list of pages in the search notebook 152 * @brief linked list of pages in the search notebook
144 */ 153 */
145typedef struct SL { 154typedef struct SL
146 struct SL * next; 155{
156 struct SL *next;
147 /** 157 /**
148 * Reference to the glade XML context that was 158 * Reference to the glade XML context that was
149 * used to create the search page. 159 * used to create the search page.
150 */ 160 */
151 GladeXML * searchXML; 161 GladeXML *searchXML;
152 162
153 /** 163 /**
154 * Reference to the glade XML context that was 164 * Reference to the glade XML context that was
155 * used to create the search label. 165 * used to create the search label.
156 */ 166 */
157 GladeXML * labelXML; 167 GladeXML *labelXML;
158 168
159 /** 169 /**
160 * Tree view widget that is used to display the 170 * Tree view widget that is used to display the
161 * search results. 171 * search results.
162 */ 172 */
163 GtkTreeView * treeview; 173 GtkTreeView *treeview;
164 174
165 /** 175 /**
166 * Model of the tree view. 176 * Model of the tree view.
167 */ 177 */
168 GtkTreeStore * tree; 178 GtkTreeStore *tree;
169 179
170 /** 180 /**
171 * The label used in the notebook page. 181 * The label used in the notebook page.
172 */ 182 */
173 GtkWidget * tab_label; 183 GtkWidget *tab_label;
174 184
175 /** 185 /**
176 * The notebook page that is associated with this 186 * The notebook page that is associated with this
177 * search. 187 * search.
178 */ 188 */
179 GtkWidget * searchpage; 189 GtkWidget *searchpage;
180 190
181 /** 191 /**
182 * Path to the entry in the summary list 192 * Path to the entry in the summary list
183 * for this search. 193 * for this search.
184 */ 194 */
185 GtkTreeRowReference * summaryViewRowReference; 195 GtkTreeRowReference *summaryViewRowReference;
186 196
187 /** 197 /**
188 * URI for this search. 198 * URI for this search.
189 */ 199 */
190 struct ECRS_URI * uri; 200 struct ECRS_URI *uri;
191 201
192 /** 202 /**
193 * String describing the search. 203 * String describing the search.
194 */ 204 */
195 char * searchString; 205 char *searchString;
196 206
197 /** 207 /**
198 * FSUI search handle. 208 * FSUI search handle.
199 */ 209 */
200 struct FSUI_SearchList * fsui_list; 210 struct FSUI_SearchList *fsui_list;
201 211
202 /** 212 /**
203 * Number of results received so far. 213 * Number of results received so far.
@@ -217,29 +227,30 @@ typedef struct SL {
217} SearchList; 227} SearchList;
218 228
219 229
220typedef struct DL { 230typedef struct DL
221 struct DL * next; 231{
232 struct DL *next;
222 233
223 /** 234 /**
224 * URI of the download. 235 * URI of the download.
225 */ 236 */
226 struct ECRS_URI * uri; 237 struct ECRS_URI *uri;
227 238
228 /** 239 /**
229 * Where is the download being saved to? 240 * Where is the download being saved to?
230 */ 241 */
231 char * filename; 242 char *filename;
232 243
233 /** 244 /**
234 * Path in the summary view for this download. 245 * Path in the summary view for this download.
235 */ 246 */
236 GtkTreeRowReference * summaryViewRowReference; 247 GtkTreeRowReference *summaryViewRowReference;
237 248
238 /** 249 /**
239 * Search that this download belongs to. 250 * Search that this download belongs to.
240 * Maybe NULL. 251 * Maybe NULL.
241 */ 252 */
242 struct SL * searchList; 253 struct SL *searchList;
243 254
244 /** 255 /**
245 * Path in the search view that this 256 * Path in the search view that this
@@ -247,12 +258,12 @@ typedef struct DL {
247 * if search has been closed or if download 258 * if search has been closed or if download
248 * was initiated from URI without search. 259 * was initiated from URI without search.
249 */ 260 */
250 GtkTreeRowReference * searchViewRowReference; 261 GtkTreeRowReference *searchViewRowReference;
251 262
252 /** 263 /**
253 * FSUI reference for the download. 264 * FSUI reference for the download.
254 */ 265 */
255 struct FSUI_DownloadList * fsui_list; 266 struct FSUI_DownloadList *fsui_list;
256 267
257 /** 268 /**
258 * Total size of the download. 269 * Total size of the download.
@@ -268,25 +279,26 @@ typedef struct DL {
268 279
269} DownloadList; 280} DownloadList;
270 281
271typedef struct UL { 282typedef struct UL
272 struct UL * next; 283{
284 struct UL *next;
273 285
274 /** 286 /**
275 * Which file or directory are we uploading? 287 * Which file or directory are we uploading?
276 */ 288 */
277 char * filename; 289 char *filename;
278 290
279 /** 291 /**
280 * Path in the summary view for this download. 292 * Path in the summary view for this download.
281 */ 293 */
282 GtkTreeRowReference * summaryViewRowReference; 294 GtkTreeRowReference *summaryViewRowReference;
283 295
284 struct FSUI_UploadList * fsui_list; 296 struct FSUI_UploadList *fsui_list;
285 297
286 /** 298 /**
287 * Set to final URI upon successful completion. 299 * Set to final URI upon successful completion.
288 */ 300 */
289 struct ECRS_URI * uri; 301 struct ECRS_URI *uri;
290 302
291 /** 303 /**
292 * Total size of the upload. 304 * Total size of the upload.
@@ -299,25 +311,25 @@ typedef struct UL {
299 311
300} UploadList; 312} UploadList;
301 313
302extern struct FSUI_Context * ctx; 314extern struct FSUI_Context *ctx;
303 315
304extern struct GE_Context * ectx; 316extern struct GE_Context *ectx;
305 317
306extern struct GC_Configuration * cfg; 318extern struct GC_Configuration *cfg;
307 319
308extern SearchList * search_head; 320extern SearchList *search_head;
309 321
310extern DownloadList * download_head; 322extern DownloadList *download_head;
311 323
312extern UploadList * upload_head; 324extern UploadList *upload_head;
313 325
314extern GtkListStore * search_summary; 326extern GtkListStore *search_summary;
315 327
316extern GtkTreeStore * download_summary; 328extern GtkTreeStore *download_summary;
317 329
318extern GtkTreeStore * upload_summary; 330extern GtkTreeStore *upload_summary;
319 331
320const char * getColorCode(enum URITRACK_STATE state); 332const char *getColorCode (enum URITRACK_STATE state);
321 333
322 334
323#endif 335#endif
diff --git a/src/plugins/fs/helper.c b/src/plugins/fs/helper.c
index f371505e..a0957628 100644
--- a/src/plugins/fs/helper.c
+++ b/src/plugins/fs/helper.c
@@ -37,91 +37,64 @@
37 * @param val set to the computed time 37 * @param val set to the computed time
38 * @return OK on success, SYSERR on error 38 * @return OK on success, SYSERR on error
39 */ 39 */
40int parseTime(const char * t, 40int
41 TIME_T * param) { 41parseTime (const char *t, TIME_T * param)
42{
42 int pos; 43 int pos;
43 int start; 44 int start;
44 unsigned int val; 45 unsigned int val;
45 char * tmp; 46 char *tmp;
46 cron_t ret; 47 cron_t ret;
47 48
48 ret = 0; 49 ret = 0;
49 pos = 0; 50 pos = 0;
50 51
51 while (t[pos] != '\0') { 52 while (t[pos] != '\0')
52 start = pos; 53 {
53 while ( (isdigit(t[pos])) && 54 start = pos;
54 (t[pos] != '\0') ) 55 while ((isdigit (t[pos])) && (t[pos] != '\0'))
55 pos++; 56 pos++;
56 tmp = STRNDUP(&t[start], 57 tmp = STRNDUP (&t[start], pos - start);
57 pos - start); 58 if (1 != sscanf (tmp, "%u", &val))
58 if (1 != sscanf(tmp, 59 return -1; /* parse error */
59 "%u", 60 FREE (tmp);
60 &val) ) 61 while (t[pos] == ' ')
61 return -1; /* parse error */ 62 pos++;
62 FREE(tmp); 63 start = pos;
63 while ( t[pos] == ' ') 64 while ((t[pos] != ' ') && (t[pos] != '\0'))
64 pos++; 65 pos++;
65 start = pos; 66 if (0 == strncasecmp (&t[start], _("ms"), strlen (_("ms"))))
66 while ( (t[pos] != ' ') && 67 ret += cronMILLIS * val;
67 (t[pos] != '\0') ) 68 if (0 == strncasecmp (&t[start], _("minutes"), strlen (_("minutes"))))
68 pos++; 69 ret += cronMINUTES * val;
69 if (0 == strncasecmp(&t[start], 70 else if (0 == strncasecmp (&t[start],
70 _("ms"), 71 _("seconds"), strlen (_("seconds"))))
71 strlen(_("ms")))) 72 ret += cronSECONDS * val;
72 ret += cronMILLIS * val; 73 else if (0 == strncasecmp (&t[start], _("hours"), strlen (_("hours"))))
73 if (0 == strncasecmp(&t[start], 74 ret += cronHOURS * val;
74 _("minutes"), 75 else if (0 == strncasecmp (&t[start], _("days"), strlen (_("days"))))
75 strlen(_("minutes")))) 76 ret += cronDAYS * val;
76 ret += cronMINUTES * val; 77 else
77 else if (0 == strncasecmp(&t[start], 78 if (0 == strncasecmp (&t[start], _("minute"), strlen (_("minute"))))
78 _("seconds"), 79 ret += cronMINUTES * val;
79 strlen(_("seconds")))) 80 else if (0 == strncasecmp (&t[start],
80 ret += cronSECONDS * val; 81 _("second"), strlen (_("second"))))
81 else if (0 == strncasecmp(&t[start], 82 ret += cronSECONDS * val;
82 _("hours"), 83 else if (0 == strncasecmp (&t[start], _("hour"), strlen (_("hour"))))
83 strlen(_("hours")))) 84 ret += cronHOURS * val;
84 ret += cronHOURS * val; 85 else if (0 == strncasecmp (&t[start], _("day"), strlen (_("day"))))
85 else if (0 == strncasecmp(&t[start], 86 ret += cronDAYS * val;
86 _("days"), 87 else if (0 == strncasecmp (&t[start], "m", strlen ("m")))
87 strlen(_("days")))) 88 ret += cronMINUTES * val;
88 ret += cronDAYS * val; 89 else if (0 == strncasecmp (&t[start], "s", strlen ("s")))
89 else 90 ret += cronSECONDS * val;
90 if (0 == strncasecmp(&t[start], 91 else if (0 == strncasecmp (&t[start], "h", strlen ("h")))
91 _("minute"), 92 ret += cronHOURS * val;
92 strlen(_("minute")))) 93 else
93 ret += cronMINUTES * val; 94 return SYSERR; /* parse error */
94 else if (0 == strncasecmp(&t[start], 95 while (t[pos] == ' ')
95 _("second"), 96 pos++;
96 strlen(_("second")))) 97 }
97 ret += cronSECONDS * val;
98 else if (0 == strncasecmp(&t[start],
99 _("hour"),
100 strlen(_("hour"))))
101 ret += cronHOURS * val;
102 else if (0 == strncasecmp(&t[start],
103 _("day"),
104 strlen(_("day"))))
105 ret += cronDAYS * val;
106 else if (0 == strncasecmp(&t[start],
107 "m",
108 strlen("m")))
109 ret += cronMINUTES * val;
110 else if (0 == strncasecmp(&t[start],
111 "s",
112 strlen("s")))
113 ret += cronSECONDS * val;
114 else if (0 == strncasecmp(&t[start],
115 "h",
116 strlen("h")))
117 ret += cronHOURS * val;
118 else
119 return SYSERR; /* parse error */
120 while ( t[pos] == ' ')
121 pos++;
122 }
123 *param = ret / cronSECONDS; 98 *param = ret / cronSECONDS;
124 return OK; 99 return OK;
125} 100}
126
127
diff --git a/src/plugins/fs/helper.h b/src/plugins/fs/helper.h
index f91940a8..9fa44a69 100644
--- a/src/plugins/fs/helper.h
+++ b/src/plugins/fs/helper.h
@@ -35,15 +35,12 @@
35 * @param the title of the new label 35 * @param the title of the new label
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 *buildSearchTabLabel (GtkWidget * searchPage, const char *title);
39buildSearchTabLabel(GtkWidget *searchPage,
40 const char *title);
41 39
42 40
43GtkWidget * 41GtkWidget *makeSearchResultFrame (struct GC_Configuration *cfg,
44makeSearchResultFrame(struct GC_Configuration * cfg, 42 GtkWidget ** treeview,
45 GtkWidget ** treeview, 43 GtkWidget ** anonSpin);
46 GtkWidget ** anonSpin);
47 44
48/** 45/**
49 * Parse a time given in the form 46 * Parse a time given in the form
@@ -52,7 +49,6 @@ makeSearchResultFrame(struct GC_Configuration * cfg,
52 * @param val set to the computed time 49 * @param val set to the computed time
53 * @return OK on success, SYSERR on error 50 * @return OK on success, SYSERR on error
54 */ 51 */
55int parseTime(const char * t, 52int parseTime (const char *t, TIME_T * val);
56 TIME_T * val);
57 53
58#endif 54#endif
diff --git a/src/plugins/fs/meta.c b/src/plugins/fs/meta.c
index c1665251..b5861ebf 100644
--- a/src/plugins/fs/meta.c
+++ b/src/plugins/fs/meta.c
@@ -31,602 +31,541 @@
31#include "fs.h" 31#include "fs.h"
32#include <extractor.h> 32#include <extractor.h>
33 33
34static int publishMetaData(EXTRACTOR_KeywordType type, 34static int
35 const char * data, 35publishMetaData (EXTRACTOR_KeywordType type, const char *data, void *cls)
36 void * cls) { 36{
37 GtkListStore * store = cls; 37 GtkListStore *store = cls;
38 const char * stype; 38 const char *stype;
39 GtkTreeIter iter; 39 GtkTreeIter iter;
40 40
41 stype = EXTRACTOR_getKeywordTypeAsString(type); 41 stype = EXTRACTOR_getKeywordTypeAsString (type);
42 if (stype == NULL) /* wrong LE version!? */ 42 if (stype == NULL) /* wrong LE version!? */
43 stype = _("unknown"); 43 stype = _("unknown");
44 gtk_list_store_append(store, 44 gtk_list_store_append (store, &iter);
45 &iter); 45 gtk_list_store_set (store,
46 gtk_list_store_set(store, 46 &iter,
47 &iter, 47 META_TYPE, type,
48 META_TYPE, type, 48 META_STYPE, stype, META_VALUE, data, -1);
49 META_STYPE, stype,
50 META_VALUE, data,
51 -1);
52 return OK; 49 return OK;
53} 50}
54 51
55void createMetaDataListTreeView(GladeXML * xml, 52void
56 const char * name, 53createMetaDataListTreeView (GladeXML * xml,
57 const char * previewName, 54 const char *name,
58 const struct ECRS_MetaData * init) { 55 const char *previewName,
59 GtkTreeView * metaList; 56 const struct ECRS_MetaData *init)
60 GtkListStore * metamodel; 57{
61 GtkCellRenderer * renderer; 58 GtkTreeView *metaList;
62 GtkWidget * preview; 59 GtkListStore *metamodel;
63 GdkPixbuf * pixbuf; 60 GtkCellRenderer *renderer;
64 GdkPixbufLoader * loader; 61 GtkWidget *preview;
65 unsigned char * thumb; 62 GdkPixbuf *pixbuf;
63 GdkPixbufLoader *loader;
64 unsigned char *thumb;
66 size_t ts; 65 size_t ts;
67 GtkTreeViewColumn * column; 66 GtkTreeViewColumn *column;
68 int col; 67 int col;
69 68
70 DEBUG_BEGIN(); 69 DEBUG_BEGIN ();
71 metamodel 70 metamodel
72 = gtk_list_store_new(META_NUM, 71 = gtk_list_store_new (META_NUM, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
73 G_TYPE_INT, 72 metaList = GTK_TREE_VIEW (glade_xml_get_widget (xml, name));
74 G_TYPE_STRING, 73 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (metaList),
75 G_TYPE_STRING); 74 GTK_SELECTION_MULTIPLE);
76 metaList = GTK_TREE_VIEW(glade_xml_get_widget(xml, 75 renderer = gtk_cell_renderer_text_new ();
77 name)); 76 col = gtk_tree_view_insert_column_with_attributes (metaList,
78 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(metaList), 77 -1,
79 GTK_SELECTION_MULTIPLE); 78 _("Category"),
80 renderer = gtk_cell_renderer_text_new(); 79 renderer,
81 col = gtk_tree_view_insert_column_with_attributes(metaList, 80 "text", META_STYPE,
82 -1, 81 NULL);
83 _("Category"), 82 column = gtk_tree_view_get_column (metaList, col - 1);
84 renderer, 83 gtk_tree_view_column_set_resizable (column, TRUE);
85 "text", META_STYPE, 84 gtk_tree_view_column_set_clickable (column, TRUE);
86 NULL); 85 gtk_tree_view_column_set_reorderable (column, TRUE);
87 column = gtk_tree_view_get_column(metaList, 86 gtk_tree_view_column_set_sort_column_id (column, META_STYPE);
88 col - 1); 87 renderer = gtk_cell_renderer_text_new ();
89 gtk_tree_view_column_set_resizable(column, TRUE); 88 col = gtk_tree_view_insert_column_with_attributes (metaList,
90 gtk_tree_view_column_set_clickable(column, TRUE); 89 -1,
91 gtk_tree_view_column_set_reorderable(column, TRUE); 90 _("Value"),
92 gtk_tree_view_column_set_sort_column_id(column, META_STYPE); 91 renderer,
93 renderer = gtk_cell_renderer_text_new(); 92 "text", META_VALUE,
94 col = gtk_tree_view_insert_column_with_attributes(metaList, 93 NULL);
95 -1, 94 column = gtk_tree_view_get_column (metaList, col - 1);
96 _("Value"), 95 gtk_tree_view_column_set_resizable (column, TRUE);
97 renderer, 96 gtk_tree_view_column_set_clickable (column, TRUE);
98 "text", META_VALUE, 97 gtk_tree_view_column_set_reorderable (column, TRUE);
99 NULL); 98 gtk_tree_view_column_set_sort_column_id (column, META_VALUE);
100 column = gtk_tree_view_get_column(metaList, 99 gtk_tree_view_set_model (metaList, GTK_TREE_MODEL (metamodel));
101 col - 1);
102 gtk_tree_view_column_set_resizable(column, TRUE);
103 gtk_tree_view_column_set_clickable(column, TRUE);
104 gtk_tree_view_column_set_reorderable(column, TRUE);
105 gtk_tree_view_column_set_sort_column_id(column, META_VALUE);
106 gtk_tree_view_set_model(metaList,
107 GTK_TREE_MODEL(metamodel));
108 100
109 if (init != NULL) 101 if (init != NULL)
110 ECRS_getMetaData(init, 102 ECRS_getMetaData (init, &publishMetaData, metamodel);
111 &publishMetaData, 103 if ((previewName == NULL) || (init == NULL))
112 metamodel);
113 if ( (previewName == NULL) ||
114 (init == NULL) )
115 return; 104 return;
116 preview = glade_xml_get_widget(xml, 105 preview = glade_xml_get_widget (xml, previewName);
117 previewName);
118 106
119 thumb = NULL; 107 thumb = NULL;
120 ts = ECRS_getThumbnailFromMetaData(init, 108 ts = ECRS_getThumbnailFromMetaData (init, &thumb);
121 &thumb); 109 preview = glade_xml_get_widget (xml, previewName);
122 preview = glade_xml_get_widget(xml, 110 if (ts != 0)
123 previewName); 111 {
124 if (ts != 0) { 112 loader = gdk_pixbuf_loader_new ();
125 loader = gdk_pixbuf_loader_new(); 113 gdk_pixbuf_loader_write (loader, (const guchar *) thumb, ts, NULL);
126 gdk_pixbuf_loader_write(loader, 114 pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
127 (const guchar*) thumb, 115 g_object_ref (pixbuf);
128 ts, 116 gdk_pixbuf_loader_close (loader, NULL);
129 NULL); 117 if (pixbuf != NULL)
130 pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); 118 {
131 g_object_ref(pixbuf); 119 gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf);
132 gdk_pixbuf_loader_close(loader, 120 g_object_unref (pixbuf);
133 NULL); 121 }
134 if (pixbuf != NULL) { 122 UNREF (loader);
135 gtk_image_set_from_pixbuf(GTK_IMAGE(preview),
136 pixbuf);
137 g_object_unref(pixbuf);
138 } 123 }
139 UNREF(loader); 124 DEBUG_END ();
140 }
141 DEBUG_END();
142} 125}
143 126
144static int publishKeyword(const char * data, 127static int
145 void * cls) { 128publishKeyword (const char *data, void *cls)
146 GtkListStore * store = cls; 129{
130 GtkListStore *store = cls;
147 GtkTreeIter iter; 131 GtkTreeIter iter;
148 132
149 DEBUG_BEGIN(); 133 DEBUG_BEGIN ();
150 gtk_list_store_append(store, 134 gtk_list_store_append (store, &iter);
151 &iter); 135 gtk_list_store_set (store, &iter, 0, data, -1);
152 gtk_list_store_set(store, 136 DEBUG_END ();
153 &iter,
154 0, data,
155 -1);
156 DEBUG_END();
157 return OK; 137 return OK;
158} 138}
159 139
160void createKeywordListTreeView(GladeXML * xml, 140void
161 const char * name, 141createKeywordListTreeView (GladeXML * xml,
162 const struct ECRS_URI * init) { 142 const char *name, const struct ECRS_URI *init)
163 GtkTreeView * keywordList; 143{
164 GtkListStore * keymodel; 144 GtkTreeView *keywordList;
165 GtkCellRenderer * renderer; 145 GtkListStore *keymodel;
166 GtkTreeViewColumn * column; 146 GtkCellRenderer *renderer;
167 147 GtkTreeViewColumn *column;
168 DEBUG_BEGIN(); 148
169 keymodel 149 DEBUG_BEGIN ();
170 = gtk_list_store_new(1, 150 keymodel = gtk_list_store_new (1, G_TYPE_STRING);
171 G_TYPE_STRING); 151 keywordList = GTK_TREE_VIEW (glade_xml_get_widget (xml, name));
172 keywordList = GTK_TREE_VIEW(glade_xml_get_widget(xml, 152 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (keywordList),
173 name)); 153 GTK_SELECTION_MULTIPLE);
174 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(keywordList), 154 renderer = gtk_cell_renderer_text_new ();
175 GTK_SELECTION_MULTIPLE); 155 gtk_tree_view_insert_column_with_attributes (keywordList,
176 renderer = gtk_cell_renderer_text_new(); 156 -1,
177 gtk_tree_view_insert_column_with_attributes(keywordList, 157 _("Keyword"),
178 -1, 158 renderer, "text", 0, NULL);
179 _("Keyword"), 159 column = gtk_tree_view_get_column (keywordList, 0);
180 renderer, 160 gtk_tree_view_column_set_resizable (column, TRUE);
181 "text", 0, 161 gtk_tree_view_column_set_clickable (column, TRUE);
182 NULL); 162 gtk_tree_view_column_set_reorderable (column, TRUE);
183 column = gtk_tree_view_get_column(keywordList, 163 gtk_tree_view_column_set_sort_column_id (column, 0);
184 0); 164 gtk_tree_view_set_model (keywordList, GTK_TREE_MODEL (keymodel));
185 gtk_tree_view_column_set_resizable(column, TRUE);
186 gtk_tree_view_column_set_clickable(column, TRUE);
187 gtk_tree_view_column_set_reorderable(column, TRUE);
188 gtk_tree_view_column_set_sort_column_id(column, 0);
189 gtk_tree_view_set_model(keywordList,
190 GTK_TREE_MODEL(keymodel));
191 if (init != NULL) 165 if (init != NULL)
192 ECRS_getKeywordsFromUri(init, 166 ECRS_getKeywordsFromUri (init, &publishKeyword, keymodel);
193 &publishKeyword, 167 DEBUG_END ();
194 keymodel);
195 DEBUG_END();
196} 168}
197 169
198void createMetaTypeComboBox(GladeXML * xml, 170void
199 const char * name) { 171createMetaTypeComboBox (GladeXML * xml, const char *name)
200 const char * stype; 172{
201 GtkWidget * metaType; 173 const char *stype;
202 GtkCellRenderer * renderer; 174 GtkWidget *metaType;
203 GtkListStore * keywordTypeModel; 175 GtkCellRenderer *renderer;
176 GtkListStore *keywordTypeModel;
204 GtkTreeIter iter; 177 GtkTreeIter iter;
205 EXTRACTOR_KeywordType type; 178 EXTRACTOR_KeywordType type;
206 179
207 DEBUG_BEGIN(); 180 DEBUG_BEGIN ();
208 keywordTypeModel 181 keywordTypeModel
209 = gtk_list_store_new(KTYPE_NUM, 182 = gtk_list_store_new (KTYPE_NUM, G_TYPE_STRING, G_TYPE_INT);
210 G_TYPE_STRING, 183 metaType = glade_xml_get_widget (xml, name);
211 G_TYPE_INT); 184 gtk_combo_box_set_model (GTK_COMBO_BOX (metaType),
212 metaType = glade_xml_get_widget(xml, 185 GTK_TREE_MODEL (keywordTypeModel));
213 name); 186 for (type = 0; type < EXTRACTOR_getHighestKeywordTypeNumber (); type++)
214 gtk_combo_box_set_model(GTK_COMBO_BOX(metaType), 187 {
215 GTK_TREE_MODEL(keywordTypeModel)); 188 stype = EXTRACTOR_getKeywordTypeAsString (type);
216 for (type=0;type<EXTRACTOR_getHighestKeywordTypeNumber();type++) { 189 gtk_list_store_append (keywordTypeModel, &iter);
217 stype = EXTRACTOR_getKeywordTypeAsString(type); 190 gtk_list_store_set (keywordTypeModel,
218 gtk_list_store_append(keywordTypeModel, 191 &iter, KTYPE_STRING, stype, KTYPE_TYPE, type, -1);
219 &iter); 192 }
220 gtk_list_store_set(keywordTypeModel, 193 renderer = gtk_cell_renderer_text_new ();
221 &iter, 194 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (metaType), renderer, FALSE);
222 KTYPE_STRING, stype, 195 gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (metaType),
223 KTYPE_TYPE, type, 196 renderer, "text", KTYPE_STRING);
224 -1); 197 gtk_combo_box_set_active (GTK_COMBO_BOX (metaType), 0);
225 } 198 DEBUG_END ();
226 renderer = gtk_cell_renderer_text_new();
227 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(metaType),
228 renderer,
229 FALSE);
230 gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(metaType),
231 renderer,
232 "text", KTYPE_STRING);
233 gtk_combo_box_set_active(GTK_COMBO_BOX(metaType),
234 0);
235 DEBUG_END();
236} 199}
237 200
238void handleKeywordListUpdate(GladeXML * xml, 201void
239 const char * inputLineName, 202handleKeywordListUpdate (GladeXML * xml,
240 const char * keywordListName) { 203 const char *inputLineName,
241 const char * keyword; 204 const char *keywordListName)
242 GtkWidget * keywordList; 205{
243 GtkWidget * entryLine; 206 const char *keyword;
244 GtkListStore * keymodel; 207 GtkWidget *keywordList;
208 GtkWidget *entryLine;
209 GtkListStore *keymodel;
245 GtkTreeIter iter; 210 GtkTreeIter iter;
246 211
247 DEBUG_BEGIN(); 212 DEBUG_BEGIN ();
248 keywordList = glade_xml_get_widget(xml, 213 keywordList = glade_xml_get_widget (xml, keywordListName);
249 keywordListName);
250 keymodel 214 keymodel
251 = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(keywordList))); 215 = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (keywordList)));
252 216
253 entryLine = glade_xml_get_widget(xml, 217 entryLine = glade_xml_get_widget (xml, inputLineName);
254 inputLineName); 218 keyword = gtk_entry_get_text (GTK_ENTRY (entryLine));
255 keyword = gtk_entry_get_text(GTK_ENTRY(entryLine)); 219 gtk_list_store_append (keymodel, &iter);
256 gtk_list_store_append(keymodel, 220 gtk_list_store_set (keymodel, &iter, 0, keyword, -1);
257 &iter); 221 gtk_entry_set_text (GTK_ENTRY (entryLine), "");
258 gtk_list_store_set(keymodel, 222 DEBUG_END ();
259 &iter,
260 0, keyword,
261 -1);
262 gtk_entry_set_text(GTK_ENTRY(entryLine), "");
263 DEBUG_END();
264} 223}
265 224
266void handleMetaDataListUpdate(GladeXML * xml, 225void
267 const char * typeInputLineName, 226handleMetaDataListUpdate (GladeXML * xml,
268 const char * valueInputLineName, 227 const char *typeInputLineName,
269 const char * metaDataListName) { 228 const char *valueInputLineName,
270 const char * value; 229 const char *metaDataListName)
271 GtkWidget * metaList; 230{
272 GtkWidget * entryLine; 231 const char *value;
273 GtkWidget * typeCB; 232 GtkWidget *metaList;
233 GtkWidget *entryLine;
234 GtkWidget *typeCB;
274 EXTRACTOR_KeywordType type; 235 EXTRACTOR_KeywordType type;
275 GtkListStore * metamodel; 236 GtkListStore *metamodel;
276 GtkListStore * typemodel; 237 GtkListStore *typemodel;
277 GtkTreeIter iter; 238 GtkTreeIter iter;
278 char * stype; 239 char *stype;
279 240
280 DEBUG_BEGIN(); 241 DEBUG_BEGIN ();
281 metaList = glade_xml_get_widget(xml, 242 metaList = glade_xml_get_widget (xml, metaDataListName);
282 metaDataListName);
283 metamodel 243 metamodel
284 = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(metaList))); 244 = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (metaList)));
285 245
286 entryLine = glade_xml_get_widget(xml, 246 entryLine = glade_xml_get_widget (xml, valueInputLineName);
287 valueInputLineName); 247 value = gtk_entry_get_text (GTK_ENTRY (entryLine));
288 value = gtk_entry_get_text(GTK_ENTRY(entryLine)); 248 if ((value == NULL) || (strlen (value) == 0))
289 if ( (value == NULL) || (strlen(value) == 0) )
290 return; 249 return;
291 typeCB = glade_xml_get_widget(xml, 250 typeCB = glade_xml_get_widget (xml, typeInputLineName);
292 typeInputLineName);
293 typemodel 251 typemodel
294 = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(typeCB))); 252 = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (typeCB)));
295 if (! gtk_combo_box_get_active_iter(GTK_COMBO_BOX(typeCB), 253 if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (typeCB), &iter))
296 &iter)) 254 return; /* oops */
297 return; /* oops */ 255 gtk_tree_model_get (GTK_TREE_MODEL (typemodel),
298 gtk_tree_model_get(GTK_TREE_MODEL(typemodel), 256 &iter, KTYPE_STRING, &stype, KTYPE_TYPE, &type, -1);
299 &iter, 257 gtk_list_store_append (metamodel, &iter);
300 KTYPE_STRING, &stype, 258 gtk_list_store_set (metamodel,
301 KTYPE_TYPE, &type, 259 &iter,
302 -1); 260 META_TYPE, type,
303 gtk_list_store_append(metamodel, 261 META_STYPE, stype, META_VALUE, value, -1);
304 &iter); 262 gtk_entry_set_text (GTK_ENTRY (entryLine), "");
305 gtk_list_store_set(metamodel, 263 FREENONNULL (stype);
306 &iter, 264 DEBUG_END ();
307 META_TYPE, type,
308 META_STYPE, stype,
309 META_VALUE, value,
310 -1);
311 gtk_entry_set_text(GTK_ENTRY(entryLine), "");
312 FREENONNULL(stype);
313 DEBUG_END();
314} 265}
315 266
316static void removeRow(GtkTreeModel * model, 267static void
317 GtkTreePath * path, 268removeRow (GtkTreeModel * model,
318 GtkTreeIter * iter, 269 GtkTreePath * path, GtkTreeIter * iter, gpointer unused)
319 gpointer unused) { 270{
320 gtk_list_store_remove(GTK_LIST_STORE(model), 271 gtk_list_store_remove (GTK_LIST_STORE (model), iter);
321 iter);
322} 272}
323 273
324void handleListRemove(GladeXML * xml, 274void
325 const char * listName) { 275handleListRemove (GladeXML * xml, const char *listName)
326 GtkWidget * list; 276{
277 GtkWidget *list;
327 278
328 list = glade_xml_get_widget(xml, 279 list = glade_xml_get_widget (xml, listName);
329 listName);
330 ggc_tree_selection_selected_foreach 280 ggc_tree_selection_selected_foreach
331 (gtk_tree_view_get_selection(GTK_TREE_VIEW(list)), 281 (gtk_tree_view_get_selection (GTK_TREE_VIEW (list)), &removeRow, NULL);
332 &removeRow,
333 NULL);
334} 282}
335 283
336#define THUMBSIZE 128 284#define THUMBSIZE 128
337 285
338 286
339struct ECRS_MetaData * getMetaDataFromList(GladeXML * xml, 287struct ECRS_MetaData *
340 const char * name, 288getMetaDataFromList (GladeXML * xml,
341 const char * previewName) { 289 const char *name, const char *previewName)
342 GtkWidget * metaList; 290{
343 GtkWidget * preview; 291 GtkWidget *metaList;
344 GtkTreeModel * metamodel; 292 GtkWidget *preview;
293 GtkTreeModel *metamodel;
345 GtkTreeIter iter; 294 GtkTreeIter iter;
346 struct ECRS_MetaData * meta; 295 struct ECRS_MetaData *meta;
347 EXTRACTOR_KeywordType type; 296 EXTRACTOR_KeywordType type;
348 GdkPixbuf * pixbuf; 297 GdkPixbuf *pixbuf;
349 GdkPixbuf * out; 298 GdkPixbuf *out;
350 char * mvalue; 299 char *mvalue;
351 size_t length; 300 size_t length;
352 unsigned long width; 301 unsigned long width;
353 unsigned long height; 302 unsigned long height;
354 char * thumb; 303 char *thumb;
355 304
356 metaList = glade_xml_get_widget(xml, 305 metaList = glade_xml_get_widget (xml, name);
357 name); 306 metamodel = gtk_tree_view_get_model (GTK_TREE_VIEW (metaList));
358 metamodel = gtk_tree_view_get_model(GTK_TREE_VIEW(metaList)); 307 meta = ECRS_createMetaData ();
359 meta = ECRS_createMetaData(); 308 if (gtk_tree_model_get_iter_first (metamodel, &iter))
360 if (gtk_tree_model_get_iter_first(metamodel, 309 {
361 &iter)) { 310 do
362 do { 311 {
363 gtk_tree_model_get(metamodel, 312 gtk_tree_model_get (metamodel,
364 &iter, 313 &iter,
365 META_TYPE, &type, 314 META_TYPE, &type, META_VALUE, &mvalue, -1);
366 META_VALUE, &mvalue, 315 ECRS_addToMetaData (meta, type, mvalue);
367 -1); 316 FREENONNULL (mvalue);
368 ECRS_addToMetaData(meta, 317 }
369 type, 318 while (gtk_tree_model_iter_next (metamodel, &iter));
370 mvalue); 319 }
371 FREENONNULL(mvalue);
372 } while (gtk_tree_model_iter_next(metamodel,
373 &iter));
374 }
375 if (previewName == NULL) 320 if (previewName == NULL)
376 return meta; 321 return meta;
377 322
378 preview = glade_xml_get_widget(xml, 323 preview = glade_xml_get_widget (xml, previewName);
379 previewName); 324
380 325 if (GTK_IMAGE_PIXBUF == gtk_image_get_storage_type (GTK_IMAGE (preview)))
381 if (GTK_IMAGE_PIXBUF == 326 {
382 gtk_image_get_storage_type(GTK_IMAGE(preview))) { 327 pixbuf = gtk_image_get_pixbuf (GTK_IMAGE (preview));
383 pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(preview)); 328 if (pixbuf == NULL)
384 if (pixbuf == NULL) 329 return meta;
385 return meta; 330 height = gdk_pixbuf_get_height (pixbuf);
386 height = gdk_pixbuf_get_height(pixbuf); 331 width = gdk_pixbuf_get_width (pixbuf);
387 width = gdk_pixbuf_get_width(pixbuf); 332 if ((height > THUMBSIZE) || (width > THUMBSIZE))
388 if ( (height > THUMBSIZE) || 333 {
389 (width > THUMBSIZE) ) { 334 if (height > THUMBSIZE)
390 if (height > THUMBSIZE) { 335 {
391 width = width * THUMBSIZE / height; 336 width = width * THUMBSIZE / height;
392 height = THUMBSIZE; 337 height = THUMBSIZE;
393 } 338 }
394 if (width > THUMBSIZE) { 339 if (width > THUMBSIZE)
395 height = height * THUMBSIZE / width; 340 {
396 width = THUMBSIZE; 341 height = height * THUMBSIZE / width;
397 } 342 width = THUMBSIZE;
398 out = gdk_pixbuf_scale_simple(pixbuf, 343 }
399 width, 344 out = gdk_pixbuf_scale_simple (pixbuf,
400 height, 345 width, height, GDK_INTERP_BILINEAR);
401 GDK_INTERP_BILINEAR); 346 g_object_unref (pixbuf);
402 g_object_unref(pixbuf); 347 pixbuf = out;
403 pixbuf = out; 348 }
349 if (pixbuf != NULL)
350 {
351 thumb = NULL;
352 if (gdk_pixbuf_save_to_buffer (pixbuf,
353 &thumb, &length, "png", NULL, NULL))
354 {
355 char *binary;
356
357 binary = EXTRACTOR_binaryEncode ((const unsigned char *) thumb,
358 length);
359 free (thumb);
360 ECRS_addToMetaData (meta, EXTRACTOR_THUMBNAIL_DATA, binary);
361 FREE (binary);
362 }
363 }
404 } 364 }
405 if (pixbuf != NULL) {
406 thumb = NULL;
407 if (gdk_pixbuf_save_to_buffer(pixbuf,
408 &thumb,
409 &length,
410 "png",
411 NULL,
412 NULL)) {
413 char * binary;
414
415 binary = EXTRACTOR_binaryEncode((const unsigned char*)thumb,
416 length);
417 free(thumb);
418 ECRS_addToMetaData(meta,
419 EXTRACTOR_THUMBNAIL_DATA,
420 binary);
421 FREE(binary);
422 }
423 }
424 }
425 return meta; 365 return meta;
426} 366}
427 367
428struct ECRS_URI * getKeywordURIFromList(GladeXML * xml, 368struct ECRS_URI *
429 const char * name) { 369getKeywordURIFromList (GladeXML * xml, const char *name)
430 GtkTreeModel * keymodel; 370{
431 GtkTreeView * keyList; 371 GtkTreeModel *keymodel;
372 GtkTreeView *keyList;
432 GtkTreeIter iter; 373 GtkTreeIter iter;
433 struct ECRS_URI * keywordURI; 374 struct ECRS_URI *keywordURI;
434 char * mvalue; 375 char *mvalue;
435 char ** keywords; 376 char **keywords;
436 unsigned int kpos; 377 unsigned int kpos;
437 unsigned int ksize; 378 unsigned int ksize;
438 379
439 DEBUG_BEGIN(); 380 DEBUG_BEGIN ();
440 keyList = GTK_TREE_VIEW(glade_xml_get_widget(xml, 381 keyList = GTK_TREE_VIEW (glade_xml_get_widget (xml, name));
441 name)); 382 keymodel = gtk_tree_view_get_model (keyList);
442 keymodel = gtk_tree_view_get_model(keyList);
443 383
444 keywords = NULL; 384 keywords = NULL;
445 ksize = 0; 385 ksize = 0;
446 GROW(keywords, 386 GROW (keywords, ksize, 64);
447 ksize,
448 64);
449 kpos = 0; 387 kpos = 0;
450 if (gtk_tree_model_get_iter_first(keymodel, 388 if (gtk_tree_model_get_iter_first (keymodel, &iter))
451 &iter)) { 389 {
452 do { 390 do
453 gtk_tree_model_get(keymodel, 391 {
454 &iter, 392 gtk_tree_model_get (keymodel, &iter, 0, &mvalue, -1);
455 0, &mvalue, 393 keywords[kpos++] = mvalue;
456 -1); 394 if (kpos == ksize)
457 keywords[kpos++] = mvalue; 395 GROW (keywords, ksize, kpos * 2);
458 if (kpos == ksize) 396 }
459 GROW(keywords, 397 while (gtk_tree_model_iter_next (keymodel, &iter));
460 ksize, 398 }
461 kpos*2);
462 } while (gtk_tree_model_iter_next(keymodel,
463 &iter));
464 }
465 keywords[kpos] = NULL; 399 keywords[kpos] = NULL;
466 400
467 keywordURI = ECRS_keywordsToUri((const char**)keywords); 401 keywordURI = ECRS_keywordsToUri ((const char **) keywords);
468 while (kpos > 0) 402 while (kpos > 0)
469 FREE(keywords[--kpos]); 403 FREE (keywords[--kpos]);
470 GROW(keywords, 404 GROW (keywords, ksize, 0);
471 ksize, 405 DEBUG_END ();
472 0);
473 DEBUG_END();
474 return keywordURI; 406 return keywordURI;
475} 407}
476 408
477char * updateIntervalToString(TIME_T interval) { 409char *
410updateIntervalToString (TIME_T interval)
411{
478 if (interval == ECRS_SBLOCK_UPDATE_SPORADIC) 412 if (interval == ECRS_SBLOCK_UPDATE_SPORADIC)
479 return strdup(_("--sporadic update--")); 413 return strdup (_("--sporadic update--"));
480 if (interval == ECRS_SBLOCK_UPDATE_NONE) 414 if (interval == ECRS_SBLOCK_UPDATE_NONE)
481 return strdup(_("--no update--")); 415 return strdup (_("--no update--"));
482 return string_get_fancy_time_interval(interval * cronSECONDS); 416 return string_get_fancy_time_interval (interval * cronSECONDS);
483} 417}
484 418
485int parseTimeInterval(const char * timeSpec, 419int
486 TIME_T * interval) { 420parseTimeInterval (const char *timeSpec, TIME_T * interval)
421{
487 if (timeSpec == NULL) 422 if (timeSpec == NULL)
488 return SYSERR; 423 return SYSERR;
489 if (0 == strcmp(_("--sporadic update--"), 424 if (0 == strcmp (_("--sporadic update--"), timeSpec))
490 timeSpec))
491 *interval = ECRS_SBLOCK_UPDATE_SPORADIC; 425 *interval = ECRS_SBLOCK_UPDATE_SPORADIC;
492 else if (0 == strcmp(_("--no update--"), 426 else if (0 == strcmp (_("--no update--"), timeSpec))
493 timeSpec))
494 *interval = ECRS_SBLOCK_UPDATE_NONE; 427 *interval = ECRS_SBLOCK_UPDATE_NONE;
495 else 428 else
496 return parseTime(timeSpec, 429 return parseTime (timeSpec, interval);
497 interval);
498 return OK; 430 return OK;
499} 431}
500 432
501int tryParseTimeInterval(GladeXML * xml, 433int
502 const char * intervalComboBoxEntry, 434tryParseTimeInterval (GladeXML * xml,
503 TIME_T * interval) { 435 const char *intervalComboBoxEntry, TIME_T * interval)
504 return parseTimeInterval(getEntryLineValue(xml, 436{
505 intervalComboBoxEntry), 437 return parseTimeInterval (getEntryLineValue (xml,
506 interval); 438 intervalComboBoxEntry),
439 interval);
507} 440}
508 441
509unsigned int getSpinButtonValue(GladeXML * xml, 442unsigned int
510 const char * spinButtonName) { 443getSpinButtonValue (GladeXML * xml, const char *spinButtonName)
511 GtkWidget * spin; 444{
445 GtkWidget *spin;
512 446
513 spin = glade_xml_get_widget(xml, 447 spin = glade_xml_get_widget (xml, spinButtonName);
514 spinButtonName); 448 return gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin));
515 return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
516} 449}
517 450
518 451
519 452
520char * getMimeTypeFromMetaData(const struct ECRS_MetaData * meta) { 453char *
521 char * mime; 454getMimeTypeFromMetaData (const struct ECRS_MetaData *meta)
455{
456 char *mime;
522 457
523 mime = ECRS_getFromMetaData(meta, 458 mime = ECRS_getFromMetaData (meta, EXTRACTOR_MIMETYPE);
524 EXTRACTOR_MIMETYPE);
525 if (mime == NULL) 459 if (mime == NULL)
526 mime = STRDUP(_("unknown")); 460 mime = STRDUP (_("unknown"));
527 return validate_utf8(mime); 461 return validate_utf8 (mime);
528} 462}
529 463
530char * getFileNameFromMetaData(const struct ECRS_MetaData * meta) { 464char *
531 char * name; 465getFileNameFromMetaData (const struct ECRS_MetaData *meta)
532 466{
533 name = ECRS_getFirstFromMetaData(meta, 467 char *name;
534 EXTRACTOR_FILENAME, 468
535 EXTRACTOR_TITLE, 469 name = ECRS_getFirstFromMetaData (meta,
536 EXTRACTOR_ARTIST, 470 EXTRACTOR_FILENAME,
537 EXTRACTOR_AUTHOR, 471 EXTRACTOR_TITLE,
538 EXTRACTOR_PUBLISHER, 472 EXTRACTOR_ARTIST,
539 EXTRACTOR_CREATOR, 473 EXTRACTOR_AUTHOR,
540 EXTRACTOR_PRODUCER, 474 EXTRACTOR_PUBLISHER,
541 EXTRACTOR_UNKNOWN, 475 EXTRACTOR_CREATOR,
542 -1); 476 EXTRACTOR_PRODUCER,
543 if (name == NULL) { 477 EXTRACTOR_UNKNOWN, -1);
544 name = STRDUP(_("no name given")); 478 if (name == NULL)
545 } else { 479 {
546 char * dotdot; 480 name = STRDUP (_("no name given"));
547 481 }
548 while (NULL != (dotdot = strstr(name, ".."))) 482 else
549 dotdot[0] = dotdot[1] = '_'; 483 {
550 } 484 char *dotdot;
551 return validate_utf8(name); 485
486 while (NULL != (dotdot = strstr (name, "..")))
487 dotdot[0] = dotdot[1] = '_';
488 }
489 return validate_utf8 (name);
552} 490}
553 491
554char * getDescriptionFromMetaData(const struct ECRS_MetaData * meta) { 492char *
555 char * desc; 493getDescriptionFromMetaData (const struct ECRS_MetaData *meta)
556 494{
557 desc = ECRS_getFirstFromMetaData(meta, 495 char *desc;
558 EXTRACTOR_DESCRIPTION, 496
559 EXTRACTOR_GENRE, 497 desc = ECRS_getFirstFromMetaData (meta,
560 EXTRACTOR_ALBUM, 498 EXTRACTOR_DESCRIPTION,
561 EXTRACTOR_COMMENT, 499 EXTRACTOR_GENRE,
562 EXTRACTOR_SUBJECT, 500 EXTRACTOR_ALBUM,
563 EXTRACTOR_FORMAT, 501 EXTRACTOR_COMMENT,
564 EXTRACTOR_SIZE, 502 EXTRACTOR_SUBJECT,
565 EXTRACTOR_KEYWORDS, 503 EXTRACTOR_FORMAT,
566 -1); 504 EXTRACTOR_SIZE, EXTRACTOR_KEYWORDS, -1);
567 if (desc == NULL) 505 if (desc == NULL)
568 desc = STRDUP(""); 506 desc = STRDUP ("");
569 return validate_utf8(desc); 507 return validate_utf8 (desc);
570} 508}
571 509
572GdkPixbuf * getThumbnailFromMetaData(const struct ECRS_MetaData * meta) { 510GdkPixbuf *
573 GdkPixbuf * pixbuf; 511getThumbnailFromMetaData (const struct ECRS_MetaData * meta)
574 GdkPixbufLoader * loader; 512{
513 GdkPixbuf *pixbuf;
514 GdkPixbufLoader *loader;
575 size_t ts; 515 size_t ts;
576 unsigned char * thumb; 516 unsigned char *thumb;
577 517
578 thumb = NULL; 518 thumb = NULL;
579 ts = ECRS_getThumbnailFromMetaData(meta, 519 ts = ECRS_getThumbnailFromMetaData (meta, &thumb);
580 &thumb); 520 if (ts != 0)
581 if (ts != 0) { 521 {
582 loader = gdk_pixbuf_loader_new(); 522 loader = gdk_pixbuf_loader_new ();
583 gdk_pixbuf_loader_write(loader, 523 gdk_pixbuf_loader_write (loader, (const guchar *) thumb, ts, NULL);
584 (const guchar*) thumb, 524 pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
585 ts, 525 gdk_pixbuf_loader_close (loader, NULL);
586 NULL); 526 if (pixbuf != NULL)
587 pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); 527 g_object_ref (pixbuf);
588 gdk_pixbuf_loader_close(loader, 528 UNREF (loader);
589 NULL); 529 }
590 if (pixbuf != NULL) 530 else
591 g_object_ref(pixbuf); 531 {
592 UNREF(loader); 532 pixbuf = NULL;
593 } else { 533 }
594 pixbuf = NULL; 534 FREENONNULL (thumb);
595 }
596 FREENONNULL(thumb);
597 return pixbuf; 535 return pixbuf;
598} 536}
599 537
600GtkWidget * 538GtkWidget *
601extractMainWidgetFromWindow(GladeXML * xml, 539extractMainWidgetFromWindow (GladeXML * xml, const char *windowName)
602 const char * windowName) { 540{
603 GtkContainer * window; 541 GtkContainer *window;
604 GtkWidget * ret; 542 GtkWidget *ret;
605 543
606 window = GTK_CONTAINER(glade_xml_get_widget(xml, 544 window = GTK_CONTAINER (glade_xml_get_widget (xml, windowName));
607 windowName)); 545 ret = gtk_bin_get_child (GTK_BIN (window));
608 ret = gtk_bin_get_child(GTK_BIN(window)); 546 gtk_widget_ref (ret);
609 gtk_widget_ref(ret); 547 gtk_container_remove (window, ret);
610 gtk_container_remove(window, ret); 548 gtk_widget_destroy (GTK_WIDGET (window));
611 gtk_widget_destroy(GTK_WIDGET(window));
612 return ret; 549 return ret;
613} 550}
614 551
615int getToggleButtonValue(GladeXML * xml, 552int
616 const char * widgetName) { 553getToggleButtonValue (GladeXML * xml, const char *widgetName)
617 return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(xml, 554{
618 widgetName))); 555 return
556 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
557 (glade_xml_get_widget (xml, widgetName)));
619} 558}
620 559
621const char * getEntryLineValue(GladeXML * xml, 560const char *
622 const char * widgetName) { 561getEntryLineValue (GladeXML * xml, const char *widgetName)
623 GtkBin * line; 562{
624 GtkEntry * entry; 563 GtkBin *line;
564 GtkEntry *entry;
625 565
626 line = GTK_BIN(glade_xml_get_widget(xml, 566 line = GTK_BIN (glade_xml_get_widget (xml, widgetName));
627 widgetName)); 567 entry = GTK_ENTRY (gtk_bin_get_child (line));
628 entry = GTK_ENTRY(gtk_bin_get_child(line)); 568 return gtk_entry_get_text (entry);
629 return gtk_entry_get_text(entry);
630} 569}
631 570
632/* end of meta.c */ 571/* end of meta.c */
diff --git a/src/plugins/fs/meta.h b/src/plugins/fs/meta.h
index d9a0e01d..ead38bc6 100644
--- a/src/plugins/fs/meta.h
+++ b/src/plugins/fs/meta.h
@@ -30,67 +30,58 @@
30#include "gnunetgtk_common.h" 30#include "gnunetgtk_common.h"
31#include <GNUnet/gnunet_ecrs_lib.h> 31#include <GNUnet/gnunet_ecrs_lib.h>
32 32
33void createMetaDataListTreeView(GladeXML * xml, 33void createMetaDataListTreeView (GladeXML * xml,
34 const char * name, 34 const char *name,
35 const char * previewName, 35 const char *previewName,
36 const struct ECRS_MetaData * init); 36 const struct ECRS_MetaData *init);
37 37
38void createKeywordListTreeView(GladeXML * xml, 38void createKeywordListTreeView (GladeXML * xml,
39 const char * name, 39 const char *name,
40 const struct ECRS_URI * init); 40 const struct ECRS_URI *init);
41 41
42void createMetaTypeComboBox(GladeXML * xml, 42void createMetaTypeComboBox (GladeXML * xml, const char *name);
43 const char * name);
44 43
45void handleKeywordListUpdate(GladeXML * xml, 44void handleKeywordListUpdate (GladeXML * xml,
46 const char * inputLineName, 45 const char *inputLineName,
47 const char * keywordListName); 46 const char *keywordListName);
48 47
49void handleMetaDataListUpdate(GladeXML * xml, 48void handleMetaDataListUpdate (GladeXML * xml,
50 const char * typeInputLineName, 49 const char *typeInputLineName,
51 const char * valueInputLineName, 50 const char *valueInputLineName,
52 const char * metaDataListName); 51 const char *metaDataListName);
53 52
54void handleListRemove(GladeXML * xml, 53void handleListRemove (GladeXML * xml, const char *listName);
55 const char * listName);
56 54
57struct ECRS_MetaData * 55struct ECRS_MetaData *getMetaDataFromList (GladeXML * xml,
58getMetaDataFromList(GladeXML * xml, 56 const char *name,
59 const char * name, 57 const char *preview);
60 const char * preview);
61 58
62struct ECRS_URI * 59struct ECRS_URI *getKeywordURIFromList (GladeXML * xml, const char *name);
63getKeywordURIFromList(GladeXML * xml,
64 const char * name);
65 60
66char * updateIntervalToString(TIME_T interval); 61char *updateIntervalToString (TIME_T interval);
67 62
68int tryParseTimeInterval(GladeXML * xml, 63int tryParseTimeInterval (GladeXML * xml,
69 const char * intervalComboBoxEntry, 64 const char *intervalComboBoxEntry,
70 TIME_T * interval); 65 TIME_T * interval);
71 66
72int parseTimeInterval(const char * frequency, 67int parseTimeInterval (const char *frequency, TIME_T * interval);
73 TIME_T * interval);
74 68
75char * getMimeTypeFromMetaData(const struct ECRS_MetaData * meta); 69char *getMimeTypeFromMetaData (const struct ECRS_MetaData *meta);
76 70
77char * getFileNameFromMetaData(const struct ECRS_MetaData * meta); 71char *getFileNameFromMetaData (const struct ECRS_MetaData *meta);
78 72
79char * getDescriptionFromMetaData(const struct ECRS_MetaData * meta); 73char *getDescriptionFromMetaData (const struct ECRS_MetaData *meta);
80 74
81unsigned int getSpinButtonValue(GladeXML * xml, 75unsigned int getSpinButtonValue (GladeXML * xml, const char *spinButtonName);
82 const char * spinButtonName);
83 76
84int getToggleButtonValue(GladeXML * xml, 77int getToggleButtonValue (GladeXML * xml, const char *widgetName);
85 const char * widgetName);
86 78
87const char * getEntryLineValue(GladeXML * xml, 79const char *getEntryLineValue (GladeXML * xml, const char *widgetName);
88 const char * widgetName);
89 80
90GdkPixbuf * getThumbnailFromMetaData(const struct ECRS_MetaData * meta); 81GdkPixbuf *getThumbnailFromMetaData (const struct ECRS_MetaData *meta);
91 82
92GtkWidget * extractMainWidgetFromWindow(GladeXML * xml, 83GtkWidget *extractMainWidgetFromWindow (GladeXML * xml,
93 const char * windowName); 84 const char *windowName);
94 85
95 86
96/* end of meta.h */ 87/* end of meta.h */
diff --git a/src/plugins/fs/namespace.c b/src/plugins/fs/namespace.c
index b9145a9b..425efefe 100644
--- a/src/plugins/fs/namespace.c
+++ b/src/plugins/fs/namespace.c
@@ -40,259 +40,245 @@
40/** 40/**
41 * @brief linked list of pages in the namespace notebook 41 * @brief linked list of pages in the namespace notebook
42 */ 42 */
43typedef struct NL { 43typedef struct NL
44 struct NL * next; 44{
45 GtkWidget * treeview; 45 struct NL *next;
46 GtkWidget * namespacepage; 46 GtkWidget *treeview;
47 GtkWidget * addButton; 47 GtkWidget *namespacepage;
48 GtkWidget * updateButton; 48 GtkWidget *addButton;
49 GtkTreeModel * model; 49 GtkWidget *updateButton;
50 char * name; 50 GtkTreeModel *model;
51 char *name;
51 HashCode512 id; 52 HashCode512 id;
52 struct ECRS_MetaData * meta; 53 struct ECRS_MetaData *meta;
53} NamespaceList; 54} NamespaceList;
54 55
55/** 56/**
56 * Content selection in main list of available content. 57 * Content selection in main list of available content.
57 */ 58 */
58static GtkTreeSelection * content_selection; 59static GtkTreeSelection *content_selection;
59 60
60static NamespaceList * head; 61static NamespaceList *head;
61 62
62static GladeXML * metaXML; 63static GladeXML *metaXML;
63 64
64/** 65/**
65 * The user has changed the selection either in the 66 * The user has changed the selection either in the
66 * namespace content list or the global content list. 67 * namespace content list or the global content list.
67 * Update search button status values (add/change). 68 * Update search button status values (add/change).
68 */ 69 */
69static void on_namespaceContentSelectionChanged(gpointer signal, 70static void
70 gpointer cls) { 71on_namespaceContentSelectionChanged (gpointer signal, gpointer cls)
71 NamespaceList * list = head; 72{
73 NamespaceList *list = head;
72 int count; 74 int count;
73 int ncount; 75 int ncount;
74 GtkTreeSelection * ns; 76 GtkTreeSelection *ns;
75 GtkTreeIter iter; 77 GtkTreeIter iter;
76 char * freq; 78 char *freq;
77 int ok; 79 int ok;
78 80
79 count = gtk_tree_selection_count_selected_rows(content_selection); 81 count = gtk_tree_selection_count_selected_rows (content_selection);
80 while (list != NULL) { 82 while (list != NULL)
81 ns = gtk_tree_view_get_selection(GTK_TREE_VIEW(list->treeview)); 83 {
82 ncount = gtk_tree_selection_count_selected_rows(ns); 84 ns = gtk_tree_view_get_selection (GTK_TREE_VIEW (list->treeview));
83 gtk_widget_set_sensitive(list->addButton, 85 ncount = gtk_tree_selection_count_selected_rows (ns);
84 count > 0); 86 gtk_widget_set_sensitive (list->addButton, count > 0);
85 /* now check if update is legal */ 87 /* now check if update is legal */
86 ok = 0; 88 ok = 0;
87 if ( (count == 1) && 89 if ((count == 1) &&
88 (ncount == 1) && 90 (ncount == 1) &&
89 (TRUE == gtk_tree_selection_get_selected(ns, 91 (TRUE == gtk_tree_selection_get_selected (ns, NULL, &iter)))
90 NULL, 92 {
91 &iter)) ) { 93 freq = NULL;
92 freq = NULL; 94 gtk_tree_model_get (list->model,
93 gtk_tree_model_get(list->model, 95 &iter, IN_NAMESPACE_PUB_DATE_STRING, &freq, -1);
94 &iter, 96 if ((freq != NULL) && (0 != strcmp (freq, _("never"))))
95 IN_NAMESPACE_PUB_DATE_STRING, &freq, 97 ok = 1;
96 -1); 98 FREENONNULL (freq);
97 if ( (freq != NULL) && 99 }
98 (0 != strcmp(freq, _("never"))) ) 100 gtk_widget_set_sensitive (list->updateButton, ok);
99 ok = 1; 101 list = list->next;
100 FREENONNULL(freq);
101 } 102 }
102 gtk_widget_set_sensitive(list->updateButton,
103 ok);
104 list = list->next;
105 }
106} 103}
107 104
108 105
109static void makeNamespaceFrame(NamespaceList * entry) { 106static void
110 GtkWidget * child; 107makeNamespaceFrame (NamespaceList * entry)
111 GtkWidget * resultList; 108{
112 GtkCellRenderer * renderer; 109 GtkWidget *child;
113 GtkListStore * model; 110 GtkWidget *resultList;
114 GladeXML * namespaceXML; 111 GtkCellRenderer *renderer;
115 GtkTreeViewColumn * column; 112 GtkListStore *model;
113 GladeXML *namespaceXML;
114 GtkTreeViewColumn *column;
116 int col; 115 int col;
117 116
118 DEBUG_BEGIN(); 117 DEBUG_BEGIN ();
119 namespaceXML 118 namespaceXML
120 = glade_xml_new(getGladeFileName(), 119 = glade_xml_new (getGladeFileName (),
121 "namespaceContentFrame", 120 "namespaceContentFrame", PACKAGE_NAME);
122 PACKAGE_NAME); 121 connectGladeWithPlugins (namespaceXML);
123 connectGladeWithPlugins(namespaceXML); 122 child = extractMainWidgetFromWindow (namespaceXML, "namespaceContentFrame");
124 child = extractMainWidgetFromWindow(namespaceXML, 123 resultList = glade_xml_get_widget (namespaceXML,
125 "namespaceContentFrame"); 124 "namespaceContentFrameTreeView");
126 resultList = glade_xml_get_widget(namespaceXML, 125 entry->addButton = glade_xml_get_widget (namespaceXML, "addButton");
127 "namespaceContentFrameTreeView"); 126 entry->updateButton = glade_xml_get_widget (namespaceXML,
128 entry->addButton = glade_xml_get_widget(namespaceXML, 127 "namespaceUpdateButton");
129 "addButton"); 128 entry->treeview = GTK_WIDGET (GTK_TREE_VIEW (resultList));
130 entry->updateButton = glade_xml_get_widget(namespaceXML, 129 model = gtk_list_store_new (IN_NAMESPACE_NUM, G_TYPE_STRING, /* (file)name */
131 "namespaceUpdateButton"); 130 G_TYPE_UINT64, /* size */
132 entry->treeview = GTK_WIDGET(GTK_TREE_VIEW(resultList)); 131 G_TYPE_STRING, /* human-readable size */
133 model = 132 G_TYPE_STRING, /* description */
134 gtk_list_store_new(IN_NAMESPACE_NUM, 133 G_TYPE_STRING, /* mime-type */
135 G_TYPE_STRING, /* (file)name */ 134 G_TYPE_STRING, /* last-ID */
136 G_TYPE_UINT64, /* size */ 135 G_TYPE_STRING, /* next-ID */
137 G_TYPE_STRING, /* human-readable size */ 136 G_TYPE_STRING, /* pub-freq */
138 G_TYPE_STRING, /* description */ 137 G_TYPE_STRING, /* next pub date */
139 G_TYPE_STRING, /* mime-type */ 138 G_TYPE_POINTER, /* URI */
140 G_TYPE_STRING, /* last-ID */ 139 G_TYPE_POINTER); /* META */
141 G_TYPE_STRING, /* next-ID */ 140 entry->model = GTK_TREE_MODEL (model);
142 G_TYPE_STRING, /* pub-freq */ 141 gtk_tree_view_set_model (GTK_TREE_VIEW (resultList),
143 G_TYPE_STRING, /* next pub date */ 142 GTK_TREE_MODEL (model));
144 G_TYPE_POINTER, /* URI */ 143 gtk_tree_selection_set_mode (gtk_tree_view_get_selection
145 G_TYPE_POINTER); /* META */ 144 (GTK_TREE_VIEW (resultList)),
146 entry->model = GTK_TREE_MODEL(model); 145 GTK_SELECTION_SINGLE);
147 gtk_tree_view_set_model(GTK_TREE_VIEW(resultList), 146 g_signal_connect_data (gtk_tree_view_get_selection
148 GTK_TREE_MODEL(model)); 147 (GTK_TREE_VIEW (resultList)), "changed",
149 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(resultList)), 148 G_CALLBACK (&on_namespaceContentSelectionChanged),
150 GTK_SELECTION_SINGLE); 149 NULL, NULL, 0);
151 g_signal_connect_data(gtk_tree_view_get_selection(GTK_TREE_VIEW(resultList)), 150
152 "changed", 151
153 G_CALLBACK(&on_namespaceContentSelectionChanged), 152
154 NULL, 153 renderer = gtk_cell_renderer_text_new ();
155 NULL, 154 col =
156 0); 155 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (resultList),
157 156 -1, _("Filename"), renderer,
158 157 "text",
159 158 IN_NAMESPACE_FILENAME, NULL);
160 renderer = gtk_cell_renderer_text_new(); 159 column = gtk_tree_view_get_column (GTK_TREE_VIEW (resultList), col - 1);
161 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 160 gtk_tree_view_column_set_resizable (column, TRUE);
162 -1, 161 gtk_tree_view_column_set_clickable (column, TRUE);
163 _("Filename"), 162 gtk_tree_view_column_set_reorderable (column, TRUE);
164 renderer, 163 gtk_tree_view_column_set_sort_column_id (column, IN_NAMESPACE_FILENAME);
165 "text", IN_NAMESPACE_FILENAME, 164 /*gtk_tree_view_column_set_sort_indicator(column, TRUE); */
166 NULL); 165
167 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 166 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
168 col - 1); 167 (GTK_TREE_VIEW (resultList), col - 1),
169 gtk_tree_view_column_set_resizable(column, TRUE); 168 TRUE);
170 gtk_tree_view_column_set_clickable(column, TRUE); 169 renderer = gtk_cell_renderer_text_new ();
171 gtk_tree_view_column_set_reorderable(column, TRUE);
172 gtk_tree_view_column_set_sort_column_id(column, IN_NAMESPACE_FILENAME);
173 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/
174
175 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList),
176 col - 1),
177 TRUE);
178 renderer = gtk_cell_renderer_text_new();
179 g_object_set (renderer, "xalign", 1.00, NULL); 170 g_object_set (renderer, "xalign", 1.00, NULL);
180 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 171 col =
181 -1, 172 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (resultList),
182 _("Filesize"), 173 -1, _("Filesize"), renderer,
183 renderer, 174 "text", IN_NAMESPACE_HSIZE,
184 "text", IN_NAMESPACE_HSIZE, 175 NULL);
185 NULL); 176 column = gtk_tree_view_get_column (GTK_TREE_VIEW (resultList), col - 1);
186 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 177 gtk_tree_view_column_set_resizable (column, TRUE);
187 col - 1); 178 gtk_tree_view_column_set_clickable (column, TRUE);
188 gtk_tree_view_column_set_resizable(column, TRUE); 179 gtk_tree_view_column_set_reorderable (column, TRUE);
189 gtk_tree_view_column_set_clickable(column, TRUE); 180 gtk_tree_view_column_set_sort_column_id (column, IN_NAMESPACE_SIZE);
190 gtk_tree_view_column_set_reorderable(column, TRUE); 181 /*gtk_tree_view_column_set_sort_indicator(column, TRUE); */
191 gtk_tree_view_column_set_sort_column_id(column, IN_NAMESPACE_SIZE); 182 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
192 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 183 (GTK_TREE_VIEW (resultList), col - 1),
193 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 184 TRUE);
194 col - 1), 185 renderer = gtk_cell_renderer_text_new ();
195 TRUE); 186 col =
196 renderer = gtk_cell_renderer_text_new(); 187 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (resultList),
197 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 188 -1, _("Description"),
198 -1, 189 renderer, "text",
199 _("Description"), 190 IN_NAMESPACE_DESCRIPTION,
200 renderer, 191 NULL);
201 "text", IN_NAMESPACE_DESCRIPTION, 192 column = gtk_tree_view_get_column (GTK_TREE_VIEW (resultList), col - 1);
202 NULL); 193 gtk_tree_view_column_set_resizable (column, TRUE);
203 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 194 gtk_tree_view_column_set_clickable (column, TRUE);
204 col - 1); 195 gtk_tree_view_column_set_reorderable (column, TRUE);
205 gtk_tree_view_column_set_resizable(column, TRUE); 196 gtk_tree_view_column_set_sort_column_id (column, IN_NAMESPACE_DESCRIPTION);
206 gtk_tree_view_column_set_clickable(column, TRUE); 197 /*gtk_tree_view_column_set_sort_indicator(column, TRUE); */
207 gtk_tree_view_column_set_reorderable(column, TRUE); 198 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
208 gtk_tree_view_column_set_sort_column_id(column, IN_NAMESPACE_DESCRIPTION); 199 (GTK_TREE_VIEW (resultList), col - 1),
209 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 200 TRUE);
210 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 201 renderer = gtk_cell_renderer_text_new ();
211 col - 1), 202 col =
212 TRUE); 203 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (resultList),
213 renderer = gtk_cell_renderer_text_new(); 204 -1, _("Mime-type"), renderer,
214 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 205 "text",
215 -1, 206 IN_NAMESPACE_MIMETYPE, NULL);
216 _("Mime-type"), 207 column = gtk_tree_view_get_column (GTK_TREE_VIEW (resultList), col - 1);
217 renderer, 208 gtk_tree_view_column_set_resizable (column, TRUE);
218 "text", IN_NAMESPACE_MIMETYPE, 209 gtk_tree_view_column_set_clickable (column, TRUE);
219 NULL); 210 gtk_tree_view_column_set_reorderable (column, TRUE);
220 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 211 gtk_tree_view_column_set_sort_column_id (column, IN_NAMESPACE_MIMETYPE);
221 col - 1); 212 /*gtk_tree_view_column_set_sort_indicator(column, TRUE); */
222 gtk_tree_view_column_set_resizable(column, TRUE); 213 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
223 gtk_tree_view_column_set_clickable(column, TRUE); 214 (GTK_TREE_VIEW (resultList), col - 1),
224 gtk_tree_view_column_set_reorderable(column, TRUE); 215 TRUE);
225 gtk_tree_view_column_set_sort_column_id(column, IN_NAMESPACE_MIMETYPE); 216 renderer = gtk_cell_renderer_text_new ();
226 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 217 col =
227 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 218 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (resultList),
228 col - 1), 219 -1,
229 TRUE); 220 _("Publication Frequency"),
230 renderer = gtk_cell_renderer_text_new(); 221 renderer, "text",
231 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 222 IN_NAMESPACE_PUB_FREQ_STRING,
232 -1, 223 NULL);
233 _("Publication Frequency"), 224 column = gtk_tree_view_get_column (GTK_TREE_VIEW (resultList), col - 1);
234 renderer, 225 gtk_tree_view_column_set_resizable (column, TRUE);
235 "text", IN_NAMESPACE_PUB_FREQ_STRING, 226 gtk_tree_view_column_set_clickable (column, TRUE);
236 NULL); 227 gtk_tree_view_column_set_reorderable (column, TRUE);
237 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 228 gtk_tree_view_column_set_sort_column_id (column,
238 col - 1); 229 IN_NAMESPACE_PUB_FREQ_STRING);
239 gtk_tree_view_column_set_resizable(column, TRUE); 230 /*gtk_tree_view_column_set_sort_indicator(column, TRUE); */
240 gtk_tree_view_column_set_clickable(column, TRUE); 231 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
241 gtk_tree_view_column_set_reorderable(column, TRUE); 232 (GTK_TREE_VIEW (resultList), col - 1),
242 gtk_tree_view_column_set_sort_column_id(column, IN_NAMESPACE_PUB_FREQ_STRING); 233 TRUE);
243 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 234 renderer = gtk_cell_renderer_text_new ();
244 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 235 col =
245 col - 1), 236 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (resultList),
246 TRUE); 237 -1,
247 renderer = gtk_cell_renderer_text_new(); 238 _("Next Publication Date"),
248 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 239 renderer, "text",
249 -1, 240 IN_NAMESPACE_PUB_DATE_STRING,
250 _("Next Publication Date"), 241 NULL);
251 renderer, 242 column = gtk_tree_view_get_column (GTK_TREE_VIEW (resultList), col - 1);
252 "text", IN_NAMESPACE_PUB_DATE_STRING, 243 gtk_tree_view_column_set_reorderable (column, TRUE);
253 NULL); 244 gtk_tree_view_column_set_resizable (column, TRUE);
254 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 245 gtk_tree_view_column_set_clickable (column, TRUE);
255 col - 1); 246 gtk_tree_view_column_set_sort_column_id (column,
256 gtk_tree_view_column_set_reorderable(column, TRUE); 247 IN_NAMESPACE_PUB_DATE_STRING);
257 gtk_tree_view_column_set_resizable(column, TRUE); 248 /*gtk_tree_view_column_set_sort_indicator(column, TRUE); */
258 gtk_tree_view_column_set_clickable(column, TRUE); 249 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
259 gtk_tree_view_column_set_sort_column_id(column, IN_NAMESPACE_PUB_DATE_STRING); 250 (GTK_TREE_VIEW (resultList), col - 1),
260 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 251 TRUE);
261 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 252 renderer = gtk_cell_renderer_text_new ();
262 col - 1), 253 col =
263 TRUE); 254 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (resultList),
264 renderer = gtk_cell_renderer_text_new(); 255 -1, _("Last ID"), renderer,
265 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 256 "text",
266 -1, 257 IN_NAMESPACE_LAST_STRING,
267 _("Last ID"), 258 NULL);
268 renderer, 259 column = gtk_tree_view_get_column (GTK_TREE_VIEW (resultList), col - 1);
269 "text", IN_NAMESPACE_LAST_STRING, 260 gtk_tree_view_column_set_reorderable (column, TRUE);
270 NULL); 261 gtk_tree_view_column_set_resizable (column, TRUE);
271 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 262 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
272 col - 1); 263 (GTK_TREE_VIEW (resultList), col - 1),
273 gtk_tree_view_column_set_reorderable(column, TRUE); 264 TRUE);
274 gtk_tree_view_column_set_resizable(column, TRUE); 265 renderer = gtk_cell_renderer_text_new ();
275 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 266 col =
276 col - 1), 267 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (resultList),
277 TRUE); 268 -1, _("Next ID"), renderer,
278 renderer = gtk_cell_renderer_text_new(); 269 "text",
279 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(resultList), 270 IN_NAMESPACE_NEXT_STRING,
280 -1, 271 NULL);
281 _("Next ID"), 272 column = gtk_tree_view_get_column (GTK_TREE_VIEW (resultList), col - 1);
282 renderer, 273 gtk_tree_view_column_set_reorderable (column, TRUE);
283 "text", IN_NAMESPACE_NEXT_STRING, 274 gtk_tree_view_column_set_resizable (column, TRUE);
284 NULL); 275 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
285 column = gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 276 (GTK_TREE_VIEW (resultList), col - 1),
286 col - 1); 277 TRUE);
287 gtk_tree_view_column_set_reorderable(column, TRUE); 278
288 gtk_tree_view_column_set_resizable(column, TRUE); 279
289 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(resultList), 280 UNREF (namespaceXML);
290 col - 1), 281 DEBUG_END ();
291 TRUE);
292
293
294 UNREF(namespaceXML);
295 DEBUG_END();
296 282
297 entry->namespacepage = child; 283 entry->namespacepage = child;
298} 284}
@@ -311,263 +297,245 @@ static void makeNamespaceFrame(NamespaceList * entry) {
311 * next update (0 for sporadic updates) 297 * next update (0 for sporadic updates)
312 * @return OK to continue iteration, SYSERR to abort 298 * @return OK to continue iteration, SYSERR to abort
313 */ 299 */
314static int addNamespaceContentToModel(void * cls, 300static int
315 const ECRS_FileInfo * fi, 301addNamespaceContentToModel (void *cls,
316 const HashCode512 * lastId, 302 const ECRS_FileInfo * fi,
317 const HashCode512 * nextId, 303 const HashCode512 * lastId,
318 TIME_T publicationFrequency, 304 const HashCode512 * nextId,
319 TIME_T nextPublicationTime) { 305 TIME_T publicationFrequency,
320 GtkListStore * model = GTK_LIST_STORE(cls); 306 TIME_T nextPublicationTime)
307{
308 GtkListStore *model = GTK_LIST_STORE (cls);
321 GtkTreeIter iter; 309 GtkTreeIter iter;
322 char * filename; 310 char *filename;
323 char * desc; 311 char *desc;
324 char * mime; 312 char *mime;
325 char * uriString; 313 char *uriString;
326 EncName last; 314 EncName last;
327 EncName next; 315 EncName next;
328 char * freq; 316 char *freq;
329 char * date; 317 char *date;
330 unsigned long long size; 318 unsigned long long size;
331 char * size_h; 319 char *size_h;
332 320
333 DEBUG_BEGIN(); 321 DEBUG_BEGIN ();
334 filename = ECRS_getFirstFromMetaData(fi->meta, 322 filename = ECRS_getFirstFromMetaData (fi->meta,
335 EXTRACTOR_FILENAME, 323 EXTRACTOR_FILENAME,
336 EXTRACTOR_TITLE, 324 EXTRACTOR_TITLE,
337 EXTRACTOR_ARTIST, 325 EXTRACTOR_ARTIST,
338 EXTRACTOR_AUTHOR, 326 EXTRACTOR_AUTHOR,
339 EXTRACTOR_PUBLISHER, 327 EXTRACTOR_PUBLISHER,
340 EXTRACTOR_CREATOR, 328 EXTRACTOR_CREATOR,
341 EXTRACTOR_PRODUCER, 329 EXTRACTOR_PRODUCER,
342 EXTRACTOR_UNKNOWN, 330 EXTRACTOR_UNKNOWN, -1);
343 -1);
344 if (filename == NULL) 331 if (filename == NULL)
345 filename = STRDUP(_("no name given")); 332 filename = STRDUP (_("no name given"));
346 else { 333 else
347 char *dotdot; 334 {
348 335 char *dotdot;
349 while (NULL != (dotdot = strstr(filename, ".."))) 336
350 dotdot[0] = dotdot[1] = '_'; 337 while (NULL != (dotdot = strstr (filename, "..")))
351 } 338 dotdot[0] = dotdot[1] = '_';
352 desc = ECRS_getFirstFromMetaData(fi->meta, 339 }
353 EXTRACTOR_DESCRIPTION, 340 desc = ECRS_getFirstFromMetaData (fi->meta,
354 EXTRACTOR_GENRE, 341 EXTRACTOR_DESCRIPTION,
355 EXTRACTOR_ALBUM, 342 EXTRACTOR_GENRE,
356 EXTRACTOR_COMMENT, 343 EXTRACTOR_ALBUM,
357 EXTRACTOR_SUBJECT, 344 EXTRACTOR_COMMENT,
358 EXTRACTOR_FORMAT, 345 EXTRACTOR_SUBJECT,
359 EXTRACTOR_SIZE, 346 EXTRACTOR_FORMAT,
360 EXTRACTOR_KEYWORDS, 347 EXTRACTOR_SIZE, EXTRACTOR_KEYWORDS, -1);
361 -1);
362 if (desc == NULL) 348 if (desc == NULL)
363 desc = STRDUP(""); 349 desc = STRDUP ("");
364 mime = ECRS_getFromMetaData(fi->meta, 350 mime = ECRS_getFromMetaData (fi->meta, EXTRACTOR_MIMETYPE);
365 EXTRACTOR_MIMETYPE);
366 if (mime == NULL) 351 if (mime == NULL)
367 mime = STRDUP(_("unknown")); 352 mime = STRDUP (_("unknown"));
368 if (ECRS_isFileUri(fi->uri)) 353 if (ECRS_isFileUri (fi->uri))
369 size = ECRS_fileSize(fi->uri); 354 size = ECRS_fileSize (fi->uri);
370 else 355 else
371 size = 0; 356 size = 0;
372 uriString = ECRS_uriToString(fi->uri); 357 uriString = ECRS_uriToString (fi->uri);
373 hash2enc(lastId, &last); 358 hash2enc (lastId, &last);
374 if (nextId != NULL) 359 if (nextId != NULL)
375 hash2enc(nextId, &next); 360 hash2enc (nextId, &next);
376 else 361 else
377 memset(&next, 0, sizeof(EncName)); 362 memset (&next, 0, sizeof (EncName));
378 if (publicationFrequency == ECRS_SBLOCK_UPDATE_SPORADIC) 363 if (publicationFrequency == ECRS_SBLOCK_UPDATE_SPORADIC)
379 date = STRDUP(_("unspecified")); 364 date = STRDUP (_("unspecified"));
380 else if (publicationFrequency == ECRS_SBLOCK_UPDATE_NONE) 365 else if (publicationFrequency == ECRS_SBLOCK_UPDATE_NONE)
381 date = STRDUP(_("never")); 366 date = STRDUP (_("never"));
382 else 367 else
383 date = GN_CTIME(&nextPublicationTime); 368 date = GN_CTIME (&nextPublicationTime);
384 if (date[strlen(date)-1] == '\n') 369 if (date[strlen (date) - 1] == '\n')
385 date[strlen(date)-1] = '\0'; 370 date[strlen (date) - 1] = '\0';
386 371
387 freq = updateIntervalToString(publicationFrequency); 372 freq = updateIntervalToString (publicationFrequency);
388 size_h = string_get_fancy_byte_size(size); 373 size_h = string_get_fancy_byte_size (size);
389 gtk_list_store_append(model, 374 gtk_list_store_append (model, &iter);
390 &iter); 375 gtk_list_store_set (model,
391 gtk_list_store_set(model, 376 &iter,
392 &iter, 377 IN_NAMESPACE_FILENAME, filename,
393 IN_NAMESPACE_FILENAME, filename, 378 IN_NAMESPACE_SIZE, size,
394 IN_NAMESPACE_SIZE, size, 379 IN_NAMESPACE_HSIZE, size_h,
395 IN_NAMESPACE_HSIZE, size_h, 380 IN_NAMESPACE_DESCRIPTION, desc,
396 IN_NAMESPACE_DESCRIPTION, desc, 381 IN_NAMESPACE_MIMETYPE, mime,
397 IN_NAMESPACE_MIMETYPE, mime, 382 IN_NAMESPACE_LAST_STRING, &last,
398 IN_NAMESPACE_LAST_STRING, &last, 383 IN_NAMESPACE_NEXT_STRING, &next,
399 IN_NAMESPACE_NEXT_STRING, &next, 384 IN_NAMESPACE_PUB_FREQ_STRING, freq,
400 IN_NAMESPACE_PUB_FREQ_STRING, freq, 385 IN_NAMESPACE_PUB_DATE_STRING, date,
401 IN_NAMESPACE_PUB_DATE_STRING, date, 386 IN_NAMESPACE_URI, ECRS_dupUri (fi->uri),
402 IN_NAMESPACE_URI, ECRS_dupUri(fi->uri), 387 IN_NAMESPACE_META, ECRS_dupMetaData (fi->meta), -1);
403 IN_NAMESPACE_META, ECRS_dupMetaData(fi->meta), 388 FREE (size_h);
404 -1); 389 FREE (filename);
405 FREE(size_h); 390 FREE (uriString);
406 FREE(filename); 391 FREE (freq);
407 FREE(uriString); 392 FREE (date);
408 FREE(freq); 393 FREE (mime);
409 FREE(date); 394 DEBUG_END ();
410 FREE(mime);
411 DEBUG_END();
412 return OK; 395 return OK;
413} 396}
414 397
415/** 398/**
416 * Add a tab for the given namespace. 399 * Add a tab for the given namespace.
417 */ 400 */
418int addTabForNamespace(void * unused, 401int
419 const char * namespaceName, 402addTabForNamespace (void *unused,
420 const HashCode512 * namespaceId, 403 const char *namespaceName,
421 const struct ECRS_MetaData * md, 404 const HashCode512 * namespaceId,
422 int rating) { 405 const struct ECRS_MetaData *md, int rating)
423 NamespaceList * list; 406{
424 GtkWidget * label; 407 NamespaceList *list;
425 GtkWidget * notebook; 408 GtkWidget *label;
426 GtkWidget * del_menu; 409 GtkWidget *notebook;
427 410 GtkWidget *del_menu;
428 if (OK != ECRS_testNamespaceExists(NULL, 411
429 cfg, 412 if (OK != ECRS_testNamespaceExists (NULL, cfg, namespaceName, namespaceId))
430 namespaceName,
431 namespaceId))
432 return OK; 413 return OK;
433 DEBUG_BEGIN(); 414 DEBUG_BEGIN ();
434 label = gtk_label_new(namespaceName); 415 label = gtk_label_new (namespaceName);
435 list = MALLOC(sizeof(NamespaceList)); 416 list = MALLOC (sizeof (NamespaceList));
436 list->name = STRDUP(namespaceName); 417 list->name = STRDUP (namespaceName);
437 list->id = *namespaceId; 418 list->id = *namespaceId;
438 list->meta = ECRS_dupMetaData(md); 419 list->meta = ECRS_dupMetaData (md);
439 makeNamespaceFrame(list); 420 makeNamespaceFrame (list);
440 list->next 421 list->next = head;
441 = head;
442 head = list; 422 head = list;
443 /* update sensitivity of add button */ 423 /* update sensitivity of add button */
444 on_namespaceContentSelectionChanged(NULL, NULL); 424 on_namespaceContentSelectionChanged (NULL, NULL);
445 notebook 425 notebook = glade_xml_get_widget (getMainXML (), "localNamespacesNotebook");
446 = glade_xml_get_widget(getMainXML(), 426 gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
447 "localNamespacesNotebook"); 427 list->namespacepage, label);
448 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), 428 gtk_widget_show (notebook);
449 list->namespacepage,
450 label);
451 gtk_widget_show(notebook);
452 NS_listNamespaceContent 429 NS_listNamespaceContent
453 (ectx, 430 (ectx, cfg, namespaceName, &addNamespaceContentToModel, list->model);
454 cfg, 431 DEBUG_END ();
455 namespaceName,
456 &addNamespaceContentToModel,
457 list->model);
458 DEBUG_END();
459 /* enable "delete" menu entry */ 432 /* enable "delete" menu entry */
460 433
461 del_menu = glade_xml_get_widget(getMainXML(), 434 del_menu = glade_xml_get_widget (getMainXML (), "namespaceDelete");
462 "namespaceDelete"); 435 gtk_widget_set_sensitive (del_menu, TRUE);
463 gtk_widget_set_sensitive(del_menu,
464 TRUE);
465 return OK; 436 return OK;
466} 437}
467 438
468 439
469static void frame_destroy(GtkWidget * tree) { 440static void
441frame_destroy (GtkWidget * tree)
442{
470 GtkTreeIter iter; 443 GtkTreeIter iter;
471 struct ECRS_URI * u; 444 struct ECRS_URI *u;
472 struct ECRS_MetaData * m; 445 struct ECRS_MetaData *m;
473 NamespaceList * prev; 446 NamespaceList *prev;
474 NamespaceList * pos; 447 NamespaceList *pos;
475 NamespaceList * next; 448 NamespaceList *next;
476 GtkWidget * del_menu; 449 GtkWidget *del_menu;
477 450
478 pos = head; 451 pos = head;
479 prev = NULL; 452 prev = NULL;
480 while (pos != NULL) { 453 while (pos != NULL)
481 next = pos->next; 454 {
482 if (pos->treeview == tree) 455 next = pos->next;
483 break; 456 if (pos->treeview == tree)
484 prev = pos; 457 break;
485 pos = next; 458 prev = pos;
486 } 459 pos = next;
487 if (pos == NULL) { 460 }
488 GE_BREAK(NULL, 0); 461 if (pos == NULL)
489 return; 462 {
490 } 463 GE_BREAK (NULL, 0);
464 return;
465 }
491 if (prev == NULL) 466 if (prev == NULL)
492 head = pos->next; 467 head = pos->next;
493 else 468 else
494 prev->next = pos->next; 469 prev->next = pos->next;
495 FREE(pos->name); 470 FREE (pos->name);
496 ECRS_freeMetaData(pos->meta); 471 ECRS_freeMetaData (pos->meta);
497 if (gtk_tree_model_get_iter_first(pos->model, 472 if (gtk_tree_model_get_iter_first (pos->model, &iter))
498 &iter)) { 473 {
499 do { 474 do
500 gtk_tree_model_get(pos->model, 475 {
501 &iter, 476 gtk_tree_model_get (pos->model,
502 IN_NAMESPACE_URI, &u, 477 &iter,
503 IN_NAMESPACE_META, &m, 478 IN_NAMESPACE_URI, &u,
504 -1); 479 IN_NAMESPACE_META, &m, -1);
505 gtk_list_store_set(GTK_LIST_STORE(pos->model), 480 gtk_list_store_set (GTK_LIST_STORE (pos->model),
506 &iter, 481 &iter,
507 IN_NAMESPACE_URI, NULL, 482 IN_NAMESPACE_URI, NULL,
508 IN_NAMESPACE_META, NULL, 483 IN_NAMESPACE_META, NULL, -1);
509 -1); 484 if (u != NULL)
510 if (u != NULL) 485 ECRS_freeUri (u);
511 ECRS_freeUri(u); 486 if (m != NULL)
512 if (m != NULL) 487 ECRS_freeMetaData (m);
513 ECRS_freeMetaData(m); 488 }
514 } while (gtk_tree_model_iter_next(pos->model, 489 while (gtk_tree_model_iter_next (pos->model, &iter));
515 &iter)); 490 }
516 } 491 FREE (pos);
517 FREE(pos); 492 del_menu = glade_xml_get_widget (getMainXML (), "namespaceDelete");
518 del_menu = glade_xml_get_widget(getMainXML(), 493 gtk_widget_set_sensitive (del_menu, head != NULL);
519 "namespaceDelete");
520 gtk_widget_set_sensitive(del_menu,
521 head != NULL);
522} 494}
523 495
524 496
525 497
526void namespaceDelete_clicked_fs(GtkWidget * dummy1, 498void
527 GtkWidget * dummy2) { 499namespaceDelete_clicked_fs (GtkWidget * dummy1, GtkWidget * dummy2)
528 GtkWidget * notebook; 500{
529 NamespaceList * list; 501 GtkWidget *notebook;
530 NamespaceList * prev; 502 NamespaceList *list;
503 NamespaceList *prev;
531 gint num; 504 gint num;
532 GtkWidget * page; 505 GtkWidget *page;
533 GtkWidget * dialog; 506 GtkWidget *dialog;
534 gint ret; 507 gint ret;
535 508
536 DEBUG_BEGIN(); 509 DEBUG_BEGIN ();
537 notebook 510 notebook = glade_xml_get_widget (getMainXML (), "localNamespacesNotebook");
538 = glade_xml_get_widget(getMainXML(), 511 num = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
539 "localNamespacesNotebook"); 512 if (num == -1)
540 num 513 {
541 = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); 514 /* IMPROVE-ME: disable the menu item
542 if (num == -1) { 515 as long as this may happen! */
543 /* IMPROVE-ME: disable the menu item 516 dialog = gtk_message_dialog_new
544 as long as this may happen! */ 517 (NULL,
545 dialog = gtk_message_dialog_new 518 GTK_DIALOG_MODAL,
546 (NULL, 519 GTK_MESSAGE_ERROR,
547 GTK_DIALOG_MODAL, 520 GTK_BUTTONS_CLOSE,
548 GTK_MESSAGE_ERROR, 521 _("No local namespaces available that could be deleted!"));
549 GTK_BUTTONS_CLOSE, 522 gtk_dialog_run (GTK_DIALOG (dialog));
550 _("No local namespaces available that could be deleted!")); 523 gtk_widget_destroy (dialog);
551 gtk_dialog_run(GTK_DIALOG(dialog)); 524 return;
552 gtk_widget_destroy(dialog); 525 }
553 return; 526 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), num);
554 } 527 list = head;
555 page 528 prev = NULL;
556 = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), 529 while ((list != NULL) && (list->namespacepage != page))
557 num); 530 {
558 list 531 prev = list;
559 = head; 532 list = list->next;
560 prev 533 }
561 = NULL; 534 if (list == NULL)
562 while ( (list != NULL) && 535 {
563 (list->namespacepage != page) ) { 536 GE_BREAK (ectx, 0);
564 prev = list; 537 return;
565 list = list->next; 538 }
566 }
567 if (list == NULL) {
568 GE_BREAK(ectx, 0);
569 return;
570 }
571 /* open window to ask for confirmation, 539 /* open window to ask for confirmation,
572 only then delete */ 540 only then delete */
573 541
@@ -576,102 +544,98 @@ void namespaceDelete_clicked_fs(GtkWidget * dummy1,
576 GTK_DIALOG_MODAL, 544 GTK_DIALOG_MODAL,
577 GTK_MESSAGE_ERROR, 545 GTK_MESSAGE_ERROR,
578 GTK_BUTTONS_YES_NO, 546 GTK_BUTTONS_YES_NO,
579 _("Should the namespace `%s' really be deleted?"), 547 _("Should the namespace `%s' really be deleted?"), list->name);
580 list->name); 548 ret = gtk_dialog_run (GTK_DIALOG (dialog));
581 ret = gtk_dialog_run(GTK_DIALOG(dialog)); 549 gtk_widget_destroy (dialog);
582 gtk_widget_destroy(dialog);
583 if (GTK_RESPONSE_YES != ret) 550 if (GTK_RESPONSE_YES != ret)
584 return; 551 return;
585 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), 552 gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), num);
586 num); 553 NS_deleteNamespace (ectx, cfg, list->name);
587 NS_deleteNamespace(ectx, 554 frame_destroy (list->treeview);
588 cfg, 555 DEBUG_END ();
589 list->name);
590 frame_destroy(list->treeview);
591 DEBUG_END();
592} 556}
593 557
594typedef struct { 558typedef struct
559{
595 unsigned int anonymityLevel; 560 unsigned int anonymityLevel;
596 char * namespaceName; 561 char *namespaceName;
597 TIME_T updateInterval; 562 TIME_T updateInterval;
598 HashCode512 * lastId; 563 HashCode512 *lastId;
599 HashCode512 thisId; 564 HashCode512 thisId;
600 HashCode512 * nextId; 565 HashCode512 *nextId;
601} IUC; 566} IUC;
602 567
603/** 568/**
604 * Publish the selected file in the 569 * Publish the selected file in the
605 * selected namespace. 570 * selected namespace.
606 */ 571 */
607static void addToNamespaceCB(GtkTreeModel * model, 572static void
608 GtkTreePath * path, 573addToNamespaceCB (GtkTreeModel * model,
609 GtkTreeIter * iter, 574 GtkTreePath * path, GtkTreeIter * iter, gpointer data)
610 gpointer data) { 575{
611 IUC * cls = data; 576 IUC *cls = data;
612 struct ECRS_URI * resultURI; 577 struct ECRS_URI *resultURI;
613 struct ECRS_URI * dst; 578 struct ECRS_URI *dst;
614 struct ECRS_MetaData * meta; 579 struct ECRS_MetaData *meta;
615 NamespaceList * list; 580 NamespaceList *list;
616 ECRS_FileInfo fi; 581 ECRS_FileInfo fi;
617 582
618 DEBUG_BEGIN(); 583 DEBUG_BEGIN ();
619 dst = NULL; 584 dst = NULL;
620 gtk_tree_model_get(model, 585 gtk_tree_model_get (model,
621 iter, 586 iter, NAMESPACE_URI, &dst, NAMESPACE_META, &meta, -1);
622 NAMESPACE_URI, &dst, 587 if (dst == NULL)
623 NAMESPACE_META, &meta, 588 {
624 -1); 589 GE_BREAK (ectx, 0);
625 if (dst == NULL) { 590 return;
626 GE_BREAK(ectx, 0); 591 }
627 return; 592 resultURI = NS_addToNamespace (ectx, cfg, cls->anonymityLevel, 1000, /* FIXME: priority */
628 } 593 get_time () + 2 * cronYEARS, /* FIXME: expiration */
629 resultURI = NS_addToNamespace(ectx, 594 cls->namespaceName,
630 cfg, 595 cls->updateInterval,
631 cls->anonymityLevel, 596 cls->lastId,
632 1000, /* FIXME: priority */ 597 &cls->thisId, cls->nextId, dst, meta);
633 get_time() + 2 * cronYEARS, /* FIXME: expiration */ 598 if (resultURI != NULL)
634 cls->namespaceName, 599 {
635 cls->updateInterval, 600 list = head;
636 cls->lastId, 601 while ((list != NULL) && (0 != strcmp (cls->namespaceName, list->name)))
637 &cls->thisId, 602 list = list->next;
638 cls->nextId, 603 if (list == NULL)
639 dst, 604 {
640 meta); 605 GE_BREAK (ectx, 0);
641 if (resultURI != NULL) { 606 }
642 list = head; 607 else
643 while ( (list != NULL) && 608 {
644 (0 != strcmp(cls->namespaceName, 609 /* update namespace content list! */
645 list->name)) ) 610 fi.uri = dst;
646 list = list->next; 611 fi.meta = meta;
647 if (list == NULL) { 612 addNamespaceContentToModel (list->model,
648 GE_BREAK(ectx, 0); 613 &fi,
649 } else { 614 &cls->thisId,
650 /* update namespace content list! */ 615 cls->nextId,
651 fi.uri = dst; 616 cls->updateInterval,
652 fi.meta = meta; 617 cls->updateInterval + TIME (NULL));
653 addNamespaceContentToModel(list->model, 618 }
654 &fi, 619 ECRS_freeUri (resultURI);
655 &cls->thisId, 620 }
656 cls->nextId, 621 else
657 cls->updateInterval, 622 {
658 cls->updateInterval + TIME(NULL)); 623 infoMessage (YES,
624 _("Failed to insert content into namespace "
625 "(consult logs).\n"));
659 } 626 }
660 ECRS_freeUri(resultURI); 627 DEBUG_END ();
661 } else {
662 infoMessage(YES,
663 _("Failed to insert content into namespace "
664 "(consult logs).\n"));
665 }
666 DEBUG_END();
667} 628}
668 629
669void on_namespaceInsertMetaDataDialogMetaDataAddButton_clicked_fs(GtkWidget * dummy1, 630void
670 GtkWidget * dummy2) { 631on_namespaceInsertMetaDataDialogMetaDataAddButton_clicked_fs (GtkWidget *
671 handleMetaDataListUpdate(metaXML, 632 dummy1,
672 "namespaceInsertMetaTypeComboBox", 633 GtkWidget *
673 "metaDataValueEntry", 634 dummy2)
674 "metaDataTreeView"); 635{
636 handleMetaDataListUpdate (metaXML,
637 "namespaceInsertMetaTypeComboBox",
638 "metaDataValueEntry", "metaDataTreeView");
675} 639}
676 640
677/** 641/**
@@ -679,104 +643,93 @@ void on_namespaceInsertMetaDataDialogMetaDataAddButton_clicked_fs(GtkWidget * du
679 * available content list to the currently selected 643 * available content list to the currently selected
680 * namespace. 644 * namespace.
681 */ 645 */
682void on_namespaceInsertButton_clicked_fs(GtkWidget * dummy1, 646void
683 GtkWidget * dummy2) { 647on_namespaceInsertButton_clicked_fs (GtkWidget * dummy1, GtkWidget * dummy2)
684 648{
685 const char * identifierName; 649
686 NamespaceList * list; 650 const char *identifierName;
687 GtkWidget * nameLine; 651 NamespaceList *list;
688 GtkWidget * page; 652 GtkWidget *nameLine;
689 GtkWidget * notebook; 653 GtkWidget *page;
690 GtkWidget * dialog; 654 GtkWidget *notebook;
691 GtkWidget * updateIntervalComboBox; 655 GtkWidget *dialog;
656 GtkWidget *updateIntervalComboBox;
692 HashCode512 nextId; 657 HashCode512 nextId;
693 IUC cls; 658 IUC cls;
694 gint num; 659 gint num;
695 660
696 notebook 661 notebook = glade_xml_get_widget (getMainXML (), "localNamespacesNotebook");
697 = glade_xml_get_widget(getMainXML(), 662 num = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
698 "localNamespacesNotebook"); 663 GE_ASSERT (ectx, num != -1);
699 num = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); 664 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), num);
700 GE_ASSERT(ectx, num != -1);
701 page =gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
702 num);
703 list = head; 665 list = head;
704 while ( (list != NULL) && 666 while ((list != NULL) && (list->namespacepage != page))
705 (list->namespacepage != page) )
706 list = list->next; 667 list = list->next;
707 if (list == NULL) { 668 if (list == NULL)
708 GE_BREAK(ectx, 0); 669 {
709 return; 670 GE_BREAK (ectx, 0);
710 } 671 return;
672 }
711 cls.namespaceName = list->name; 673 cls.namespaceName = list->name;
712 674
713 metaXML 675 metaXML
714 = glade_xml_new(getGladeFileName(), 676 = glade_xml_new (getGladeFileName (),
715 "namespaceInsertDialog", 677 "namespaceInsertDialog", PACKAGE_NAME);
716 PACKAGE_NAME); 678 connectGladeWithPlugins (metaXML);
717 connectGladeWithPlugins(metaXML); 679 dialog = glade_xml_get_widget (metaXML, "namespaceInsertDialog");
718 dialog = glade_xml_get_widget(metaXML, 680 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
719 "namespaceInsertDialog"); 681
720 gtk_dialog_set_default_response(GTK_DIALOG(dialog), 682 updateIntervalComboBox = glade_xml_get_widget (metaXML,
721 GTK_RESPONSE_OK); 683 "updateIntervalComboBoxEntry");
722 684 gtk_combo_box_set_active (GTK_COMBO_BOX (updateIntervalComboBox), 0);
723 updateIntervalComboBox = glade_xml_get_widget(metaXML, 685
724 "updateIntervalComboBoxEntry"); 686
725 gtk_combo_box_set_active(GTK_COMBO_BOX(updateIntervalComboBox), 687 if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
726 0); 688 {
727 689 if (OK != tryParseTimeInterval (metaXML,
728 690 "updateIntervalComboBoxEntry",
729 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { 691 &cls.updateInterval))
730 if (OK != tryParseTimeInterval(metaXML, 692 {
731 "updateIntervalComboBoxEntry", 693 /* this should be impossible - OK button is
732 &cls.updateInterval)) { 694 deactivated while parse errors are there */
733 /* this should be impossible - OK button is 695 gtk_widget_destroy (dialog);
734 deactivated while parse errors are there */ 696 UNREF (metaXML);
735 gtk_widget_destroy(dialog); 697 metaXML = NULL;
736 UNREF(metaXML); 698 dialog = gtk_message_dialog_new
737 metaXML = NULL; 699 (NULL,
738 dialog = gtk_message_dialog_new 700 GTK_DIALOG_MODAL,
739 (NULL, 701 GTK_MESSAGE_ERROR,
740 GTK_DIALOG_MODAL, 702 GTK_BUTTONS_CLOSE, _("Failed to parse given time interval!"));
741 GTK_MESSAGE_ERROR, 703 gtk_dialog_run (GTK_DIALOG (dialog));
742 GTK_BUTTONS_CLOSE, 704 gtk_widget_destroy (dialog);
743 _("Failed to parse given time interval!")); 705 return;
744 gtk_dialog_run(GTK_DIALOG(dialog)); 706 }
745 gtk_widget_destroy(dialog); 707 cls.anonymityLevel
746 return; 708 = getSpinButtonValue (metaXML, "anonymitySpinButton");
709 nameLine = glade_xml_get_widget (metaXML,
710 "namespaceContentIdentifierEntry");
711 identifierName = gtk_entry_get_text (GTK_ENTRY (nameLine));
712 if (identifierName == NULL)
713 identifierName = "";
714 hash (identifierName, strlen (identifierName), &cls.thisId);
715 cls.lastId = NULL;
716
717 nameLine = glade_xml_get_widget (metaXML, "nextIdentifierEntry");
718 identifierName = gtk_entry_get_text (GTK_ENTRY (nameLine));
719 if ((identifierName == NULL) || (strlen (identifierName) == 0))
720 {
721 cls.nextId = NULL;
722 }
723 else
724 {
725 hash (identifierName, strlen (identifierName), &nextId);
726 cls.nextId = &nextId;
727 }
728 ggc_tree_selection_selected_foreach
729 (content_selection, &addToNamespaceCB, &cls);
747 } 730 }
748 cls.anonymityLevel 731 gtk_widget_destroy (dialog);
749 = getSpinButtonValue(metaXML, 732 UNREF (metaXML);
750 "anonymitySpinButton");
751 nameLine = glade_xml_get_widget(metaXML,
752 "namespaceContentIdentifierEntry");
753 identifierName = gtk_entry_get_text(GTK_ENTRY(nameLine));
754 if (identifierName == NULL)
755 identifierName = "";
756 hash(identifierName,
757 strlen(identifierName),
758 &cls.thisId);
759 cls.lastId = NULL;
760
761 nameLine = glade_xml_get_widget(metaXML,
762 "nextIdentifierEntry");
763 identifierName = gtk_entry_get_text(GTK_ENTRY(nameLine));
764 if ( (identifierName == NULL) ||
765 (strlen(identifierName) == 0)) {
766 cls.nextId = NULL;
767 } else {
768 hash(identifierName,
769 strlen(identifierName),
770 &nextId);
771 cls.nextId = &nextId;
772 }
773 ggc_tree_selection_selected_foreach
774 (content_selection,
775 &addToNamespaceCB,
776 &cls);
777 }
778 gtk_widget_destroy(dialog);
779 UNREF(metaXML);
780 metaXML = NULL; 733 metaXML = NULL;
781} 734}
782 735
@@ -785,288 +738,243 @@ void on_namespaceInsertButton_clicked_fs(GtkWidget * dummy1,
785 * User clicked on update; launch update dialog 738 * User clicked on update; launch update dialog
786 * and perform namespace content update. 739 * and perform namespace content update.
787 */ 740 */
788void on_namespaceUpdateButton_clicked_fs(GtkWidget * dummy1, 741void
789 GtkWidget * dummy2) { 742on_namespaceUpdateButton_clicked_fs (GtkWidget * dummy1, GtkWidget * dummy2)
790 NamespaceList * list; 743{
744 NamespaceList *list;
791 GtkTreeIter iter; 745 GtkTreeIter iter;
792 HashCode512 nextId; 746 HashCode512 nextId;
793 HashCode512 lastId; 747 HashCode512 lastId;
794 GtkTreeSelection * selection; 748 GtkTreeSelection *selection;
795 IUC cls; 749 IUC cls;
796 char * last; 750 char *last;
797 char * next; 751 char *next;
798 char * freq; 752 char *freq;
799 EncName nextnext; 753 EncName nextnext;
800 GtkWidget * nextEntryLine; 754 GtkWidget *nextEntryLine;
801 GtkWidget * identifierLabel; 755 GtkWidget *identifierLabel;
802 GtkWidget * updateIntervalComboBox; 756 GtkWidget *updateIntervalComboBox;
803 GtkWidget * dialog; 757 GtkWidget *dialog;
804 GtkWidget * mdialog; 758 GtkWidget *mdialog;
805 GtkWidget * notebook; 759 GtkWidget *notebook;
806 GtkWidget * page; 760 GtkWidget *page;
807 GtkTreeModel * model; 761 GtkTreeModel *model;
808 gint num; 762 gint num;
809 const char * nn_str; 763 const char *nn_str;
810 764
811 DEBUG_BEGIN(); 765 DEBUG_BEGIN ();
812 /* find out which namespace this is about */ 766 /* find out which namespace this is about */
813 notebook 767 notebook = glade_xml_get_widget (getMainXML (), "localNamespacesNotebook");
814 = glade_xml_get_widget(getMainXML(), 768 num = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
815 "localNamespacesNotebook"); 769 GE_ASSERT (ectx, num != -1);
816 num = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); 770 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), num);
817 GE_ASSERT(ectx, num != -1);
818 page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
819 num);
820 list = head; 771 list = head;
821 while ( (list != NULL) && 772 while ((list != NULL) && (list->namespacepage != page))
822 (list->namespacepage != page) )
823 list = list->next; 773 list = list->next;
824 if (list == NULL) { 774 if (list == NULL)
825 GE_BREAK(ectx, 0); 775 {
826 return; 776 GE_BREAK (ectx, 0);
827 } 777 return;
778 }
828 cls.namespaceName = list->name; 779 cls.namespaceName = list->name;
829 780
830 /* find out what we are updating */ 781 /* find out what we are updating */
831 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list->treeview)); 782 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list->treeview));
832 if (TRUE != gtk_tree_selection_get_selected(selection, 783 if (TRUE != gtk_tree_selection_get_selected (selection, NULL, &iter))
833 NULL, 784 {
834 &iter)) { 785 GE_BREAK (ectx, 0);
835 GE_BREAK(ectx, 0); 786 return;
836 return; 787 }
837 } 788 gtk_tree_model_get (list->model,
838 gtk_tree_model_get(list->model, 789 &iter,
839 &iter, 790 IN_NAMESPACE_LAST_STRING, &last,
840 IN_NAMESPACE_LAST_STRING, &last, 791 IN_NAMESPACE_NEXT_STRING, &next,
841 IN_NAMESPACE_NEXT_STRING, &next, 792 IN_NAMESPACE_PUB_FREQ_STRING, &freq, -1);
842 IN_NAMESPACE_PUB_FREQ_STRING, &freq, 793 if ((last == NULL) || (next == NULL) || (freq == NULL))
843 -1); 794 {
844 if ( (last == NULL) || 795 GE_BREAK (NULL, 0);
845 (next == NULL) || 796 return;
846 (freq == NULL) ) { 797 }
847 GE_BREAK(NULL, 0); 798 if (OK != parseTimeInterval (freq, &cls.updateInterval))
848 return; 799 {
849 } 800 GE_BREAK (ectx, 0);
850 if (OK != parseTimeInterval(freq, 801 cls.updateInterval = ECRS_SBLOCK_UPDATE_SPORADIC;
851 &cls.updateInterval)) { 802 }
852 GE_BREAK(ectx, 0);
853 cls.updateInterval = ECRS_SBLOCK_UPDATE_SPORADIC;
854 }
855 803
856 /* create update dialog */ 804 /* create update dialog */
857 metaXML 805 metaXML
858 = glade_xml_new(getGladeFileName(), 806 = glade_xml_new (getGladeFileName (),
859 "namespaceUpdateDialog", 807 "namespaceUpdateDialog", PACKAGE_NAME);
860 PACKAGE_NAME); 808 connectGladeWithPlugins (metaXML);
861 connectGladeWithPlugins(metaXML); 809 dialog = glade_xml_get_widget (metaXML, "namespaceUpdateDialog");
862 dialog = glade_xml_get_widget(metaXML, 810 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
863 "namespaceUpdateDialog"); 811 identifierLabel = glade_xml_get_widget (metaXML, "identifierLabel");
864 gtk_dialog_set_default_response(GTK_DIALOG(dialog), 812 gtk_label_set_text (GTK_LABEL (identifierLabel), next);
865 GTK_RESPONSE_OK); 813 enc2hash (last, &lastId);
866 identifierLabel = glade_xml_get_widget(metaXML,
867 "identifierLabel");
868 gtk_label_set_text(GTK_LABEL(identifierLabel),
869 next);
870 enc2hash(last, &lastId);
871 cls.lastId = &lastId; 814 cls.lastId = &lastId;
872 enc2hash(next, &cls.thisId); 815 enc2hash (next, &cls.thisId);
873 816
874 nextEntryLine = glade_xml_get_widget(metaXML, 817 nextEntryLine = glade_xml_get_widget (metaXML, "nextIdentifierEntry");
875 "nextIdentifierEntry"); 818 if ((cls.updateInterval != ECRS_SBLOCK_UPDATE_SPORADIC) &&
876 if ( (cls.updateInterval != ECRS_SBLOCK_UPDATE_SPORADIC) && 819 (OK == NS_computeNextId (NULL,
877 (OK == NS_computeNextId(NULL, 820 cfg,
878 cfg, 821 cls.namespaceName,
879 cls.namespaceName, 822 &lastId,
880 &lastId, 823 &cls.thisId, cls.updateInterval, &nextId)))
881 &cls.thisId, 824 {
882 cls.updateInterval, 825 hash2enc (&nextId, &nextnext);
883 &nextId)) ) { 826 gtk_entry_set_text (GTK_ENTRY (nextEntryLine), (char *) &nextnext);
884 hash2enc(&nextId, 827 gtk_widget_set_sensitive (nextEntryLine, FALSE);
885 &nextnext); 828 }
886 gtk_entry_set_text(GTK_ENTRY(nextEntryLine),
887 (char*) &nextnext);
888 gtk_widget_set_sensitive(nextEntryLine,
889 FALSE);
890 }
891 /* set update interval in dialog to 829 /* set update interval in dialog to
892 the existing update interval */ 830 the existing update interval */
893 updateIntervalComboBox = glade_xml_get_widget(metaXML, 831 updateIntervalComboBox = glade_xml_get_widget (metaXML,
894 "namespaceUpdateIntervalComboBoxEntry"); 832 "namespaceUpdateIntervalComboBoxEntry");
895 model = gtk_combo_box_get_model(GTK_COMBO_BOX(updateIntervalComboBox)); 833 model = gtk_combo_box_get_model (GTK_COMBO_BOX (updateIntervalComboBox));
896 gtk_list_store_insert(GTK_LIST_STORE(model), 834 gtk_list_store_insert (GTK_LIST_STORE (model), &iter, 0);
897 &iter, 835 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, freq, -1);
898 0); 836 gtk_combo_box_set_active (GTK_COMBO_BOX (updateIntervalComboBox), 0);
899 gtk_list_store_set(GTK_LIST_STORE(model),
900 &iter,
901 0, freq,
902 -1);
903 gtk_combo_box_set_active(GTK_COMBO_BOX(updateIntervalComboBox),
904 0);
905 837
906 /* run update dialog */ 838 /* run update dialog */
907 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) 839 if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_OK)
908 goto CLEANUP; 840 goto CLEANUP;
909 gtk_widget_hide(dialog); 841 gtk_widget_hide (dialog);
910 842
911 /* get data from update dialog */ 843 /* get data from update dialog */
912 nn_str = gtk_entry_get_text(GTK_ENTRY(nextEntryLine)); 844 nn_str = gtk_entry_get_text (GTK_ENTRY (nextEntryLine));
913 if (nn_str == NULL) 845 if (nn_str == NULL)
914 nn_str = ""; 846 nn_str = "";
915 hash(nn_str, 847 hash (nn_str, strlen (nn_str), &nextId);
916 strlen(nn_str),
917 &nextId);
918 cls.nextId = &nextId; 848 cls.nextId = &nextId;
919 849
920 if (OK != tryParseTimeInterval(metaXML, 850 if (OK != tryParseTimeInterval (metaXML,
921 "namespaceUpdateIntervalComboBoxEntry", 851 "namespaceUpdateIntervalComboBoxEntry",
922 &cls.updateInterval)) { 852 &cls.updateInterval))
923 /* This should be impossible since the 853 {
924 the OK button is deactivated while parse errors are present */ 854 /* This should be impossible since the
925 mdialog = gtk_message_dialog_new 855 the OK button is deactivated while parse errors are present */
926 (NULL, 856 mdialog = gtk_message_dialog_new
927 GTK_DIALOG_MODAL, 857 (NULL,
928 GTK_MESSAGE_ERROR, 858 GTK_DIALOG_MODAL,
929 GTK_BUTTONS_CLOSE, 859 GTK_MESSAGE_ERROR,
930 _("Failed to parse given time interval!")); 860 GTK_BUTTONS_CLOSE, _("Failed to parse given time interval!"));
931 gtk_dialog_run(GTK_DIALOG(mdialog)); 861 gtk_dialog_run (GTK_DIALOG (mdialog));
932 gtk_widget_destroy(mdialog); 862 gtk_widget_destroy (mdialog);
933 goto CLEANUP; 863 goto CLEANUP;
934 } 864 }
935 cls.anonymityLevel 865 cls.anonymityLevel
936 = getSpinButtonValue(metaXML, 866 = getSpinButtonValue (metaXML, "namespaceUpdateAnonymitySpinButton");
937 "namespaceUpdateAnonymitySpinButton");
938 867
939 /* run actual update */ 868 /* run actual update */
940 ggc_tree_selection_selected_foreach 869 ggc_tree_selection_selected_foreach
941 (content_selection, 870 (content_selection, &addToNamespaceCB, &cls);
942 &addToNamespaceCB, 871CLEANUP:
943 &cls); 872 gtk_widget_destroy (dialog);
944 CLEANUP: 873 UNREF (metaXML);
945 gtk_widget_destroy(dialog);
946 UNREF(metaXML);
947 metaXML = NULL; 874 metaXML = NULL;
948 free(last); 875 free (last);
949 free(next); 876 free (next);
950 free(freq); 877 free (freq);
951 DEBUG_END(); 878 DEBUG_END ();
952} 879}
953 880
954 881
955 882
956void fs_namespace_start() { 883void
957 GtkWidget * contentList; 884fs_namespace_start ()
958 GtkListStore * model; 885{
959 GtkCellRenderer * renderer; 886 GtkWidget *contentList;
960 GtkWidget * trackCheckButton; 887 GtkListStore *model;
961 GtkTreeViewColumn * column; 888 GtkCellRenderer *renderer;
889 GtkWidget *trackCheckButton;
890 GtkTreeViewColumn *column;
962 int col; 891 int col;
963 892
964 DEBUG_BEGIN(); 893 DEBUG_BEGIN ();
965 trackCheckButton 894 trackCheckButton
966 = glade_xml_get_widget(getMainXML(), 895 = glade_xml_get_widget (getMainXML (), "trackingCheckButton");
967 "trackingCheckButton"); 896 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (trackCheckButton),
968 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(trackCheckButton), 897 URITRACK_trackStatus (ectx,
969 URITRACK_trackStatus(ectx, 898 cfg) ==
970 cfg) == YES ? TRUE : FALSE); 899 YES ? TRUE : FALSE);
971 900
972 contentList 901 contentList = glade_xml_get_widget (getMainXML (), "availableContentList");
973 = glade_xml_get_widget(getMainXML(), 902
974 "availableContentList"); 903 model = gtk_list_store_new (NAMESPACE_NUM, G_TYPE_STRING, /* name */
975 904 G_TYPE_UINT64, /* size */
976 model = gtk_list_store_new(NAMESPACE_NUM, 905 G_TYPE_STRING, /* human-readable size */
977 G_TYPE_STRING, /* name */ 906 G_TYPE_STRING, /* uri-string */
978 G_TYPE_UINT64, /* size */ 907 G_TYPE_POINTER, G_TYPE_POINTER); /* uri */
979 G_TYPE_STRING, /* human-readable size */ 908 gtk_tree_view_set_model (GTK_TREE_VIEW (contentList),
980 G_TYPE_STRING, /* uri-string */ 909 GTK_TREE_MODEL (model));
981 G_TYPE_POINTER, 910 content_selection =
982 G_TYPE_POINTER); /* uri */ 911 gtk_tree_view_get_selection (GTK_TREE_VIEW (contentList));
983 gtk_tree_view_set_model(GTK_TREE_VIEW(contentList), 912 gtk_tree_selection_set_mode (content_selection, GTK_SELECTION_MULTIPLE);
984 GTK_TREE_MODEL(model)); 913
985 content_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(contentList)); 914 g_signal_connect_data (content_selection,
986 gtk_tree_selection_set_mode(content_selection, 915 "changed",
987 GTK_SELECTION_MULTIPLE); 916 G_CALLBACK (&on_namespaceContentSelectionChanged),
988 917 NULL, NULL, 0);
989 g_signal_connect_data(content_selection, 918
990 "changed", 919
991 G_CALLBACK(&on_namespaceContentSelectionChanged), 920 renderer = gtk_cell_renderer_text_new ();
992 NULL, 921 col =
993 NULL, 922 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (contentList),
994 0); 923 -1, _("Filename"), renderer,
995 924 "text", NAMESPACE_FILENAME,
996 925 NULL);
997 renderer = gtk_cell_renderer_text_new(); 926 column = gtk_tree_view_get_column (GTK_TREE_VIEW (contentList), col - 1);
998 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(contentList), 927 gtk_tree_view_column_set_resizable (column, TRUE);
999 -1, 928 gtk_tree_view_column_set_clickable (column, TRUE);
1000 _("Filename"), 929 gtk_tree_view_column_set_reorderable (column, TRUE);
1001 renderer, 930 gtk_tree_view_column_set_sort_column_id (column, NAMESPACE_FILENAME);
1002 "text", NAMESPACE_FILENAME, 931 /*gtk_tree_view_column_set_sort_indicator(column, TRUE); */
1003 NULL); 932
1004 column = gtk_tree_view_get_column(GTK_TREE_VIEW(contentList), 933 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
1005 col - 1); 934 (GTK_TREE_VIEW (contentList), col - 1),
1006 gtk_tree_view_column_set_resizable(column, TRUE); 935 TRUE);
1007 gtk_tree_view_column_set_clickable(column, TRUE); 936 renderer = gtk_cell_renderer_text_new ();
1008 gtk_tree_view_column_set_reorderable(column, TRUE);
1009 gtk_tree_view_column_set_sort_column_id(column, NAMESPACE_FILENAME);
1010 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/
1011
1012 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(contentList),
1013 col - 1),
1014 TRUE);
1015 renderer = gtk_cell_renderer_text_new();
1016 g_object_set (renderer, "xalign", 1.00, NULL); 937 g_object_set (renderer, "xalign", 1.00, NULL);
1017 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(contentList), 938 col =
1018 -1, 939 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (contentList),
1019 _("Filesize"), 940 -1, _("Filesize"), renderer,
1020 renderer, 941 "text", NAMESPACE_HSIZE,
1021 "text", NAMESPACE_HSIZE, 942 NULL);
1022 NULL); 943 column = gtk_tree_view_get_column (GTK_TREE_VIEW (contentList), col - 1);
1023 column = gtk_tree_view_get_column(GTK_TREE_VIEW(contentList), 944 gtk_tree_view_column_set_resizable (column, TRUE);
1024 col - 1); 945 gtk_tree_view_column_set_clickable (column, TRUE);
1025 gtk_tree_view_column_set_resizable(column, TRUE); 946 gtk_tree_view_column_set_reorderable (column, TRUE);
1026 gtk_tree_view_column_set_clickable(column, TRUE); 947 gtk_tree_view_column_set_sort_column_id (column, NAMESPACE_SIZE);
1027 gtk_tree_view_column_set_reorderable(column, TRUE); 948 /*gtk_tree_view_column_set_sort_indicator(column, TRUE); */
1028 gtk_tree_view_column_set_sort_column_id(column, NAMESPACE_SIZE); 949 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
1029 /*gtk_tree_view_column_set_sort_indicator(column, TRUE);*/ 950 (GTK_TREE_VIEW (contentList), col - 1),
1030 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(contentList), 951 TRUE);
1031 col - 1), 952 renderer = gtk_cell_renderer_text_new ();
1032 TRUE); 953 col =
1033 renderer = gtk_cell_renderer_text_new(); 954 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (contentList),
1034 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(contentList), 955 -1, _("URI"), renderer,
1035 -1, 956 "text", NAMESPACE_URISTRING,
1036 _("URI"), 957 NULL);
1037 renderer, 958 column = gtk_tree_view_get_column (GTK_TREE_VIEW (contentList), col - 1);
1038 "text", NAMESPACE_URISTRING, 959 gtk_tree_view_column_set_reorderable (column, TRUE);
1039 NULL); 960 gtk_tree_view_column_set_resizable (column, TRUE);
1040 column = gtk_tree_view_get_column(GTK_TREE_VIEW(contentList), 961 gtk_tree_view_column_set_resizable (gtk_tree_view_get_column
1041 col - 1); 962 (GTK_TREE_VIEW (contentList), col - 1),
1042 gtk_tree_view_column_set_reorderable(column, TRUE); 963 TRUE);
1043 gtk_tree_view_column_set_resizable(column, TRUE); 964 URITRACK_registerTrackCallback (ectx, cfg, &updateViewSave, NULL);
1044 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(contentList), 965 NS_listNamespaces (ectx, cfg, &addTabForNamespace, NULL);
1045 col - 1), 966 NS_registerDiscoveryCallback (ectx, cfg, &namespace_discovered_cb, NULL);
1046 TRUE); 967 DEBUG_END ();
1047 URITRACK_registerTrackCallback(ectx,
1048 cfg,
1049 &updateViewSave,
1050 NULL);
1051 NS_listNamespaces(ectx,
1052 cfg,
1053 &addTabForNamespace,
1054 NULL);
1055 NS_registerDiscoveryCallback(ectx,
1056 cfg,
1057 &namespace_discovered_cb,
1058 NULL);
1059 DEBUG_END();
1060} 968}
1061 969
1062 970
1063void fs_namespace_stop() { 971void
1064 NS_unregisterDiscoveryCallback(&namespace_discovered_cb, 972fs_namespace_stop ()
1065 NULL); 973{
974 NS_unregisterDiscoveryCallback (&namespace_discovered_cb, NULL);
1066 while (head != NULL) 975 while (head != NULL)
1067 frame_destroy(head->treeview); 976 frame_destroy (head->treeview);
1068 URITRACK_unregisterTrackCallback(&updateViewSave, 977 URITRACK_unregisterTrackCallback (&updateViewSave, NULL);
1069 NULL);
1070} 978}
1071 979
1072/* end of namespace.c */ 980/* end of namespace.c */
diff --git a/src/plugins/fs/namespace.h b/src/plugins/fs/namespace.h
index f0a251f5..3343e561 100644
--- a/src/plugins/fs/namespace.h
+++ b/src/plugins/fs/namespace.h
@@ -30,15 +30,14 @@
30/** 30/**
31 * Add a tab for the given namespace. 31 * Add a tab for the given namespace.
32 */ 32 */
33int addTabForNamespace(void * unused, 33int addTabForNamespace (void *unused,
34 const char * namespaceName, 34 const char *namespaceName,
35 const HashCode512 * namespaceId, 35 const HashCode512 * namespaceId,
36 const struct ECRS_MetaData * md, 36 const struct ECRS_MetaData *md, int rating);
37 int rating);
38 37
39 38
40void fs_namespace_start(void); 39void fs_namespace_start (void);
41 40
42void fs_namespace_stop(void); 41void fs_namespace_stop (void);
43 42
44#endif 43#endif
diff --git a/src/plugins/fs/namespace_create.c b/src/plugins/fs/namespace_create.c
index cdd24912..1182c0a6 100644
--- a/src/plugins/fs/namespace_create.c
+++ b/src/plugins/fs/namespace_create.c
@@ -37,224 +37,220 @@
37#include <extractor.h> 37#include <extractor.h>
38 38
39 39
40static GladeXML * metaXML; 40static GladeXML *metaXML;
41 41
42 42
43void on_namespacemetaDataDialogKeywordRemoveButton_clicked_fs(gpointer dummy, 43void
44 GtkWidget * uploadButton) { 44on_namespacemetaDataDialogKeywordRemoveButton_clicked_fs (gpointer dummy,
45 handleListRemove(metaXML, 45 GtkWidget *
46 "namespaceMetaDataDialogKeywordList"); 46 uploadButton)
47{
48 handleListRemove (metaXML, "namespaceMetaDataDialogKeywordList");
47} 49}
48 50
49void on_namespacemetaDataDialogMetaDataRemoveButton_clicked_fs(gpointer dummy, 51void
50 GtkWidget * uploadButton) { 52on_namespacemetaDataDialogMetaDataRemoveButton_clicked_fs (gpointer dummy,
51 handleListRemove(metaXML, 53 GtkWidget *
52 "namespaceMetaDataDialogMetaDataList"); 54 uploadButton)
55{
56 handleListRemove (metaXML, "namespaceMetaDataDialogMetaDataList");
53} 57}
54 58
55void on_namespacemetaDataDialogKeywordAddButton_clicked_fs(gpointer dummy, 59void
56 GtkWidget * uploadButton) { 60on_namespacemetaDataDialogKeywordAddButton_clicked_fs (gpointer dummy,
57 handleKeywordListUpdate(metaXML, 61 GtkWidget *
58 "namespaceKeywordEntry", 62 uploadButton)
59 "namespaceMetaDataDialogKeywordList"); 63{
64 handleKeywordListUpdate (metaXML,
65 "namespaceKeywordEntry",
66 "namespaceMetaDataDialogKeywordList");
60} 67}
61 68
62void on_namespacemetaDataDialogMetaDataAddButton_clicked_fs(gpointer dummy, 69void
63 GtkWidget * uploadButton) { 70on_namespacemetaDataDialogMetaDataAddButton_clicked_fs (gpointer dummy,
64 handleMetaDataListUpdate(metaXML, 71 GtkWidget *
65 "namespaceMetaDataDialogMetaTypeComboBox", 72 uploadButton)
66 "namespaceMetaDataValueEntry", 73{
67 "namespaceMetaDataDialogMetaDataList"); 74 handleMetaDataListUpdate (metaXML,
75 "namespaceMetaDataDialogMetaTypeComboBox",
76 "namespaceMetaDataValueEntry",
77 "namespaceMetaDataDialogMetaDataList");
68} 78}
69 79
70/** 80/**
71 * The selection of the keyword list changed. 81 * The selection of the keyword list changed.
72 * Update button status. 82 * Update button status.
73 */ 83 */
74static void on_keyword_list_selection_changed(gpointer signal, 84static void
75 gpointer cls) { 85on_keyword_list_selection_changed (gpointer signal, gpointer cls)
76 GtkTreeSelection * selection; 86{
77 GtkWidget * button; 87 GtkTreeSelection *selection;
88 GtkWidget *button;
78 89
79 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(metaXML, 90 selection =
80 "namespaceMetaDataDialogKeywordList"))); 91 gtk_tree_view_get_selection (GTK_TREE_VIEW
81 button 92 (glade_xml_get_widget
82 = glade_xml_get_widget(metaXML, 93 (metaXML,
83 "nsMetaDataDialogKeywordRemoveButton"); 94 "namespaceMetaDataDialogKeywordList")));
84 gtk_widget_set_sensitive(button, 95 button =
85 gtk_tree_selection_count_selected_rows(selection) > 0); 96 glade_xml_get_widget (metaXML, "nsMetaDataDialogKeywordRemoveButton");
97 gtk_widget_set_sensitive (button,
98 gtk_tree_selection_count_selected_rows (selection)
99 > 0);
86} 100}
87 101
88/** 102/**
89 * The selection of the metadata list changed. 103 * The selection of the metadata list changed.
90 * Update button status. 104 * Update button status.
91 */ 105 */
92static void on_metadata_list_selection_changed(gpointer signal, 106static void
93 gpointer cls) { 107on_metadata_list_selection_changed (gpointer signal, gpointer cls)
94 GtkTreeSelection * selection; 108{
95 GtkWidget * button; 109 GtkTreeSelection *selection;
110 GtkWidget *button;
96 111
97 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(metaXML, 112 selection =
98 "namespaceMetaDataDialogMetaDataList"))); 113 gtk_tree_view_get_selection (GTK_TREE_VIEW
99 button 114 (glade_xml_get_widget
100 = glade_xml_get_widget(metaXML, 115 (metaXML,
101 "nsMetaDataDialogMetaDataRemoveButton"); 116 "namespaceMetaDataDialogMetaDataList")));
102 gtk_widget_set_sensitive(button, 117 button =
103 gtk_tree_selection_count_selected_rows(selection) > 0); 118 glade_xml_get_widget (metaXML, "nsMetaDataDialogMetaDataRemoveButton");
119 gtk_widget_set_sensitive (button,
120 gtk_tree_selection_count_selected_rows (selection)
121 > 0);
104} 122}
105 123
106/** 124/**
107 * The user has edited the metadata entry. 125 * The user has edited the metadata entry.
108 * Update add button status. 126 * Update add button status.
109 */ 127 */
110void on_namespaceMetaDataValueEntry_changed_fs(gpointer dummy2, 128void
111 GtkWidget * searchEntry) { 129on_namespaceMetaDataValueEntry_changed_fs (gpointer dummy2,
112 const char * input; 130 GtkWidget * searchEntry)
113 GtkWidget * button; 131{
132 const char *input;
133 GtkWidget *button;
114 134
115 input = gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(metaXML, 135 input = gtk_entry_get_text (GTK_ENTRY (glade_xml_get_widget (metaXML,
116 "namespaceMetaDataValueEntry"))); 136 "namespaceMetaDataValueEntry")));
117 if (input == NULL) 137 if (input == NULL)
118 return; 138 return;
119 button 139 button
120 = glade_xml_get_widget(metaXML, 140 = glade_xml_get_widget (metaXML, "nsMetaDataDialogMetaDataAddButton");
121 "nsMetaDataDialogMetaDataAddButton"); 141 gtk_widget_set_sensitive (button, strlen (input) > 0);
122 gtk_widget_set_sensitive(button,
123 strlen(input) > 0);
124} 142}
125 143
126/** 144/**
127 * The user has edited the keyword entry. 145 * The user has edited the keyword entry.
128 * Update add button status. 146 * Update add button status.
129 */ 147 */
130void on_namespaceKeywordEntry_changed_fs(gpointer dummy2, 148void
131 GtkWidget * searchEntry) { 149on_namespaceKeywordEntry_changed_fs (gpointer dummy2, GtkWidget * searchEntry)
132 const char * input; 150{
133 GtkWidget * button; 151 const char *input;
152 GtkWidget *button;
134 153
135 input = gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(metaXML, 154 input = gtk_entry_get_text (GTK_ENTRY (glade_xml_get_widget (metaXML,
136 "namespaceKeywordEntry"))); 155 "namespaceKeywordEntry")));
137 if (input == NULL) 156 if (input == NULL)
138 return; 157 return;
139 button 158 button = glade_xml_get_widget (metaXML, "nsMetaDataDialogKeywordAddButton");
140 = glade_xml_get_widget(metaXML, 159 gtk_widget_set_sensitive (button, strlen (input) > 0);
141 "nsMetaDataDialogKeywordAddButton");
142 gtk_widget_set_sensitive(button,
143 strlen(input) > 0);
144} 160}
145 161
146 162
147void create_namespace_clicked_fs(GtkWidget * dummy1, 163void
148 GtkWidget * dummy2) { 164create_namespace_clicked_fs (GtkWidget * dummy1, GtkWidget * dummy2)
149 const char * namespaceName; 165{
150 GtkWidget * nameLine; 166 const char *namespaceName;
151 GtkWidget * dialog; 167 GtkWidget *nameLine;
152 GtkWidget * spin; 168 GtkWidget *dialog;
153 struct ECRS_MetaData * meta; 169 GtkWidget *spin;
154 struct ECRS_URI * keywordURI; 170 struct ECRS_MetaData *meta;
155 struct ECRS_URI * root; 171 struct ECRS_URI *keywordURI;
172 struct ECRS_URI *root;
156 HashCode512 namespaceId; 173 HashCode512 namespaceId;
157 HashCode512 rootEntry; 174 HashCode512 rootEntry;
158 175
159 DEBUG_BEGIN(); 176 DEBUG_BEGIN ();
160 metaXML 177 metaXML
161 = glade_xml_new(getGladeFileName(), 178 = glade_xml_new (getGladeFileName (),
162 "namespaceMetaDataDialog", 179 "namespaceMetaDataDialog", PACKAGE_NAME);
163 PACKAGE_NAME); 180 connectGladeWithPlugins (metaXML);
164 connectGladeWithPlugins(metaXML); 181 dialog = glade_xml_get_widget (metaXML, "namespaceMetaDataDialog");
165 dialog = glade_xml_get_widget(metaXML, 182 createMetaDataListTreeView (metaXML,
166 "namespaceMetaDataDialog"); 183 "namespaceMetaDataDialogMetaDataList",
167 createMetaDataListTreeView(metaXML, 184 NULL, NULL);
168 "namespaceMetaDataDialogMetaDataList", 185 g_signal_connect_data (gtk_tree_view_get_selection
169 NULL, 186 (GTK_TREE_VIEW
170 NULL); 187 (glade_xml_get_widget
171 g_signal_connect_data(gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(metaXML, 188 (metaXML, "namespaceMetaDataDialogMetaDataList"))),
172 "namespaceMetaDataDialogMetaDataList"))), 189 "changed",
173 "changed", 190 G_CALLBACK (&on_metadata_list_selection_changed),
174 G_CALLBACK(&on_metadata_list_selection_changed), 191 NULL, NULL, 0);
175 NULL, 192 createKeywordListTreeView (metaXML, "namespaceMetaDataDialogKeywordList",
176 NULL, 193 NULL);
177 0); 194 g_signal_connect_data (gtk_tree_view_get_selection
178 createKeywordListTreeView(metaXML, 195 (GTK_TREE_VIEW
179 "namespaceMetaDataDialogKeywordList", 196 (glade_xml_get_widget
180 NULL); 197 (metaXML, "namespaceMetaDataDialogKeywordList"))),
181 g_signal_connect_data(gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(metaXML, 198 "changed",
182 "namespaceMetaDataDialogKeywordList"))), 199 G_CALLBACK (&on_keyword_list_selection_changed),
183 "changed", 200 NULL, NULL, 0);
184 G_CALLBACK(&on_keyword_list_selection_changed),
185 NULL,
186 NULL,
187 0);
188 201
189 createMetaTypeComboBox(metaXML, 202 createMetaTypeComboBox (metaXML, "namespaceMetaDataDialogMetaTypeComboBox");
190 "namespaceMetaDataDialogMetaTypeComboBox"); 203 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
191 gtk_dialog_set_default_response(GTK_DIALOG(dialog), 204 if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
192 GTK_RESPONSE_OK); 205 {
193 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { 206 meta
194 meta 207 = getMetaDataFromList (metaXML,
195 = getMetaDataFromList(metaXML, 208 "namespaceMetaDataDialogMetaDataList", NULL);
196 "namespaceMetaDataDialogMetaDataList", 209 keywordURI
197 NULL); 210 = getKeywordURIFromList (metaXML,
198 keywordURI 211 "namespaceMetaDataDialogKeywordList");
199 = getKeywordURIFromList(metaXML, 212 spin = glade_xml_get_widget (metaXML, "namespaceAnonymityspinbutton");
200 "namespaceMetaDataDialogKeywordList"); 213 nameLine = glade_xml_get_widget (metaXML, "namespaceRootEntry");
201 spin = glade_xml_get_widget(metaXML, 214 namespaceName = gtk_entry_get_text (GTK_ENTRY (nameLine));
202 "namespaceAnonymityspinbutton"); 215 if (namespaceName == NULL)
203 nameLine = glade_xml_get_widget(metaXML, 216 namespaceName = "root"; /* do NOT translate "root"! */
204 "namespaceRootEntry"); 217 hash (namespaceName, strlen (namespaceName), &rootEntry);
205 namespaceName = gtk_entry_get_text(GTK_ENTRY(nameLine)); 218 nameLine = glade_xml_get_widget (metaXML, "namespaceNameEntry");
206 if (namespaceName == NULL) 219 namespaceName = gtk_entry_get_text (GTK_ENTRY (nameLine));
207 namespaceName = "root"; /* do NOT translate "root"! */ 220 root = NS_createNamespace (ectx, cfg, gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin)), 1000, /* FIXME: priority */
208 hash(namespaceName, 221 get_time () + 2 * cronYEARS, /* FIXME: expiration */
209 strlen(namespaceName), 222 namespaceName, meta, keywordURI, &rootEntry);
210 &rootEntry); 223 if (root != NULL)
211 nameLine = glade_xml_get_widget(metaXML, 224 {
212 "namespaceNameEntry"); 225 ECRS_getNamespaceId (root, &namespaceId);
213 namespaceName = gtk_entry_get_text(GTK_ENTRY(nameLine)); 226 addTabForNamespace (NULL, namespaceName, &namespaceId, meta, 0);
214 root = NS_createNamespace(ectx, 227 ECRS_freeUri (root);
215 cfg, 228 }
216 gtk_spin_button_get_value_as_int 229 else
217 (GTK_SPIN_BUTTON(spin)), 230 {
218 1000, /* FIXME: priority */ 231 GtkWidget *dialog;
219 get_time() + 2 * cronYEARS, /* FIXME: expiration */
220 namespaceName,
221 meta,
222 keywordURI,
223 &rootEntry);
224 if (root != NULL) {
225 ECRS_getNamespaceId(root,
226 &namespaceId);
227 addTabForNamespace(NULL,
228 namespaceName,
229 &namespaceId,
230 meta,
231 0);
232 ECRS_freeUri(root);
233 } else {
234 GtkWidget * dialog;
235 232
236 /* IMPROVE-ME: we could check if the 233 /* IMPROVE-ME: we could check if the
237 namespace exists as the user 234 namespace exists as the user
238 enters its name and disable the 235 enters its name and disable the
239 "Ok" button unless the name is unique */ 236 "Ok" button unless the name is unique */
240 dialog = gtk_message_dialog_new 237 dialog = gtk_message_dialog_new
241 (NULL, 238 (NULL,
242 GTK_DIALOG_MODAL, 239 GTK_DIALOG_MODAL,
243 GTK_MESSAGE_ERROR, 240 GTK_MESSAGE_ERROR,
244 GTK_BUTTONS_CLOSE, 241 GTK_BUTTONS_CLOSE,
245 _("Failed to create namespace `%s'." 242 _("Failed to create namespace `%s'."
246 "Consult logs, most likely error is" 243 "Consult logs, most likely error is"
247 " that a namespace with that name " 244 " that a namespace with that name "
248 "already exists."), 245 "already exists."), namespaceName);
249 namespaceName); 246 gtk_dialog_run (GTK_DIALOG (dialog));
250 gtk_dialog_run(GTK_DIALOG(dialog)); 247 gtk_widget_destroy (dialog);
251 gtk_widget_destroy(dialog); 248 }
249 ECRS_freeMetaData (meta);
250 ECRS_freeUri (keywordURI);
252 } 251 }
253 ECRS_freeMetaData(meta); 252 gtk_widget_destroy (dialog);
254 ECRS_freeUri(keywordURI); 253 UNREF (metaXML);
255 }
256 gtk_widget_destroy(dialog);
257 UNREF(metaXML);
258 metaXML = NULL; 254 metaXML = NULL;
259 DEBUG_END(); 255 DEBUG_END ();
260} 256}
diff --git a/src/plugins/fs/namespace_search.c b/src/plugins/fs/namespace_search.c
index 5a15194b..d89297f6 100644
--- a/src/plugins/fs/namespace_search.c
+++ b/src/plugins/fs/namespace_search.c
@@ -39,73 +39,67 @@
39 * The spin button giving the rating for a particular namespace 39 * The spin button giving the rating for a particular namespace
40 * has been changed. Store the new rating for the namespace. 40 * has been changed. Store the new rating for the namespace.
41 */ 41 */
42void on_namespaceRatingSpinButton_changed_fs(GtkWidget * dummy, 42void
43 GtkWidget * dummy2) { 43on_namespaceRatingSpinButton_changed_fs (GtkWidget * dummy,
44 GtkWidget * spin; 44 GtkWidget * dummy2)
45 GtkWidget * ncbe; 45{
46 GtkTreeModel * model; 46 GtkWidget *spin;
47 GtkWidget *ncbe;
48 GtkTreeModel *model;
47 GtkTreeIter iter; 49 GtkTreeIter iter;
48 char * encStr; 50 char *encStr;
49 char * description; 51 char *description;
50 int rating; 52 int rating;
51 int newrating; 53 int newrating;
52 54
53 DEBUG_BEGIN(); 55 DEBUG_BEGIN ();
54 spin 56 spin = glade_xml_get_widget (getMainXML (), "namespaceRatingSpinButton");
55 = glade_xml_get_widget(getMainXML(), 57 ncbe = glade_xml_get_widget (getMainXML (), "searchNamespaceComboBoxEntry");
56 "namespaceRatingSpinButton"); 58 model = gtk_combo_box_get_model (GTK_COMBO_BOX (ncbe));
57 ncbe
58 = glade_xml_get_widget(getMainXML(),
59 "searchNamespaceComboBoxEntry");
60 model = gtk_combo_box_get_model(GTK_COMBO_BOX(ncbe));
61 description = NULL; 59 description = NULL;
62 encStr = NULL; 60 encStr = NULL;
63 if (TRUE == gtk_combo_box_get_active_iter(GTK_COMBO_BOX(ncbe), 61 if (TRUE == gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ncbe), &iter))
64 &iter)) { 62 {
65 gtk_tree_model_get(model, 63 gtk_tree_model_get (model,
66 &iter, 64 &iter,
67 NS_SEARCH_DESCRIPTION, &description, 65 NS_SEARCH_DESCRIPTION, &description,
68 NS_SEARCH_ENCNAME, &encStr, 66 NS_SEARCH_ENCNAME, &encStr,
69 NS_SEARCH_RATING, &rating, 67 NS_SEARCH_RATING, &rating, -1);
70 -1); 68 if ((description != NULL) && (0 == strcmp (description, _("globally"))))
71 if ( (description != NULL) && 69 {
72 (0 == strcmp(description, 70 /* just to be sure */
73 _("globally"))) ) { 71 gtk_widget_set_sensitive (spin, FALSE);
74 /* just to be sure */ 72 }
75 gtk_widget_set_sensitive(spin, 73 else
76 FALSE); 74 {
77 } else { 75 if (encStr != NULL)
78 if (encStr != NULL) { 76 {
79 newrating = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)); 77 newrating = gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin));
80 rating = NS_rankNamespace(ectx, 78 rating = NS_rankNamespace (ectx,
81 cfg, 79 cfg, encStr, newrating - rating);
82 encStr, 80 if (rating != newrating)
83 newrating - rating); 81 {
84 if (rating != newrating) { 82 /* concurrent modification? */
85 /* concurrent modification? */ 83 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), rating);
86 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 84 GE_BREAK (ectx, 0);
87 rating); 85 }
88 GE_BREAK(ectx, 0); 86 gtk_list_store_set (GTK_LIST_STORE (model),
89 } 87 &iter, NS_SEARCH_RATING, rating, -1);
90 gtk_list_store_set(GTK_LIST_STORE(model), 88 }
91 &iter, 89 }
92 NS_SEARCH_RATING, rating, 90 }
93 -1); 91 else
94 } 92 {
93 /* FIXME: if enc2hash succeeds, we may want to keep this
94 active */
95 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), 0);
96 gtk_widget_set_sensitive (spin, FALSE);
95 } 97 }
96 } else {
97 /* FIXME: if enc2hash succeeds, we may want to keep this
98 active */
99 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin),
100 0);
101 gtk_widget_set_sensitive(spin,
102 FALSE);
103 }
104 if (description != NULL) 98 if (description != NULL)
105 free(description); 99 free (description);
106 if (encStr != NULL) 100 if (encStr != NULL)
107 free(encStr); 101 free (encStr);
108 DEBUG_END(); 102 DEBUG_END ();
109} 103}
110 104
111 105
@@ -114,175 +108,159 @@ void on_namespaceRatingSpinButton_changed_fs(GtkWidget * dummy,
114 * Update the trust level (possibly changing sensitivity) 108 * Update the trust level (possibly changing sensitivity)
115 * and set the search string to the root (if available). 109 * and set the search string to the root (if available).
116 */ 110 */
117void on_searchNamespaceComboBoxEntry_changed_fs(GtkWidget * dummy, 111void
118 GtkWidget * dummy2) { 112on_searchNamespaceComboBoxEntry_changed_fs (GtkWidget * dummy,
119 GtkWidget * keyword; 113 GtkWidget * dummy2)
120 GtkWidget * spin; 114{
121 GtkWidget * ncbe; 115 GtkWidget *keyword;
122 GtkTreeModel * model; 116 GtkWidget *spin;
117 GtkWidget *ncbe;
118 GtkTreeModel *model;
123 GtkTreeIter iter; 119 GtkTreeIter iter;
124 int rating; 120 int rating;
125 char * encStr; 121 char *encStr;
126 char * descStr; 122 char *descStr;
127 HashCode512 ns; 123 HashCode512 ns;
128 HashCode512 root; 124 HashCode512 root;
129 EncName enc; 125 EncName enc;
130 126
131 DEBUG_BEGIN(); 127 DEBUG_BEGIN ();
132 spin 128 spin = glade_xml_get_widget (getMainXML (), "namespaceRatingSpinButton");
133 = glade_xml_get_widget(getMainXML(), 129 ncbe = glade_xml_get_widget (getMainXML (), "searchNamespaceComboBoxEntry");
134 "namespaceRatingSpinButton"); 130 model = gtk_combo_box_get_model (GTK_COMBO_BOX (ncbe));
135 ncbe
136 = glade_xml_get_widget(getMainXML(),
137 "searchNamespaceComboBoxEntry");
138 model = gtk_combo_box_get_model(GTK_COMBO_BOX(ncbe));
139 descStr = NULL; 131 descStr = NULL;
140 encStr = NULL; 132 encStr = NULL;
141 if (TRUE == gtk_combo_box_get_active_iter(GTK_COMBO_BOX(ncbe), 133 if (TRUE == gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ncbe), &iter))
142 &iter)) { 134 {
143 gtk_tree_model_get(model, 135 gtk_tree_model_get (model,
144 &iter, 136 &iter,
145 NS_SEARCH_DESCRIPTION, &descStr, 137 NS_SEARCH_DESCRIPTION, &descStr,
146 NS_SEARCH_ENCNAME, &encStr, 138 NS_SEARCH_ENCNAME, &encStr,
147 NS_SEARCH_RATING, &rating, 139 NS_SEARCH_RATING, &rating, -1);
148 -1); 140 if ((descStr != NULL) && (0 == strcmp (descStr, _("globally"))))
149 if ( (descStr != NULL) && 141 {
150 (0 == strcmp(descStr, 142 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), 0);
151 _("globally"))) ) { 143 gtk_widget_set_sensitive (spin, FALSE);
152 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 144 }
153 0); 145 else if (encStr != NULL)
154 gtk_widget_set_sensitive(spin, 146 {
155 FALSE); 147 enc2hash (encStr, &ns);
156 } else if (encStr != NULL) { 148 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), rating);
157 enc2hash(encStr, 149 gtk_widget_set_sensitive (spin, TRUE);
158 &ns); 150 keyword
159 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 151 = glade_xml_get_widget (getMainXML (),
160 rating); 152 "fssearchKeywordComboBoxEntry");
161 gtk_widget_set_sensitive(spin, 153 if (OK == NS_getNamespaceRoot (ectx, cfg, encStr, &root))
162 TRUE); 154 {
163 keyword 155 hash2enc (&root, &enc);
164 = glade_xml_get_widget(getMainXML(), 156 gtk_entry_set_text (GTK_ENTRY
165 "fssearchKeywordComboBoxEntry"); 157 (gtk_bin_get_child (GTK_BIN (keyword))),
166 if (OK == NS_getNamespaceRoot(ectx, 158 (const gchar *) &enc);
167 cfg, 159 }
168 encStr, 160 else
169 &root)) { 161 {
170 hash2enc(&root, 162 gtk_entry_set_text (GTK_ENTRY
171 &enc); 163 (gtk_bin_get_child (GTK_BIN (keyword))),
172 gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(keyword))), 164 "");
173 (const gchar*) &enc); 165 }
174 } else { 166 }
175 gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(keyword))), 167 }
176 ""); 168 else
177 } 169 {
170 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), 0);
171 gtk_widget_set_sensitive (spin, FALSE);
178 } 172 }
179 } else {
180 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin),
181 0);
182 gtk_widget_set_sensitive(spin,
183 FALSE);
184 }
185 if (descStr != NULL) 173 if (descStr != NULL)
186 free(descStr); 174 free (descStr);
187 if (encStr != NULL) 175 if (encStr != NULL)
188 free(encStr); 176 free (encStr);
189 DEBUG_END(); 177 DEBUG_END ();
190} 178}
191 179
192struct NewNamespaceInfo { 180struct NewNamespaceInfo
193 const char * namespaceName; 181{
194 const HashCode512 * namespaceId; 182 const char *namespaceName;
195 const struct ECRS_MetaData * md; 183 const HashCode512 *namespaceId;
184 const struct ECRS_MetaData *md;
196 int rating; 185 int rating;
197}; 186};
198 187
199static void * saveDiscovery(void * cls) { 188static void *
200 struct NewNamespaceInfo * nni = cls; 189saveDiscovery (void *cls)
190{
191 struct NewNamespaceInfo *nni = cls;
201 192
202 GtkListStore * model; 193 GtkListStore *model;
203 GtkTreeIter iter; 194 GtkTreeIter iter;
204 EncName enc; 195 EncName enc;
205 char * name; 196 char *name;
206 struct ECRS_MetaData * dmd; 197 struct ECRS_MetaData *dmd;
207 GtkWidget * ncbe; 198 GtkWidget *ncbe;
208 char * desc; 199 char *desc;
209 size_t n; 200 size_t n;
210 int found; 201 int found;
211 char * encName; 202 char *encName;
212 203
213 DEBUG_BEGIN(); 204 DEBUG_BEGIN ();
214 ncbe 205 ncbe = glade_xml_get_widget (getMainXML (), "searchNamespaceComboBoxEntry");
215 = glade_xml_get_widget(getMainXML(), 206 model = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (ncbe)));
216 "searchNamespaceComboBoxEntry"); 207 hash2enc (nni->namespaceId, &enc);
217 model = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(ncbe))); 208 if (nni->md == NULL)
218 hash2enc(nni->namespaceId, 209 {
219 &enc); 210 dmd = NULL;
220 if (nni->md == NULL) { 211 desc = STRDUP ("");
221 dmd = NULL; 212 }
222 desc = STRDUP(""); 213 else
223 } else { 214 {
224 dmd = ECRS_dupMetaData(nni->md); 215 dmd = ECRS_dupMetaData (nni->md);
225 desc = ECRS_getFirstFromMetaData(dmd, 216 desc = ECRS_getFirstFromMetaData (dmd,
226 EXTRACTOR_DESCRIPTION, 217 EXTRACTOR_DESCRIPTION,
227 EXTRACTOR_TITLE, 218 EXTRACTOR_TITLE,
228 EXTRACTOR_AUTHOR, 219 EXTRACTOR_AUTHOR,
229 EXTRACTOR_GENRE, 220 EXTRACTOR_GENRE,
230 EXTRACTOR_SUBJECT, 221 EXTRACTOR_SUBJECT,
231 EXTRACTOR_CREATOR, 222 EXTRACTOR_CREATOR,
232 EXTRACTOR_PRODUCER, 223 EXTRACTOR_PRODUCER,
233 EXTRACTOR_GROUP, 224 EXTRACTOR_GROUP,
234 EXTRACTOR_CREATED_FOR, 225 EXTRACTOR_CREATED_FOR,
235 EXTRACTOR_SUMMARY, 226 EXTRACTOR_SUMMARY,
236 EXTRACTOR_OWNER, 227 EXTRACTOR_OWNER, -1);
237 -1); 228 if (desc == NULL)
238 if (desc == NULL) 229 desc = STRDUP ("");
239 desc = STRDUP(""); 230 }
240 }
241 231
242 n = strlen(desc) + 64; 232 n = strlen (desc) + 64;
243 name = MALLOC(n); 233 name = MALLOC (n);
244 SNPRINTF(name, 234 SNPRINTF (name, n, "%s: %.*s", desc, 20, &enc);
245 n,
246 "%s: %.*s",
247 desc,
248 20,
249 &enc);
250 /* check if present! */ 235 /* check if present! */
251 found = NO; 236 found = NO;
252 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), 237 if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter))
253 &iter)) { 238 {
254 do { 239 do
255 gtk_tree_model_get(GTK_TREE_MODEL(model), 240 {
256 &iter, 241 gtk_tree_model_get (GTK_TREE_MODEL (model),
257 NS_SEARCH_ENCNAME, &encName, 242 &iter, NS_SEARCH_ENCNAME, &encName, -1);
258 -1); 243 if ((encName != NULL) &&
259 if ( (encName != NULL) && 244 (0 == strcmp (encName, (const char *) &enc)))
260 (0 == strcmp(encName, 245 found = YES;
261 (const char*) &enc)) ) 246 FREENONNULL (encName);
262 found =YES; 247 }
263 FREENONNULL(encName); 248 while ((found == NO) &&
264 } while ( (found == NO) && 249 (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter)));
265 (gtk_tree_model_iter_next(GTK_TREE_MODEL(model), 250 }
266 &iter)) ); 251 if (found == NO)
267 } 252 {
268 if (found == NO) { 253 infoMessage (YES, _("Namespace found: %s - %.*s\n"), desc, 20, &enc);
269 infoMessage(YES, 254 gtk_list_store_append (model, &iter);
270 _("Namespace found: %s - %.*s\n"), 255 gtk_list_store_set (model,
271 desc, 256 &iter,
272 20, 257 NS_SEARCH_DESCRIPTION, name,
273 &enc); 258 NS_SEARCH_ENCNAME, &enc,
274 gtk_list_store_append(model, 259 NS_SEARCH_METADATA, dmd,
275 &iter); 260 NS_SEARCH_RATING, nni->rating, -1);
276 gtk_list_store_set(model, 261 }
277 &iter, 262 FREE (name);
278 NS_SEARCH_DESCRIPTION, name, 263 DEBUG_END ();
279 NS_SEARCH_ENCNAME, &enc,
280 NS_SEARCH_METADATA, dmd,
281 NS_SEARCH_RATING, nni->rating,
282 -1);
283 }
284 FREE(name);
285 DEBUG_END();
286 264
287 return NULL; 265 return NULL;
288} 266}
@@ -299,17 +277,17 @@ static void * saveDiscovery(void * cls) {
299 * @param rating the local rating of the namespace 277 * @param rating the local rating of the namespace
300 * @return OK (always) 278 * @return OK (always)
301 */ 279 */
302int namespace_discovered_cb(void * cls, 280int
303 const char * namespaceName, 281namespace_discovered_cb (void *cls,
304 const HashCode512 * namespaceId, 282 const char *namespaceName,
305 const struct ECRS_MetaData * md, 283 const HashCode512 * namespaceId,
306 int rating) { 284 const struct ECRS_MetaData *md, int rating)
285{
307 struct NewNamespaceInfo nni; 286 struct NewNamespaceInfo nni;
308 nni.namespaceName = namespaceName; 287 nni.namespaceName = namespaceName;
309 nni.namespaceId = namespaceId; 288 nni.namespaceId = namespaceId;
310 nni.md = md; 289 nni.md = md;
311 nni.rating = rating; 290 nni.rating = rating;
312 gtkSaveCall(&saveDiscovery, 291 gtkSaveCall (&saveDiscovery, &nni);
313 &nni);
314 return OK; 292 return OK;
315} 293}
diff --git a/src/plugins/fs/namespace_search.h b/src/plugins/fs/namespace_search.h
index d2b7e463..fd85bb6c 100644
--- a/src/plugins/fs/namespace_search.h
+++ b/src/plugins/fs/namespace_search.h
@@ -36,11 +36,10 @@
36 * @param rating the local rating of the namespace 36 * @param rating the local rating of the namespace
37 * @return OK (always) 37 * @return OK (always)
38 */ 38 */
39int namespace_discovered_cb(void * cls, 39int namespace_discovered_cb (void *cls,
40 const char * namespaceName, 40 const char *namespaceName,
41 const HashCode512 * namespaceId, 41 const HashCode512 * namespaceId,
42 const struct ECRS_MetaData * md, 42 const struct ECRS_MetaData *md, int rating);
43 int rating);
44 43
45 44
46 45
diff --git a/src/plugins/fs/search.c b/src/plugins/fs/search.c
index bd28425e..dc9600f7 100644
--- a/src/plugins/fs/search.c
+++ b/src/plugins/fs/search.c
@@ -39,18 +39,18 @@
39 * The user has edited the search entry. 39 * The user has edited the search entry.
40 * Update search button status. 40 * Update search button status.
41 */ 41 */
42static void on_fssearchSelectionChanged(gpointer signal, 42static void
43 gpointer cls) { 43on_fssearchSelectionChanged (gpointer signal, gpointer cls)
44 SearchList * list = cls; 44{
45 GtkTreeSelection * selection; 45 SearchList *list = cls;
46 GtkWidget * downloadButton; 46 GtkTreeSelection *selection;
47 47 GtkWidget *downloadButton;
48 selection = gtk_tree_view_get_selection(list->treeview); 48
49 downloadButton 49 selection = gtk_tree_view_get_selection (list->treeview);
50 = glade_xml_get_widget(list->searchXML, 50 downloadButton = glade_xml_get_widget (list->searchXML, "downloadButton");
51 "downloadButton"); 51 gtk_widget_set_sensitive (downloadButton,
52 gtk_widget_set_sensitive(downloadButton, 52 gtk_tree_selection_count_selected_rows (selection)
53 gtk_tree_selection_count_selected_rows(selection) > 0); 53 > 0);
54} 54}
55 55
56 56
@@ -60,84 +60,86 @@ static void on_fssearchSelectionChanged(gpointer signal,
60 * Update the number of results received for the given 60 * Update the number of results received for the given
61 * search in the summary and in the label of the tab. 61 * search in the summary and in the label of the tab.
62 */ 62 */
63static void updateSearchSummary(SearchList * searchContext) { 63static void
64 GtkTreePath * path; 64updateSearchSummary (SearchList * searchContext)
65{
66 GtkTreePath *path;
65 GtkTreeIter iter; 67 GtkTreeIter iter;
66 char * new_title; 68 char *new_title;
67 GtkLabel * label; 69 GtkLabel *label;
68 70
69 path = gtk_tree_row_reference_get_path(searchContext->summaryViewRowReference); 71 path =
70 if (TRUE != gtk_tree_model_get_iter(GTK_TREE_MODEL(search_summary), 72 gtk_tree_row_reference_get_path (searchContext->summaryViewRowReference);
71 &iter, 73 if (TRUE !=
72 path)) { 74 gtk_tree_model_get_iter (GTK_TREE_MODEL (search_summary), &iter, path))
73 GE_BREAK(ectx, 0); 75 {
74 return; 76 GE_BREAK (ectx, 0);
75 } 77 return;
76 gtk_tree_path_free(path); 78 }
77 gtk_list_store_set(search_summary, 79 gtk_tree_path_free (path);
78 &iter, 80 gtk_list_store_set (search_summary,
79 SEARCH_SUMMARY_RESULT_COUNT, searchContext->resultsReceived, 81 &iter,
80 -1); 82 SEARCH_SUMMARY_RESULT_COUNT,
83 searchContext->resultsReceived, -1);
84
81 85
82
83 86
84 /* update tab title with the number of results */ 87 /* update tab title with the number of results */
85 new_title = 88 new_title =
86 g_strdup_printf("%.*s%s (%u)", 89 g_strdup_printf ("%.*s%s (%u)",
87 20, 90 20,
88 searchContext->searchString, 91 searchContext->searchString,
89 strlen(searchContext->searchString) > 20 ? "..." : "", 92 strlen (searchContext->searchString) > 20 ? "..." : "",
90 searchContext->resultsReceived); 93 searchContext->resultsReceived);
91 label = GTK_LABEL(glade_xml_get_widget(searchContext->labelXML, 94 label = GTK_LABEL (glade_xml_get_widget (searchContext->labelXML,
92 "searchTabLabel")); 95 "searchTabLabel"));
93 gtk_label_set(label, new_title); 96 gtk_label_set (label, new_title);
94 FREE(new_title); 97 FREE (new_title);
95} 98}
96 99
97/** 100/**
98 * Add the given search result to the search 101 * Add the given search result to the search
99 * tree at the specified position. 102 * tree at the specified position.
100 */ 103 */
101void addEntryToSearchTree(SearchList * searchContext, 104void
102 DownloadList * downloadParent, 105addEntryToSearchTree (SearchList * searchContext,
103 const ECRS_FileInfo * info, 106 DownloadList * downloadParent,
104 GtkTreeIter * iter) { 107 const ECRS_FileInfo * info, GtkTreeIter * iter)
105 char * name; 108{
106 char * mime; 109 char *name;
107 char * desc; 110 char *mime;
111 char *desc;
108 unsigned long long size; 112 unsigned long long size;
109 char * size_h; 113 char *size_h;
110 GdkPixbuf * pixbuf; 114 GdkPixbuf *pixbuf;
111 enum URITRACK_STATE state; 115 enum URITRACK_STATE state;
112 116
113 state = URITRACK_getState(ectx, 117 state = URITRACK_getState (ectx, cfg, info->uri);
114 cfg, 118 mime = getMimeTypeFromMetaData (info->meta);
115 info->uri); 119 desc = getDescriptionFromMetaData (info->meta);
116 mime = getMimeTypeFromMetaData(info->meta); 120 name = getFileNameFromMetaData (info->meta);
117 desc = getDescriptionFromMetaData(info->meta); 121 size = ECRS_isFileUri (info->uri)
118 name = getFileNameFromMetaData(info->meta); 122 || ECRS_isLocationUri (info->uri) ? ECRS_fileSize (info->uri) : 0;
119 size = ECRS_isFileUri(info->uri) || ECRS_isLocationUri(info->uri) ? ECRS_fileSize(info->uri) : 0; 123 pixbuf = getThumbnailFromMetaData (info->meta);
120 pixbuf = getThumbnailFromMetaData(info->meta); 124 size_h = string_get_fancy_byte_size (size);
121 size_h = string_get_fancy_byte_size(size); 125 gtk_tree_store_set (searchContext->tree,
122 gtk_tree_store_set(searchContext->tree, 126 iter,
123 iter, 127 SEARCH_NAME, name,
124 SEARCH_NAME, name, 128 SEARCH_SIZE, size,
125 SEARCH_SIZE, size, 129 SEARCH_HSIZE, size_h,
126 SEARCH_HSIZE, size_h, 130 SEARCH_MIME, mime,
127 SEARCH_MIME, mime, 131 SEARCH_DESC, desc,
128 SEARCH_DESC, desc, 132 SEARCH_PIXBUF, pixbuf,
129 SEARCH_PIXBUF, pixbuf, 133 SEARCH_URI, ECRS_dupUri (info->uri),
130 SEARCH_URI, ECRS_dupUri(info->uri), 134 SEARCH_META, ECRS_dupMetaData (info->meta),
131 SEARCH_META, ECRS_dupMetaData(info->meta), 135 SEARCH_CELL_BG_COLOR, getColorCode (state),
132 SEARCH_CELL_BG_COLOR, getColorCode(state), 136 SEARCH_CELL_FG_COLOR, "black",
133 SEARCH_CELL_FG_COLOR, "black", 137 SEARCH_INTERNAL, searchContext,
134 SEARCH_INTERNAL, searchContext, 138 SEARCH_INTERNAL_PARENT, downloadParent, -1);
135 SEARCH_INTERNAL_PARENT, downloadParent, 139 FREE (size_h);
136 -1); 140 FREE (name);
137 FREE(size_h); 141 FREE (desc);
138 FREE(name); 142 FREE (mime);
139 FREE(desc);
140 FREE(mime);
141} 143}
142 144
143/** 145/**
@@ -148,202 +150,173 @@ void addEntryToSearchTree(SearchList * searchContext,
148 * @param uri the search URI 150 * @param uri the search URI
149 * @param searchContext identifies the search page 151 * @param searchContext identifies the search page
150 */ 152 */
151void fs_search_result_received(SearchList * searchContext, 153void
152 const ECRS_FileInfo * info, 154fs_search_result_received (SearchList * searchContext,
153 const struct ECRS_URI * uri) { 155 const ECRS_FileInfo * info,
154 GtkTreeStore * model; 156 const struct ECRS_URI *uri)
157{
158 GtkTreeStore *model;
155 GtkTreeIter iter; 159 GtkTreeIter iter;
156 enum URITRACK_STATE state; 160 enum URITRACK_STATE state;
157 161
158 state = URITRACK_getState(ectx, 162 state = URITRACK_getState (ectx, cfg, info->uri);
159 cfg, 163 if ((state & (URITRACK_INSERTED |
160 info->uri); 164 URITRACK_INDEXED)) &&
161 if ( (state & (URITRACK_INSERTED | 165 (YES == GC_get_configuration_value_yesno (cfg,
162 URITRACK_INDEXED) ) && 166 "GNUNET-GTK",
163 (YES == GC_get_configuration_value_yesno(cfg, 167 "DISABLE-OWN", YES)))
164 "GNUNET-GTK",
165 "DISABLE-OWN",
166 YES)) )
167 return; 168 return;
168 model = GTK_TREE_STORE(gtk_tree_view_get_model(searchContext->treeview)); 169 model = GTK_TREE_STORE (gtk_tree_view_get_model (searchContext->treeview));
169 gtk_tree_store_append(model, 170 gtk_tree_store_append (model, &iter, NULL);
170 &iter, 171 addEntryToSearchTree (searchContext, NULL, info, &iter);
171 NULL);
172 addEntryToSearchTree(searchContext,
173 NULL,
174 info,
175 &iter);
176 searchContext->resultsReceived++; 172 searchContext->resultsReceived++;
177 updateSearchSummary(searchContext); 173 updateSearchSummary (searchContext);
178} 174}
179 175
180static int 176static int
181on_search_copy_uri_activate(void * cls, 177on_search_copy_uri_activate (void *cls, GtkWidget * searchEntry)
182 GtkWidget * searchEntry) { 178{
183 SearchList * list = cls; 179 SearchList *list = cls;
184 GtkTreePath *path; 180 GtkTreePath *path;
185 GtkTreeIter iter; 181 GtkTreeIter iter;
186 struct ECRS_URI * uri; 182 struct ECRS_URI *uri;
187 char * str; 183 char *str;
188 GtkClipboard * clip; 184 GtkClipboard *clip;
189 185
190 path = NULL; 186 path = NULL;
191 if (FALSE == gtk_tree_view_get_path_at_pos(list->treeview, 187 if (FALSE == gtk_tree_view_get_path_at_pos (list->treeview,
192 list->last_x, 188 list->last_x,
193 list->last_y, 189 list->last_y,
194 &path, 190 &path, NULL, NULL, NULL))
195 NULL, 191 {
196 NULL, 192 GE_BREAK (NULL, 0);
197 NULL)) { 193 return FALSE;
198 GE_BREAK(NULL, 0); 194 }
199 return FALSE; 195 if (FALSE == gtk_tree_model_get_iter (GTK_TREE_MODEL (list->tree),
200 } 196 &iter, path))
201 if (FALSE == gtk_tree_model_get_iter(GTK_TREE_MODEL(list->tree), 197 {
202 &iter, 198 GE_BREAK (NULL, 0);
203 path)) { 199 gtk_tree_path_free (path);
204 GE_BREAK(NULL, 0); 200 return FALSE;
205 gtk_tree_path_free(path); 201 }
206 return FALSE; 202 gtk_tree_path_free (path);
207 }
208 gtk_tree_path_free(path);
209 uri = NULL; 203 uri = NULL;
210 gtk_tree_model_get(GTK_TREE_MODEL(list->tree), 204 gtk_tree_model_get (GTK_TREE_MODEL (list->tree),
211 &iter, 205 &iter, SEARCH_URI, &uri, -1);
212 SEARCH_URI, &uri, 206 str = ECRS_uriToString (uri);
213 -1); 207 clip = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
214 str = ECRS_uriToString(uri); 208 gtk_clipboard_set_text (clip, str, strlen (str));
215 clip = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); 209 FREE (str);
216 gtk_clipboard_set_text(clip,
217 str,
218 strlen(str));
219 FREE(str);
220 return FALSE; 210 return FALSE;
221} 211}
222 212
223 213
224#ifndef MINGW 214#ifndef MINGW
225static char * 215static char *
226selectFile() { 216selectFile ()
227 GladeXML * uploadXML; 217{
228 GtkFileChooser * dialog; 218 GladeXML *uploadXML;
229 char * ret; 219 GtkFileChooser *dialog;
220 char *ret;
230 221
231 uploadXML 222 uploadXML
232 = glade_xml_new(getGladeFileName(), 223 = glade_xml_new (getGladeFileName (),
233 "directorySaveDialog", 224 "directorySaveDialog", PACKAGE_NAME);
234 PACKAGE_NAME); 225 connectGladeWithPlugins (uploadXML);
235 connectGladeWithPlugins(uploadXML); 226 dialog = GTK_FILE_CHOOSER (glade_xml_get_widget (uploadXML,
236 dialog = GTK_FILE_CHOOSER(glade_xml_get_widget(uploadXML, 227 "directorySaveDialog"));
237 "directorySaveDialog")); 228 if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_CANCEL)
238 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL) 229 ret = gtk_file_chooser_get_filename (dialog);
239 ret = gtk_file_chooser_get_filename(dialog);
240 else 230 else
241 ret = NULL; 231 ret = NULL;
242 gtk_widget_destroy(GTK_WIDGET(dialog)); 232 gtk_widget_destroy (GTK_WIDGET (dialog));
243 UNREF(uploadXML); 233 UNREF (uploadXML);
244 return ret; 234 return ret;
245} 235}
246 236
247#else /* MINGW */ 237#else /* MINGW */
248 238
249static char * 239static char *
250selectFile() { 240selectFile ()
251 return plibc_ChooseFile(_("Choose the name under which you want to save the search results."), 241{
252 OFN_SHAREAWARE); 242 return
243 plibc_ChooseFile (_
244 ("Choose the name under which you want to save the search results."),
245 OFN_SHAREAWARE);
253} 246}
254#endif /* MINGW */ 247#endif /* MINGW */
255 248
256static int 249static int
257on_save_search_activate(void * cls, 250on_save_search_activate (void *cls, GtkWidget * searchEntry)
258 GtkWidget * searchEntry) { 251{
259 SearchList * list = cls; 252 SearchList *list = cls;
260 char * name; 253 char *name;
261 char * directory; 254 char *directory;
262 unsigned long long dir_len; 255 unsigned long long dir_len;
263 unsigned int fis_size; 256 unsigned int fis_size;
264 ECRS_FileInfo * fis; 257 ECRS_FileInfo *fis;
265 struct ECRS_MetaData * meta; 258 struct ECRS_MetaData *meta;
266 GtkTreeModel * model; 259 GtkTreeModel *model;
267 GtkTreeIter iter; 260 GtkTreeIter iter;
268 unsigned int pos; 261 unsigned int pos;
269 262
270 model = gtk_tree_view_get_model(list->treeview); 263 model = gtk_tree_view_get_model (list->treeview);
271 if (TRUE != gtk_tree_model_get_iter_first(model, &iter)) { 264 if (TRUE != gtk_tree_model_get_iter_first (model, &iter))
272 addLogEntry(_("No search results yet, cannot save!")); 265 {
273 return FALSE; 266 addLogEntry (_("No search results yet, cannot save!"));
274 } 267 return FALSE;
268 }
275 269
276 name = selectFile(""); 270 name = selectFile ("");
277 if (name == NULL) 271 if (name == NULL)
278 return FALSE; 272 return FALSE;
279 fis = NULL; 273 fis = NULL;
280 fis_size = 0; 274 fis_size = 0;
281 GROW(fis, 275 GROW (fis, fis_size, list->resultsReceived);
282 fis_size,
283 list->resultsReceived);
284 pos = 0; 276 pos = 0;
285 do { 277 do
286 if (pos == fis_size) 278 {
287 GROW(fis, 279 if (pos == fis_size)
288 fis_size, 280 GROW (fis, fis_size, pos + 1);
289 pos + 1); 281 gtk_tree_model_get (model,
290 gtk_tree_model_get(model, 282 &iter,
291 &iter, 283 SEARCH_URI, &fis[pos].uri,
292 SEARCH_URI, &fis[pos].uri, 284 SEARCH_META, &fis[pos].meta, -1);
293 SEARCH_META, &fis[pos].meta, 285 pos++;
294 -1); 286 }
295 pos++; 287 while (gtk_tree_model_iter_next (model, &iter));
296 } while (gtk_tree_model_iter_next(model, 288 meta = ECRS_createMetaData ();
297 &iter)); 289 ECRS_addToMetaData (meta, EXTRACTOR_KEYWORDS, list->searchString);
298 meta = ECRS_createMetaData(); 290 ECRS_addToMetaData (meta, EXTRACTOR_DESCRIPTION, _("Saved search results"));
299 ECRS_addToMetaData(meta, 291 ECRS_addToMetaData (meta, EXTRACTOR_SOFTWARE, "gnunet-gtk");
300 EXTRACTOR_KEYWORDS, 292 if (OK != ECRS_createDirectory (NULL,
301 list->searchString); 293 &directory, &dir_len, fis_size, fis, meta))
302 ECRS_addToMetaData(meta, 294 {
303 EXTRACTOR_DESCRIPTION, 295 addLogEntry (_("Internal error."));
304 _("Saved search results")); 296 GE_BREAK (NULL, 0);
305 ECRS_addToMetaData(meta, 297 ECRS_freeMetaData (meta);
306 EXTRACTOR_SOFTWARE, 298 GROW (fis, fis_size, 0);
307 "gnunet-gtk"); 299 FREE (name);
308 if (OK != ECRS_createDirectory(NULL, 300 return FALSE;
309 &directory, 301 }
310 &dir_len, 302 ECRS_freeMetaData (meta);
311 fis_size, 303 GROW (fis, fis_size, 0);
312 fis, 304 if (OK != disk_file_write (NULL, name, directory, dir_len, "644"))
313 meta)) { 305 {
314 addLogEntry(_("Internal error.")); 306 addLogEntry (_("Error writing file `%s'."), name);
315 GE_BREAK(NULL, 0); 307 }
316 ECRS_freeMetaData(meta); 308 FREE (directory);
317 GROW(fis, 309 FREE (name);
318 fis_size,
319 0);
320 FREE(name);
321 return FALSE;
322 }
323 ECRS_freeMetaData(meta);
324 GROW(fis,
325 fis_size,
326 0);
327 if (OK != disk_file_write(NULL,
328 name,
329 directory,
330 dir_len,
331 "644")) {
332 addLogEntry(_("Error writing file `%s'."),
333 name);
334 }
335 FREE(directory);
336 FREE(name);
337 return FALSE; 310 return FALSE;
338} 311}
339 312
340static gint 313static gint
341search_click_handler(void * cls, 314search_click_handler (void *cls, GdkEvent * event)
342 GdkEvent *event) { 315{
343 SearchList * list = cls; 316 SearchList *list = cls;
344 GtkMenu * menu; 317 GtkMenu *menu;
345 GtkWidget * entry; 318 GtkWidget *entry;
346 GdkEventButton * event_button; 319 GdkEventButton *event_button;
347 320
348 g_return_val_if_fail (event != NULL, FALSE); 321 g_return_val_if_fail (event != NULL, FALSE);
349 322
@@ -354,34 +327,26 @@ search_click_handler(void * cls,
354 return FALSE; 327 return FALSE;
355 list->last_x = event_button->x; 328 list->last_x = event_button->x;
356 list->last_y = event_button->y; 329 list->last_y = event_button->y;
357 menu = GTK_MENU(gtk_menu_new()); 330 menu = GTK_MENU (gtk_menu_new ());
358 entry = gtk_menu_item_new_with_label(_("_Copy URI to Clipboard")); 331 entry = gtk_menu_item_new_with_label (_("_Copy URI to Clipboard"));
359 g_signal_connect_swapped (entry, 332 g_signal_connect_swapped (entry,
360 "activate", 333 "activate",
361 G_CALLBACK(on_search_copy_uri_activate), 334 G_CALLBACK (on_search_copy_uri_activate), list);
362 list); 335 gtk_label_set_use_underline (GTK_LABEL
363 gtk_label_set_use_underline(GTK_LABEL(gtk_bin_get_child(GTK_BIN(entry))), 336 (gtk_bin_get_child (GTK_BIN (entry))), TRUE);
364 TRUE); 337 gtk_widget_show (entry);
365 gtk_widget_show(entry); 338 gtk_menu_shell_append (GTK_MENU_SHELL (menu), entry);
366 gtk_menu_shell_append(GTK_MENU_SHELL(menu), 339 entry = gtk_menu_item_new_with_label (_("_Save results as directory"));
367 entry);
368 entry = gtk_menu_item_new_with_label(_("_Save results as directory"));
369 g_signal_connect_swapped (entry, 340 g_signal_connect_swapped (entry,
370 "activate", 341 "activate",
371 G_CALLBACK(on_save_search_activate), 342 G_CALLBACK (on_save_search_activate), list);
372 list); 343 gtk_label_set_use_underline (GTK_LABEL
373 gtk_label_set_use_underline(GTK_LABEL(gtk_bin_get_child(GTK_BIN(entry))), 344 (gtk_bin_get_child (GTK_BIN (entry))), TRUE);
374 TRUE); 345 gtk_widget_show (entry);
375 gtk_widget_show(entry); 346 gtk_menu_shell_append (GTK_MENU_SHELL (menu), entry);
376 gtk_menu_shell_append(GTK_MENU_SHELL(menu),
377 entry);
378 gtk_menu_popup (menu, 347 gtk_menu_popup (menu,
379 NULL, 348 NULL,
380 NULL, 349 NULL, NULL, NULL, event_button->button, event_button->time);
381 NULL,
382 NULL,
383 event_button->button,
384 event_button->time);
385 return TRUE; 350 return TRUE;
386} 351}
387 352
@@ -390,234 +355,195 @@ search_click_handler(void * cls,
390 * tab and add an entry to the summary. 355 * tab and add an entry to the summary.
391 */ 356 */
392SearchList * 357SearchList *
393fs_search_started(struct FSUI_SearchList * fsui_list, 358fs_search_started (struct FSUI_SearchList * fsui_list,
394 const struct ECRS_URI * uri, 359 const struct ECRS_URI * uri,
395 unsigned int anonymityLevel, 360 unsigned int anonymityLevel,
396 unsigned int resultCount, 361 unsigned int resultCount,
397 const ECRS_FileInfo * results, 362 const ECRS_FileInfo * results, FSUI_State state)
398 FSUI_State state) { 363{
399 SearchList * list; 364 SearchList *list;
400 gint pages; 365 gint pages;
401 char * description; 366 char *description;
402 const char * dhead; 367 const char *dhead;
403 GtkTreeViewColumn * column; 368 GtkTreeViewColumn *column;
404 GtkCellRenderer * renderer; 369 GtkCellRenderer *renderer;
405 GtkNotebook * notebook; 370 GtkNotebook *notebook;
406 GtkTreePath * path; 371 GtkTreePath *path;
407 GtkTreeIter iter; 372 GtkTreeIter iter;
408 int col; 373 int col;
409 int i; 374 int i;
410 375
411 description = ECRS_uriToString(uri); 376 description = ECRS_uriToString (uri);
412 if (description == NULL) { 377 if (description == NULL)
413 GE_BREAK(ectx, 0); 378 {
414 return NULL; 379 GE_BREAK (ectx, 0);
415 } 380 return NULL;
416 GE_ASSERT(ectx, 381 }
417 strlen(description) >= strlen(ECRS_URI_PREFIX)); 382 GE_ASSERT (ectx, strlen (description) >= strlen (ECRS_URI_PREFIX));
418 dhead = &description[strlen(ECRS_URI_PREFIX)]; 383 dhead = &description[strlen (ECRS_URI_PREFIX)];
419 if (0 == strncmp(dhead, 384 if (0 == strncmp (dhead, ECRS_SEARCH_INFIX, strlen (ECRS_SEARCH_INFIX)))
420 ECRS_SEARCH_INFIX, 385 dhead = &dhead[strlen (ECRS_SEARCH_INFIX)];
421 strlen(ECRS_SEARCH_INFIX))) 386 else if (0 == strncmp (dhead,
422 dhead = &dhead[strlen(ECRS_SEARCH_INFIX)]; 387 ECRS_SUBSPACE_INFIX, strlen (ECRS_SUBSPACE_INFIX)))
423 else if (0 == strncmp(dhead, 388 dhead = &dhead[strlen (ECRS_SUBSPACE_INFIX)];
424 ECRS_SUBSPACE_INFIX, 389 list = MALLOC (sizeof (SearchList));
425 strlen(ECRS_SUBSPACE_INFIX))) 390 memset (list, 0, sizeof (SearchList));
426 dhead = &dhead[strlen(ECRS_SUBSPACE_INFIX)]; 391 list->searchString = STRDUP (dhead);
427 list 392 list->uri = ECRS_dupUri (uri);
428 = MALLOC(sizeof(SearchList)); 393 list->fsui_list = fsui_list;
429 memset(list, 394 list->next = search_head;
430 0,
431 sizeof(SearchList));
432 list->searchString
433 = STRDUP(dhead);
434 list->uri
435 = ECRS_dupUri(uri);
436 list->fsui_list
437 = fsui_list;
438 list->next
439 = search_head;
440 search_head = list; 395 search_head = list;
441 list->searchXML 396 list->searchXML
442 = glade_xml_new(getGladeFileName(), 397 = glade_xml_new (getGladeFileName (), "searchResultsFrame", PACKAGE_NAME);
443 "searchResultsFrame", 398 connectGladeWithPlugins (list->searchXML);
444 PACKAGE_NAME);
445 connectGladeWithPlugins(list->searchXML);
446 list->searchpage 399 list->searchpage
447 = extractMainWidgetFromWindow(list->searchXML, 400 = extractMainWidgetFromWindow (list->searchXML, "searchResultsFrame");
448 "searchResultsFrame");
449 /* setup tree view and renderers */ 401 /* setup tree view and renderers */
450 list->treeview = GTK_TREE_VIEW(glade_xml_get_widget(list->searchXML, 402 list->treeview = GTK_TREE_VIEW (glade_xml_get_widget (list->searchXML,
451 "searchResults")); 403 "searchResults"));
452 g_signal_connect_swapped (list->treeview, 404 g_signal_connect_swapped (list->treeview,
453 "button-press-event", 405 "button-press-event",
454 G_CALLBACK(search_click_handler), 406 G_CALLBACK (search_click_handler), list);
455 list); 407 list->tree = gtk_tree_store_new (SEARCH_NUM, G_TYPE_STRING, /* name */
456 list->tree = 408 G_TYPE_UINT64, /* size */
457 gtk_tree_store_new(SEARCH_NUM, 409 G_TYPE_STRING, /* human-readable size */
458 G_TYPE_STRING, /* name */ 410 G_TYPE_STRING, /* mime-type */
459 G_TYPE_UINT64, /* size */ 411 G_TYPE_STRING, /* meta-data (some) */
460 G_TYPE_STRING, /* human-readable size */ 412 GDK_TYPE_PIXBUF, /* preview */
461 G_TYPE_STRING, /* mime-type */ 413 G_TYPE_POINTER, /* url */
462 G_TYPE_STRING, /* meta-data (some) */ 414 G_TYPE_POINTER, /* meta */
463 GDK_TYPE_PIXBUF, /* preview */ 415 G_TYPE_STRING, /* bg-color */
464 G_TYPE_POINTER, /* url */ 416 G_TYPE_STRING, /* fg-color */
465 G_TYPE_POINTER, /* meta */ 417 G_TYPE_POINTER, /* internal: search list */
466 G_TYPE_STRING, /* bg-color */ 418 G_TYPE_POINTER); /* internal: download parent list */
467 G_TYPE_STRING, /* fg-color */ 419
468 G_TYPE_POINTER, /* internal: search list */ 420 gtk_tree_view_set_model (list->treeview, GTK_TREE_MODEL (list->tree));
469 G_TYPE_POINTER); /* internal: download parent list */ 421 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (list->treeview),
470 422 GTK_SELECTION_MULTIPLE);
471 gtk_tree_view_set_model(list->treeview, 423
472 GTK_TREE_MODEL(list->tree)); 424 g_signal_connect_data (gtk_tree_view_get_selection (list->treeview),
473 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(list->treeview), 425 "changed",
474 GTK_SELECTION_MULTIPLE); 426 G_CALLBACK (&on_fssearchSelectionChanged),
475 427 list, NULL, 0);
476 g_signal_connect_data(gtk_tree_view_get_selection(list->treeview), 428 renderer = gtk_cell_renderer_text_new ();
477 "changed", 429 col = gtk_tree_view_insert_column_with_attributes (list->treeview,
478 G_CALLBACK(&on_fssearchSelectionChanged), 430 -1,
479 list, 431 _("Name"),
480 NULL, 432 renderer,
481 0); 433 "text", SEARCH_NAME,
482 renderer = gtk_cell_renderer_text_new(); 434 NULL);
483 col = gtk_tree_view_insert_column_with_attributes(list->treeview, 435 g_object_set (G_OBJECT (renderer),
484 -1, 436 "wrap-width", 45,
485 _("Name"), 437 "width-chars", 45, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
486 renderer, 438 column = gtk_tree_view_get_column (list->treeview, col - 1);
487 "text", SEARCH_NAME, 439 gtk_tree_view_column_set_resizable (column, TRUE);
488 NULL); 440 gtk_tree_view_column_set_clickable (column, TRUE);
489 g_object_set(G_OBJECT(renderer), 441 gtk_tree_view_column_set_reorderable (column, TRUE);
490 "wrap-width", 45, 442 gtk_tree_view_column_set_sort_column_id (column, SEARCH_NAME);
491 "width-chars", 45, 443
492 "ellipsize", PANGO_ELLIPSIZE_END, 444 renderer = gtk_cell_renderer_text_new ();
493 NULL);
494 column = gtk_tree_view_get_column(list->treeview,
495 col - 1);
496 gtk_tree_view_column_set_resizable(column, TRUE);
497 gtk_tree_view_column_set_clickable(column, TRUE);
498 gtk_tree_view_column_set_reorderable(column, TRUE);
499 gtk_tree_view_column_set_sort_column_id(column, SEARCH_NAME);
500
501 renderer = gtk_cell_renderer_text_new();
502 g_object_set (renderer, "xalign", 1.00, NULL); 445 g_object_set (renderer, "xalign", 1.00, NULL);
503 col = gtk_tree_view_insert_column_with_attributes(list->treeview, 446 col = gtk_tree_view_insert_column_with_attributes (list->treeview,
504 -1, 447 -1,
505 _("Size"), 448 _("Size"),
506 renderer, 449 renderer,
507 "text", SEARCH_HSIZE, 450 "text", SEARCH_HSIZE,
508 "cell-background", SEARCH_CELL_BG_COLOR, 451 "cell-background",
509 "foreground", SEARCH_CELL_FG_COLOR, 452 SEARCH_CELL_BG_COLOR,
510 NULL); 453 "foreground",
511 column = gtk_tree_view_get_column(list->treeview, 454 SEARCH_CELL_FG_COLOR,
512 col - 1); 455 NULL);
513 gtk_tree_view_column_set_resizable(column, TRUE); 456 column = gtk_tree_view_get_column (list->treeview, col - 1);
514 gtk_tree_view_column_set_clickable(column, TRUE); 457 gtk_tree_view_column_set_resizable (column, TRUE);
515 gtk_tree_view_column_set_reorderable(column, TRUE); 458 gtk_tree_view_column_set_clickable (column, TRUE);
516 gtk_tree_view_column_set_sort_column_id(column, SEARCH_SIZE); 459 gtk_tree_view_column_set_reorderable (column, TRUE);
517 460 gtk_tree_view_column_set_sort_column_id (column, SEARCH_SIZE);
518 renderer = gtk_cell_renderer_text_new(); 461
519 col = gtk_tree_view_insert_column_with_attributes(list->treeview, 462 renderer = gtk_cell_renderer_text_new ();
520 -1, 463 col = gtk_tree_view_insert_column_with_attributes (list->treeview,
521 _("Mime-type"), 464 -1,
522 renderer, 465 _("Mime-type"),
523 "text", SEARCH_MIME, 466 renderer,
524 NULL); 467 "text", SEARCH_MIME,
525 g_object_set(G_OBJECT(renderer), 468 NULL);
526 "wrap-width", 30, 469 g_object_set (G_OBJECT (renderer),
527 "width-chars", 30, 470 "wrap-width", 30,
528 "ellipsize", PANGO_ELLIPSIZE_END, 471 "width-chars", 30, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
529 NULL); 472 column = gtk_tree_view_get_column (list->treeview, col - 1);
530 column = gtk_tree_view_get_column(list->treeview, 473 gtk_tree_view_column_set_resizable (column, TRUE);
531 col - 1); 474 gtk_tree_view_column_set_clickable (column, TRUE);
532 gtk_tree_view_column_set_resizable(column, TRUE); 475 gtk_tree_view_column_set_reorderable (column, TRUE);
533 gtk_tree_view_column_set_clickable(column, TRUE); 476 gtk_tree_view_column_set_sort_column_id (column, SEARCH_MIME);
534 gtk_tree_view_column_set_reorderable(column, TRUE); 477
535 gtk_tree_view_column_set_sort_column_id(column, SEARCH_MIME); 478 if (YES != GC_get_configuration_value_yesno (cfg,
536 479 "GNUNET-GTK",
537 if (YES != GC_get_configuration_value_yesno(cfg, 480 "DISABLE-PREVIEWS", NO))
538 "GNUNET-GTK", 481 {
539 "DISABLE-PREVIEWS", 482 renderer = gtk_cell_renderer_pixbuf_new ();
540 NO)) { 483 col = gtk_tree_view_insert_column_with_attributes (list->treeview,
541 renderer = gtk_cell_renderer_pixbuf_new(); 484 -1,
542 col = gtk_tree_view_insert_column_with_attributes(list->treeview, 485 _("Preview"),
543 -1, 486 renderer,
544 _("Preview"), 487 "pixbuf",
545 renderer, 488 SEARCH_PIXBUF, NULL);
546 "pixbuf", SEARCH_PIXBUF, 489 column = gtk_tree_view_get_column (list->treeview, col - 1);
547 NULL); 490 gtk_tree_view_column_set_resizable (column, TRUE);
548 column = gtk_tree_view_get_column(list->treeview, 491 gtk_tree_view_column_set_reorderable (column, TRUE);
549 col - 1); 492 gtk_tree_view_column_set_resizable (column, TRUE);
550 gtk_tree_view_column_set_resizable(column, TRUE); 493 }
551 gtk_tree_view_column_set_reorderable(column, TRUE); 494
552 gtk_tree_view_column_set_resizable(column, TRUE); 495 renderer = gtk_cell_renderer_text_new ();
553 } 496 col = gtk_tree_view_insert_column_with_attributes (list->treeview,
554 497 -1,
555 renderer = gtk_cell_renderer_text_new(); 498 _("Meta-data"),
556 col = gtk_tree_view_insert_column_with_attributes(list->treeview, 499 renderer,
557 -1, 500 "text", SEARCH_DESC,
558 _("Meta-data"), 501 NULL);
559 renderer, 502 column = gtk_tree_view_get_column (list->treeview, col - 1);
560 "text", SEARCH_DESC, 503 g_object_set (G_OBJECT (renderer),
561 NULL); 504 "wrap-width", 60,
562 column = gtk_tree_view_get_column(list->treeview, 505 "width-chars", 60,
563 col - 1); 506 "wrap-mode", PANGO_WRAP_WORD_CHAR,
564 g_object_set(G_OBJECT(renderer), 507 "ellipsize", PANGO_ELLIPSIZE_END,
565 "wrap-width", 60, 508 "ellipsize-set", TRUE, NULL);
566 "width-chars", 60, 509 gtk_tree_view_column_set_resizable (column, TRUE);
567 "wrap-mode", PANGO_WRAP_WORD_CHAR, 510 gtk_tree_view_column_set_clickable (column, TRUE);
568 "ellipsize", PANGO_ELLIPSIZE_END, 511 gtk_tree_view_column_set_reorderable (column, TRUE);
569 "ellipsize-set", TRUE, 512 gtk_tree_view_column_set_sort_column_id (column, SEARCH_DESC);
570 NULL);
571 gtk_tree_view_column_set_resizable(column, TRUE);
572 gtk_tree_view_column_set_clickable(column, TRUE);
573 gtk_tree_view_column_set_reorderable(column, TRUE);
574 gtk_tree_view_column_set_sort_column_id(column, SEARCH_DESC);
575 513
576 /* add entry in search summary */ 514 /* add entry in search summary */
577 gtk_list_store_append(search_summary, 515 gtk_list_store_append (search_summary, &iter);
578 &iter); 516 gtk_list_store_set (search_summary,
579 gtk_list_store_set(search_summary, 517 &iter,
580 &iter, 518 SEARCH_SUMMARY_NAME, dhead,
581 SEARCH_SUMMARY_NAME, dhead, 519 SEARCH_SUMMARY_RESULT_COUNT, 0,
582 SEARCH_SUMMARY_RESULT_COUNT, 0, 520 SEARCH_SUMMARY_INTERNAL, list, -1);
583 SEARCH_SUMMARY_INTERNAL, list, 521 FREE (description);
584 -1); 522 path = gtk_tree_model_get_path (GTK_TREE_MODEL (search_summary), &iter);
585 FREE(description);
586 path = gtk_tree_model_get_path(GTK_TREE_MODEL(search_summary),
587 &iter);
588 list->summaryViewRowReference 523 list->summaryViewRowReference
589 = gtk_tree_row_reference_new(GTK_TREE_MODEL(search_summary), 524 = gtk_tree_row_reference_new (GTK_TREE_MODEL (search_summary), path);
590 path); 525 gtk_tree_path_free (path);
591 gtk_tree_path_free(path);
592 526
593 /* load label */ 527 /* load label */
594 list->labelXML 528 list->labelXML
595 = glade_xml_new(getGladeFileName(), 529 = glade_xml_new (getGladeFileName (),
596 "searchTabLabelWindow", 530 "searchTabLabelWindow", PACKAGE_NAME);
597 PACKAGE_NAME); 531 connectGladeWithPlugins (list->labelXML);
598 connectGladeWithPlugins(list->labelXML);
599 list->tab_label 532 list->tab_label
600 = extractMainWidgetFromWindow(list->labelXML, 533 = extractMainWidgetFromWindow (list->labelXML, "searchTabLabelWindow");
601 "searchTabLabelWindow");
602 /* process existing results */ 534 /* process existing results */
603 for (i=0;i<resultCount;i++) 535 for (i = 0; i < resultCount; i++)
604 fs_search_result_received(list, 536 fs_search_result_received (list, &results[i], uri);
605 &results[i], 537 if (resultCount == 0) /* otherwise already done! */
606 uri); 538 updateSearchSummary (list);
607 if (resultCount == 0) /* otherwise already done! */
608 updateSearchSummary(list);
609 539
610 /* insert new page into search notebook */ 540 /* insert new page into search notebook */
611 notebook 541 notebook
612 = GTK_NOTEBOOK(glade_xml_get_widget(getMainXML(), 542 = GTK_NOTEBOOK (glade_xml_get_widget (getMainXML (), "downloadNotebook"));
613 "downloadNotebook")); 543 pages = gtk_notebook_get_n_pages (GTK_NOTEBOOK (notebook));
614 pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook)); 544 gtk_notebook_append_page (notebook, list->searchpage, list->tab_label);
615 gtk_notebook_append_page(notebook, 545 gtk_notebook_set_current_page (notebook, pages);
616 list->searchpage, 546 gtk_widget_show (GTK_WIDGET (notebook)); /* may have been hidden! */
617 list->tab_label);
618 gtk_notebook_set_current_page(notebook,
619 pages);
620 gtk_widget_show(GTK_WIDGET(notebook)); /* may have been hidden! */
621 547
622 return list; 548 return list;
623} 549}
@@ -626,42 +552,38 @@ fs_search_started(struct FSUI_SearchList * fsui_list,
626 * Recursively free the (internal) model data fields 552 * Recursively free the (internal) model data fields
627 * (uri and meta) from the search tree model. 553 * (uri and meta) from the search tree model.
628 */ 554 */
629static void freeIterSubtree(GtkTreeModel * tree, 555static void
630 GtkTreeIter * iter) { 556freeIterSubtree (GtkTreeModel * tree, GtkTreeIter * iter)
557{
631 GtkTreeIter child; 558 GtkTreeIter child;
632 struct ECRS_URI * uri; 559 struct ECRS_URI *uri;
633 struct ECRS_MetaData * meta; 560 struct ECRS_MetaData *meta;
634 561
635 do { 562 do
636 uri = NULL; 563 {
637 meta = NULL; 564 uri = NULL;
638 gtk_tree_model_get(tree, 565 meta = NULL;
639 iter, 566 gtk_tree_model_get (tree,
640 SEARCH_URI, &uri, 567 iter, SEARCH_URI, &uri, SEARCH_META, &meta, -1);
641 SEARCH_META, &meta, 568 if (uri != NULL)
642 -1); 569 ECRS_freeUri (uri);
643 if (uri != NULL) 570 if (meta != NULL)
644 ECRS_freeUri(uri); 571 ECRS_freeMetaData (meta);
645 if (meta != NULL) 572 gtk_tree_store_set (GTK_TREE_STORE (tree),
646 ECRS_freeMetaData(meta); 573 iter, SEARCH_URI, NULL, SEARCH_META, NULL, -1);
647 gtk_tree_store_set(GTK_TREE_STORE(tree), 574 if (gtk_tree_model_iter_children (tree, &child, iter))
648 iter, 575 freeIterSubtree (tree, &child);
649 SEARCH_URI, NULL, 576 }
650 SEARCH_META, NULL, 577 while (gtk_tree_model_iter_next (tree, iter));
651 -1);
652 if (gtk_tree_model_iter_children(tree,
653 &child,
654 iter))
655 freeIterSubtree(tree, &child);
656 } while (gtk_tree_model_iter_next(tree,
657 iter));
658} 578}
659 579
660/** 580/**
661 * FSUI event: a search was aborted. 581 * FSUI event: a search was aborted.
662 * Update views accordingly. 582 * Update views accordingly.
663 */ 583 */
664void fs_search_aborted(SearchList * list) { 584void
585fs_search_aborted (SearchList * list)
586{
665 /* FIXME: show aborted status somehow! */ 587 /* FIXME: show aborted status somehow! */
666} 588}
667 589
@@ -669,69 +591,68 @@ void fs_search_aborted(SearchList * list) {
669 * FSUI event: a search was stopped. Remove the 591 * FSUI event: a search was stopped. Remove the
670 * respective tab and its entry in the summary. 592 * respective tab and its entry in the summary.
671 */ 593 */
672void fs_search_stopped(SearchList * list) { 594void
673 GtkNotebook * notebook; 595fs_search_stopped (SearchList * list)
596{
597 GtkNotebook *notebook;
674 GtkTreeIter iter; 598 GtkTreeIter iter;
675 SearchList * prev; 599 SearchList *prev;
676 DownloadList * downloads; 600 DownloadList *downloads;
677 GtkTreePath * path; 601 GtkTreePath *path;
678 int index; 602 int index;
679 int i; 603 int i;
680 604
681 /* remove from linked list */ 605 /* remove from linked list */
682 if (search_head == list) { 606 if (search_head == list)
683 search_head = search_head->next; 607 {
684 } else { 608 search_head = search_head->next;
685 prev = search_head; 609 }
686 while (prev->next != list) 610 else
687 prev = prev->next; 611 {
688 prev->next = list->next; 612 prev = search_head;
689 } 613 while (prev->next != list)
614 prev = prev->next;
615 prev->next = list->next;
616 }
690 617
691 /* remove links from download views */ 618 /* remove links from download views */
692 downloads = download_head; 619 downloads = download_head;
693 while (downloads != NULL) { 620 while (downloads != NULL)
694 if (downloads->searchList == list) { 621 {
695 gtk_tree_row_reference_free(downloads->searchViewRowReference); 622 if (downloads->searchList == list)
696 downloads->searchViewRowReference = NULL; 623 {
697 downloads->searchList = NULL; 624 gtk_tree_row_reference_free (downloads->searchViewRowReference);
625 downloads->searchViewRowReference = NULL;
626 downloads->searchList = NULL;
627 }
628 downloads = downloads->next;
698 } 629 }
699 downloads = downloads->next;
700 }
701 630
702 /* remove page from notebook */ 631 /* remove page from notebook */
703 notebook 632 notebook
704 = GTK_NOTEBOOK(glade_xml_get_widget(getMainXML(), 633 = GTK_NOTEBOOK (glade_xml_get_widget (getMainXML (), "downloadNotebook"));
705 "downloadNotebook"));
706 index = -1; 634 index = -1;
707 for (i=gtk_notebook_get_n_pages(notebook)-1;i>=0;i--) 635 for (i = gtk_notebook_get_n_pages (notebook) - 1; i >= 0; i--)
708 if (list->searchpage == gtk_notebook_get_nth_page(notebook, 636 if (list->searchpage == gtk_notebook_get_nth_page (notebook, i))
709 i))
710 index = i; 637 index = i;
711 GE_BREAK(ectx, index != -1); 638 GE_BREAK (ectx, index != -1);
712 gtk_notebook_remove_page(notebook, 639 gtk_notebook_remove_page (notebook, index);
713 index);
714 /* recursively free search model */ 640 /* recursively free search model */
715 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list->tree), 641 if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list->tree), &iter))
716 &iter)) 642 freeIterSubtree (GTK_TREE_MODEL (list->tree), &iter);
717 freeIterSubtree(GTK_TREE_MODEL(list->tree),
718 &iter);
719 643
720 /* destroy entry in summary */ 644 /* destroy entry in summary */
721 path = gtk_tree_row_reference_get_path(list->summaryViewRowReference); 645 path = gtk_tree_row_reference_get_path (list->summaryViewRowReference);
722 gtk_tree_model_get_iter(GTK_TREE_MODEL(search_summary), 646 gtk_tree_model_get_iter (GTK_TREE_MODEL (search_summary), &iter, path);
723 &iter, 647 gtk_tree_path_free (path);
724 path); 648 gtk_list_store_remove (search_summary, &iter);
725 gtk_tree_path_free(path);
726 gtk_list_store_remove(search_summary,
727 &iter);
728 /* free list state itself */ 649 /* free list state itself */
729 UNREF(list->searchXML); 650 UNREF (list->searchXML);
730 UNREF(list->labelXML); 651 UNREF (list->labelXML);
731 gtk_tree_row_reference_free(list->summaryViewRowReference); 652 gtk_tree_row_reference_free (list->summaryViewRowReference);
732 FREE(list->searchString); 653 FREE (list->searchString);
733 ECRS_freeUri(list->uri); 654 ECRS_freeUri (list->uri);
734 FREE(list); 655 FREE (list);
735} 656}
736 657
737/* ****************** User event handling ************* */ 658/* ****************** User event handling ************* */
@@ -741,34 +662,32 @@ void fs_search_stopped(SearchList * list) {
741 * The user has edited the search entry. 662 * The user has edited the search entry.
742 * Update search button status. 663 * Update search button status.
743 */ 664 */
744void on_fssearchKeywordComboBoxEntry_changed_fs(gpointer dummy2, 665void
745 GtkWidget * searchEntry) { 666on_fssearchKeywordComboBoxEntry_changed_fs (gpointer dummy2,
746 const char * searchString; 667 GtkWidget * searchEntry)
747 GtkWidget * searchButton; 668{
748 669 const char *searchString;
749 searchString = getEntryLineValue(getMainXML(), 670 GtkWidget *searchButton;
750 "fssearchKeywordComboBoxEntry"); 671
751 searchButton 672 searchString = getEntryLineValue (getMainXML (),
752 = glade_xml_get_widget(getMainXML(), 673 "fssearchKeywordComboBoxEntry");
753 "fssearchbutton"); 674 searchButton = glade_xml_get_widget (getMainXML (), "fssearchbutton");
754 gtk_widget_set_sensitive(searchButton, 675 gtk_widget_set_sensitive (searchButton, strlen (searchString) > 0);
755 strlen(searchString) > 0);
756} 676}
757 677
758typedef struct { 678typedef struct
679{
759 unsigned int anonymity; 680 unsigned int anonymity;
760 unsigned int max; 681 unsigned int max;
761 cron_t delay; 682 cron_t delay;
762 struct ECRS_URI * uri; 683 struct ECRS_URI *uri;
763} FSSS; 684} FSSS;
764 685
765static void * search_start_helper(void * cls) { 686static void *
766 FSSS * fsss = cls; 687search_start_helper (void *cls)
767 FSUI_startSearch(ctx, 688{
768 fsss->anonymity, 689 FSSS *fsss = cls;
769 fsss->max, 690 FSUI_startSearch (ctx, fsss->anonymity, fsss->max, fsss->delay, fsss->uri);
770 fsss->delay,
771 fsss->uri);
772 return NULL; 691 return NULL;
773} 692}
774 693
@@ -776,147 +695,146 @@ static void * search_start_helper(void * cls) {
776 * The user has clicked the "SEARCH" button. 695 * The user has clicked the "SEARCH" button.
777 * Initiate a search. 696 * Initiate a search.
778 */ 697 */
779void on_fssearchbutton_clicked_fs(gpointer dummy2, 698void
780 GtkWidget * searchButton) { 699on_fssearchbutton_clicked_fs (gpointer dummy2, GtkWidget * searchButton)
700{
781 FSSS fsss; 701 FSSS fsss;
782 const char * searchString; 702 const char *searchString;
783 gint pages; 703 gint pages;
784 gint i; 704 gint i;
785 SearchList * list; 705 SearchList *list;
786 GtkTreeIter iter; 706 GtkTreeIter iter;
787 GtkComboBox * searchKeywordGtkCB; 707 GtkComboBox *searchKeywordGtkCB;
788 GtkWidget * searchNamespaceGtkCB; 708 GtkWidget *searchNamespaceGtkCB;
789 GtkNotebook * notebook; 709 GtkNotebook *notebook;
790 710
791 searchString = getEntryLineValue(getMainXML(), 711 searchString = getEntryLineValue (getMainXML (),
792 "fssearchKeywordComboBoxEntry"); 712 "fssearchKeywordComboBoxEntry");
793 if ( (searchString == NULL) || 713 if ((searchString == NULL) || (strlen (searchString) == 0))
794 (strlen(searchString) == 0) ) { 714 {
795 GE_LOG(ectx, 715 GE_LOG (ectx,
796 GE_ERROR | GE_USER | GE_IMMEDIATE, 716 GE_ERROR | GE_USER | GE_IMMEDIATE,
797 _("Need a keyword to search!\n")); 717 _("Need a keyword to search!\n"));
798 return; 718 return;
799 } 719 }
800 /* add the keyword to the list of keywords that have 720 /* add the keyword to the list of keywords that have
801 been used so far */ 721 been used so far */
802 searchKeywordGtkCB 722 searchKeywordGtkCB
803 = GTK_COMBO_BOX(glade_xml_get_widget(getMainXML(), 723 = GTK_COMBO_BOX (glade_xml_get_widget (getMainXML (),
804 "fssearchKeywordComboBoxEntry")); 724 "fssearchKeywordComboBoxEntry"));
805 i = gtk_combo_box_get_active(searchKeywordGtkCB); 725 i = gtk_combo_box_get_active (searchKeywordGtkCB);
806 if (i == -1) { 726 if (i == -1)
807 GtkListStore * model; 727 {
808 728 GtkListStore *model;
809 model = GTK_LIST_STORE(gtk_combo_box_get_model(searchKeywordGtkCB)); 729
810 gtk_list_store_prepend(model, 730 model = GTK_LIST_STORE (gtk_combo_box_get_model (searchKeywordGtkCB));
811 &iter); 731 gtk_list_store_prepend (model, &iter);
812 gtk_list_store_set(model, 732 gtk_list_store_set (model, &iter, 0, searchString, -1);
813 &iter, 733 }
814 0, searchString,
815 -1);
816 }
817 fsss.uri = NULL; 734 fsss.uri = NULL;
818 /* check for namespace search */ 735 /* check for namespace search */
819 searchNamespaceGtkCB 736 searchNamespaceGtkCB
820 = glade_xml_get_widget(getMainXML(), 737 = glade_xml_get_widget (getMainXML (), "searchNamespaceComboBoxEntry");
821 "searchNamespaceComboBoxEntry"); 738 if (TRUE ==
822 if (TRUE == gtk_combo_box_get_active_iter(GTK_COMBO_BOX(searchNamespaceGtkCB), 739 gtk_combo_box_get_active_iter (GTK_COMBO_BOX (searchNamespaceGtkCB),
823 &iter)) { 740 &iter))
824 char * descStr; 741 {
825 char * ns; 742 char *descStr;
826 743 char *ns;
827 ns = NULL; 744
828 descStr = NULL;
829 gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(searchNamespaceGtkCB)),
830 &iter,
831 NS_SEARCH_DESCRIPTION, &descStr,
832 NS_SEARCH_ENCNAME, &ns,
833 -1);
834
835 if ( (descStr != NULL) &&
836 (0 == strcmp(descStr,
837 _("globally"))) ) {
838 ns = NULL; 745 ns = NULL;
839 } else { 746 descStr = NULL;
840 GE_ASSERT(ectx, strlen(ns) == sizeof(EncName) - 1); 747 gtk_tree_model_get (gtk_combo_box_get_model
841 if ( (descStr == NULL) && 748 (GTK_COMBO_BOX (searchNamespaceGtkCB)), &iter,
842 (ns != NULL) ) 749 NS_SEARCH_DESCRIPTION, &descStr, NS_SEARCH_ENCNAME,
843 descStr = STRDUP(ns); 750 &ns, -1);
751
752 if ((descStr != NULL) && (0 == strcmp (descStr, _("globally"))))
753 {
754 ns = NULL;
755 }
756 else
757 {
758 GE_ASSERT (ectx, strlen (ns) == sizeof (EncName) - 1);
759 if ((descStr == NULL) && (ns != NULL))
760 descStr = STRDUP (ns);
761 }
762 if (ns != NULL)
763 {
764 char *ustring;
765
766 ustring = MALLOC (strlen (searchString) + sizeof (EncName) +
767 strlen (ECRS_URI_PREFIX) +
768 strlen (ECRS_SUBSPACE_INFIX) + 10);
769 strcpy (ustring, ECRS_URI_PREFIX);
770 strcat (ustring, ECRS_SUBSPACE_INFIX);
771 strcat (ustring, ns);
772 strcat (ustring, "/");
773 strcat (ustring, searchString);
774 fsss.uri = ECRS_stringToUri (ectx, ustring);
775 if (fsss.uri == NULL)
776 {
777 GE_LOG (ectx,
778 GE_ERROR | GE_BULK | GE_USER,
779 _("Failed to create namespace URI from `%s'.\n"),
780 ustring);
781 }
782 FREE (ustring);
783 }
784 if (descStr != NULL)
785 free (descStr);
786 if (ns != NULL)
787 free (ns);
844 } 788 }
845 if (ns != NULL) {
846 char * ustring;
847
848 ustring = MALLOC(strlen(searchString) + sizeof(EncName) +
849 strlen(ECRS_URI_PREFIX) +
850 strlen(ECRS_SUBSPACE_INFIX) + 10);
851 strcpy(ustring, ECRS_URI_PREFIX);
852 strcat(ustring, ECRS_SUBSPACE_INFIX);
853 strcat(ustring, ns);
854 strcat(ustring, "/");
855 strcat(ustring, searchString);
856 fsss.uri = ECRS_stringToUri(ectx, ustring);
857 if (fsss.uri == NULL) {
858 GE_LOG(ectx,
859 GE_ERROR | GE_BULK | GE_USER,
860 _("Failed to create namespace URI from `%s'.\n"),
861 ustring);
862 }
863 FREE(ustring);
864 }
865 if (descStr != NULL)
866 free(descStr);
867 if (ns != NULL)
868 free(ns);
869 }
870 if (fsss.uri == NULL) 789 if (fsss.uri == NULL)
871 fsss.uri = ECRS_parseCharKeywordURI(ectx, searchString); 790 fsss.uri = ECRS_parseCharKeywordURI (ectx, searchString);
872 if (fsss.uri == NULL) { 791 if (fsss.uri == NULL)
873 GE_BREAK(ectx, 0); 792 {
874 return; 793 GE_BREAK (ectx, 0);
875 } 794 return;
795 }
876 /* check if search is already running */ 796 /* check if search is already running */
877 notebook 797 notebook
878 = GTK_NOTEBOOK(glade_xml_get_widget(getMainXML(), 798 = GTK_NOTEBOOK (glade_xml_get_widget (getMainXML (), "downloadNotebook"));
879 "downloadNotebook")); 799 pages = gtk_notebook_get_n_pages (notebook);
880 pages = gtk_notebook_get_n_pages(notebook);
881 list = search_head; 800 list = search_head;
882 while (list != NULL) { 801 while (list != NULL)
883 if (ECRS_equalsUri(list->uri, 802 {
884 fsss.uri)) { 803 if (ECRS_equalsUri (list->uri, fsss.uri))
885 for (i=0;i<pages;i++) { 804 {
886 if (gtk_notebook_get_nth_page(notebook, 805 for (i = 0; i < pages; i++)
887 i) 806 {
888 == list->searchpage) { 807 if (gtk_notebook_get_nth_page (notebook, i) == list->searchpage)
889 gtk_notebook_set_current_page(notebook, 808 {
890 i); 809 gtk_notebook_set_current_page (notebook, i);
891 ECRS_freeUri(fsss.uri); 810 ECRS_freeUri (fsss.uri);
892 return; 811 return;
893 } 812 }
894 } 813 }
895 GE_BREAK(ectx, 0); 814 GE_BREAK (ectx, 0);
815 }
816 list = list->next;
896 } 817 }
897 list = list->next; 818 fsss.anonymity = getSpinButtonValue (getMainXML (),
898 } 819 "searchAnonymitySelectionSpinButton");
899 fsss.anonymity = getSpinButtonValue(getMainXML(), 820 fsss.max = getSpinButtonValue (getMainXML (), "maxResultsSpinButton");
900 "searchAnonymitySelectionSpinButton"); 821 fsss.delay = getSpinButtonValue (getMainXML (),
901 fsss.max = getSpinButtonValue(getMainXML(), 822 "searchDelaySpinButton") * cronSECONDS;
902 "maxResultsSpinButton"); 823 run_with_save_calls (search_start_helper, &fsss);
903 fsss.delay = getSpinButtonValue(getMainXML(), 824 ECRS_freeUri (fsss.uri);
904 "searchDelaySpinButton") * cronSECONDS;
905 run_with_save_calls(search_start_helper,
906 &fsss);
907 ECRS_freeUri(fsss.uri);
908} 825}
909 826
910struct FCBC { 827struct FCBC
911 int (*method)(struct FSUI_Context * ctx, 828{
912 struct FSUI_SearchList * list); 829 int (*method) (struct FSUI_Context * ctx, struct FSUI_SearchList * list);
913 struct FSUI_SearchList * argument; 830 struct FSUI_SearchList *argument;
914}; 831};
915 832
916static void * fsui_callback(void * cls) { 833static void *
917 struct FCBC * fcbc = cls; 834fsui_callback (void *cls)
918 fcbc->method(ctx, 835{
919 fcbc->argument); 836 struct FCBC *fcbc = cls;
837 fcbc->method (ctx, fcbc->argument);
920 return NULL; 838 return NULL;
921} 839}
922 840
@@ -928,132 +846,131 @@ static void * fsui_callback(void * cls) {
928 * either refer to the main page in the tab or to the 846 * either refer to the main page in the tab or to the
929 * main entry of the tab label. 847 * main entry of the tab label.
930 */ 848 */
931void on_closeSearchButton_clicked_fs(GtkWidget * searchPage, 849void
932 GtkWidget * closeButton) { 850on_closeSearchButton_clicked_fs (GtkWidget * searchPage,
933 SearchList * list; 851 GtkWidget * closeButton)
852{
853 SearchList *list;
934 struct FCBC fcbc; 854 struct FCBC fcbc;
935 855
936 list = search_head; 856 list = search_head;
937 while (list != NULL) { 857 while (list != NULL)
938 if ( (list->searchpage == searchPage) || 858 {
939 (list->tab_label == searchPage) ) 859 if ((list->searchpage == searchPage) || (list->tab_label == searchPage))
940 break; 860 break;
941 list = list->next; 861 list = list->next;
942 } 862 }
943 GE_ASSERT(ectx, list != NULL); 863 GE_ASSERT (ectx, list != NULL);
944 if (list->fsui_list == NULL) { 864 if (list->fsui_list == NULL)
945 /* open directory - close directly */ 865 {
946 fs_search_stopped(list); 866 /* open directory - close directly */
947 } else { 867 fs_search_stopped (list);
948 /* actual search - close via FSUI */ 868 }
949 fcbc.method = &FSUI_abortSearch; 869 else
950 fcbc.argument = list->fsui_list; 870 {
951 run_with_save_calls(&fsui_callback, 871 /* actual search - close via FSUI */
952 &fcbc); 872 fcbc.method = &FSUI_abortSearch;
953 fcbc.method = &FSUI_stopSearch; 873 fcbc.argument = list->fsui_list;
954 run_with_save_calls(&fsui_callback, 874 run_with_save_calls (&fsui_callback, &fcbc);
955 &fcbc); 875 fcbc.method = &FSUI_stopSearch;
956 } 876 run_with_save_calls (&fsui_callback, &fcbc);
877 }
957} 878}
958 879
959/** 880/**
960 * The abort button was clicked. Abort the search. 881 * The abort button was clicked. Abort the search.
961 */ 882 */
962void on_abortSearchButton_clicked_fs(GtkWidget * searchPage, 883void
963 GtkWidget * closeButton) { 884on_abortSearchButton_clicked_fs (GtkWidget * searchPage,
964 SearchList * list; 885 GtkWidget * closeButton)
886{
887 SearchList *list;
965 struct FCBC fcbc; 888 struct FCBC fcbc;
966 889
967 list = search_head; 890 list = search_head;
968 while (list != NULL) { 891 while (list != NULL)
969 if (list->searchpage == searchPage) 892 {
970 break; 893 if (list->searchpage == searchPage)
971 list = list->next; 894 break;
972 } 895 list = list->next;
973 GE_ASSERT(ectx, list != NULL); 896 }
974 if (list->fsui_list != NULL) { 897 GE_ASSERT (ectx, list != NULL);
975 fcbc.method = &FSUI_abortSearch; 898 if (list->fsui_list != NULL)
976 fcbc.argument = list->fsui_list; 899 {
977 run_with_save_calls(&fsui_callback, 900 fcbc.method = &FSUI_abortSearch;
978 &fcbc); 901 fcbc.argument = list->fsui_list;
979 } 902 run_with_save_calls (&fsui_callback, &fcbc);
903 }
980} 904}
981 905
982static void stopSearch(GtkTreeModel * model, 906static void
983 GtkTreePath * path, 907stopSearch (GtkTreeModel * model,
984 GtkTreeIter * iter, 908 GtkTreePath * path, GtkTreeIter * iter, gpointer unused)
985 gpointer unused) { 909{
986 SearchList * s; 910 SearchList *s;
987 struct FCBC fcbc; 911 struct FCBC fcbc;
988 912
989 s = NULL; 913 s = NULL;
990 gtk_tree_model_get(model, 914 gtk_tree_model_get (model, iter, SEARCH_SUMMARY_INTERNAL, &s, -1);
991 iter, 915 if (s != NULL)
992 SEARCH_SUMMARY_INTERNAL, &s, 916 {
993 -1); 917 if (s->fsui_list == NULL)
994 if (s != NULL) { 918 {
995 if (s->fsui_list == NULL) { 919 /* open directory - close directly */
996 /* open directory - close directly */ 920 fs_search_stopped (s);
997 fs_search_stopped(s); 921 }
998 } else { 922 else
999 fcbc.method = &FSUI_abortSearch; 923 {
1000 fcbc.argument = s->fsui_list; 924 fcbc.method = &FSUI_abortSearch;
1001 run_with_save_calls(&fsui_callback, 925 fcbc.argument = s->fsui_list;
1002 &fcbc); 926 run_with_save_calls (&fsui_callback, &fcbc);
1003 fcbc.method = &FSUI_stopSearch; 927 fcbc.method = &FSUI_stopSearch;
1004 run_with_save_calls(&fsui_callback, 928 run_with_save_calls (&fsui_callback, &fcbc);
1005 &fcbc); 929 }
1006 } 930 }
1007 }
1008} 931}
1009 932
1010/** 933/**
1011 * The stop button in the search summary was clicked. 934 * The stop button in the search summary was clicked.
1012 */ 935 */
1013void on_closeSearchSummaryButton_clicked_fs(GtkWidget * treeview, 936void
1014 GtkWidget * closeButton) { 937on_closeSearchSummaryButton_clicked_fs (GtkWidget * treeview,
1015 GtkTreeSelection * selection; 938 GtkWidget * closeButton)
1016 939{
1017 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); 940 GtkTreeSelection *selection;
1018 ggc_tree_selection_selected_foreach 941
1019 (selection, 942 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
1020 &stopSearch, 943 ggc_tree_selection_selected_foreach (selection, &stopSearch, NULL);
1021 NULL);
1022} 944}
1023 945
1024static void abortSearch(GtkTreeModel * model, 946static void
1025 GtkTreePath * path, 947abortSearch (GtkTreeModel * model,
1026 GtkTreeIter * iter, 948 GtkTreePath * path, GtkTreeIter * iter, gpointer unused)
1027 gpointer unused) { 949{
1028 SearchList * s; 950 SearchList *s;
1029 struct FCBC fcbc; 951 struct FCBC fcbc;
1030 952
1031 s = NULL; 953 s = NULL;
1032 gtk_tree_model_get(model, 954 gtk_tree_model_get (model, iter, SEARCH_SUMMARY_INTERNAL, &s, -1);
1033 iter, 955 if ((s != NULL) && (s->fsui_list != NULL))
1034 SEARCH_SUMMARY_INTERNAL, &s, 956 {
1035 -1); 957 fcbc.method = &FSUI_abortSearch;
1036 if ( (s != NULL) && 958 fcbc.argument = s->fsui_list;
1037 (s->fsui_list != NULL) ) { 959 run_with_save_calls (&fsui_callback, &fcbc);
1038 fcbc.method = &FSUI_abortSearch; 960 }
1039 fcbc.argument = s->fsui_list;
1040 run_with_save_calls(&fsui_callback,
1041 &fcbc);
1042 }
1043} 961}
1044 962
1045/** 963/**
1046 * The abort button in the search summary was clicked. 964 * The abort button in the search summary was clicked.
1047 */ 965 */
1048void on_abortSearchSummaryButton_clicked_fs(GtkWidget * treeview, 966void
1049 GtkWidget * closeButton) { 967on_abortSearchSummaryButton_clicked_fs (GtkWidget * treeview,
1050 GtkTreeSelection * selection; 968 GtkWidget * closeButton)
1051 969{
1052 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); 970 GtkTreeSelection *selection;
1053 ggc_tree_selection_selected_foreach 971
1054 (selection, 972 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
1055 &abortSearch, 973 ggc_tree_selection_selected_foreach (selection, &abortSearch, NULL);
1056 NULL);
1057} 974}
1058 975
1059/* end of search.c */ 976/* end of search.c */
diff --git a/src/plugins/fs/search.h b/src/plugins/fs/search.h
index 4afc1496..82d7a8f3 100644
--- a/src/plugins/fs/search.h
+++ b/src/plugins/fs/search.h
@@ -36,10 +36,9 @@
36 * Add the given search result to the search 36 * Add the given search result to the search
37 * tree at the specified position. 37 * tree at the specified position.
38 */ 38 */
39void addEntryToSearchTree(SearchList * searchContext, 39void addEntryToSearchTree (SearchList * searchContext,
40 DownloadList * downloadParent, 40 DownloadList * downloadParent,
41 const ECRS_FileInfo * info, 41 const ECRS_FileInfo * info, GtkTreeIter * iter);
42 GtkTreeIter * iter);
43 42
44/** 43/**
45 * Add the given result to the model (search result 44 * Add the given result to the model (search result
@@ -49,31 +48,30 @@ void addEntryToSearchTree(SearchList * searchContext,
49 * @param path the tree path that selects where to add 48 * @param path the tree path that selects where to add
50 * the information, NULL for top-level 49 * the information, NULL for top-level
51 */ 50 */
52void fs_search_result_received(SearchList * searchContext, 51void fs_search_result_received (SearchList * searchContext,
53 const ECRS_FileInfo * info, 52 const ECRS_FileInfo * info,
54 const struct ECRS_URI * uri); 53 const struct ECRS_URI *uri);
55 54
56/** 55/**
57 * A search has been started. Open tab. 56 * A search has been started. Open tab.
58 * 57 *
59 * @return internal search context 58 * @return internal search context
60 */ 59 */
61SearchList * 60SearchList *fs_search_started (struct FSUI_SearchList *list,
62fs_search_started(struct FSUI_SearchList * list, 61 const struct ECRS_URI *uri,
63 const struct ECRS_URI * uri, 62 unsigned int anonymityLevel,
64 unsigned int anonymityLevel, 63 unsigned int resultCount,
65 unsigned int resultCount, 64 const ECRS_FileInfo * results,
66 const ECRS_FileInfo * results, 65 FSUI_State state);
67 FSUI_State state);
68 66
69/** 67/**
70 * A search process has been aborted. Update display. 68 * A search process has been aborted. Update display.
71 */ 69 */
72void fs_search_aborted(SearchList * searchContext); 70void fs_search_aborted (SearchList * searchContext);
73 71
74/** 72/**
75 * A search process has stopped. Clean up. 73 * A search process has stopped. Clean up.
76 */ 74 */
77void fs_search_stopped(SearchList * searchContext); 75void fs_search_stopped (SearchList * searchContext);
78 76
79#endif 77#endif
diff --git a/src/plugins/fs/upload.c b/src/plugins/fs/upload.c
index 8a19adb1..071d64f1 100644
--- a/src/plugins/fs/upload.c
+++ b/src/plugins/fs/upload.c
@@ -44,145 +44,128 @@
44 * (there can only be one at a time; 44 * (there can only be one at a time;
45 * maybe NULL at times where there is no dialog) 45 * maybe NULL at times where there is no dialog)
46 */ 46 */
47static GladeXML * metaXML; 47static GladeXML *metaXML;
48 48
49/* ************ FSUI event handlers ************ */ 49/* ************ FSUI event handlers ************ */
50 50
51void fs_upload_update(UploadList * list, 51void
52 unsigned long long completed) { 52fs_upload_update (UploadList * list, unsigned long long completed)
53{
53 GtkTreeIter iter; 54 GtkTreeIter iter;
54 GtkTreePath * path; 55 GtkTreePath *path;
55 int progress; 56 int progress;
56 57
57 if (list->total != 0) 58 if (list->total != 0)
58 progress = 100 * completed / list->total; 59 progress = 100 * completed / list->total;
59 else 60 else
60 progress = 100; 61 progress = 100;
61 path = gtk_tree_row_reference_get_path(list->summaryViewRowReference); 62 path = gtk_tree_row_reference_get_path (list->summaryViewRowReference);
62 gtk_tree_model_get_iter(GTK_TREE_MODEL(upload_summary), 63 gtk_tree_model_get_iter (GTK_TREE_MODEL (upload_summary), &iter, path);
63 &iter, 64 gtk_tree_path_free (path);
64 path); 65 gtk_tree_store_set (upload_summary, &iter, UPLOAD_PROGRESS, progress, -1);
65 gtk_tree_path_free(path);
66 gtk_tree_store_set(upload_summary,
67 &iter,
68 UPLOAD_PROGRESS, progress,
69 -1);
70} 66}
71 67
72void fs_upload_complete(UploadList * list, 68void
73 struct ECRS_URI * uri) { 69fs_upload_complete (UploadList * list, struct ECRS_URI *uri)
70{
74 GtkTreeIter iter; 71 GtkTreeIter iter;
75 GtkTreePath * path; 72 GtkTreePath *path;
76 char * us; 73 char *us;
77 74
78 list->has_terminated = YES; 75 list->has_terminated = YES;
79 list->uri = ECRS_dupUri(uri); 76 list->uri = ECRS_dupUri (uri);
80 us = ECRS_uriToString(uri); 77 us = ECRS_uriToString (uri);
81 path = gtk_tree_row_reference_get_path(list->summaryViewRowReference); 78 path = gtk_tree_row_reference_get_path (list->summaryViewRowReference);
82 gtk_tree_model_get_iter(GTK_TREE_MODEL(upload_summary), 79 gtk_tree_model_get_iter (GTK_TREE_MODEL (upload_summary), &iter, path);
83 &iter, 80 gtk_tree_path_free (path);
84 path); 81 gtk_tree_store_set (upload_summary, &iter, UPLOAD_URISTRING, us, -1);
85 gtk_tree_path_free(path); 82 FREE (us);
86 gtk_tree_store_set(upload_summary,
87 &iter,
88 UPLOAD_URISTRING, us,
89 -1);
90 FREE(us);
91} 83}
92 84
93void fs_upload_error(UploadList * list) { 85void
86fs_upload_error (UploadList * list)
87{
94 /* FIXME: indicate error in summary dialog! */ 88 /* FIXME: indicate error in summary dialog! */
95 list->has_terminated = YES; 89 list->has_terminated = YES;
96} 90}
97 91
98void fs_upload_stopped(UploadList * list) { 92void
93fs_upload_stopped (UploadList * list)
94{
99 GtkTreeIter iter; 95 GtkTreeIter iter;
100 GtkTreePath * path; 96 GtkTreePath *path;
101 UploadList * prev; 97 UploadList *prev;
102 98
103 path = gtk_tree_row_reference_get_path(list->summaryViewRowReference); 99 path = gtk_tree_row_reference_get_path (list->summaryViewRowReference);
104 gtk_tree_model_get_iter(GTK_TREE_MODEL(upload_summary), 100 gtk_tree_model_get_iter (GTK_TREE_MODEL (upload_summary), &iter, path);
105 &iter, 101 gtk_tree_path_free (path);
106 path); 102 gtk_tree_row_reference_free (list->summaryViewRowReference);
107 gtk_tree_path_free(path);
108 gtk_tree_row_reference_free(list->summaryViewRowReference);
109 list->summaryViewRowReference = NULL; 103 list->summaryViewRowReference = NULL;
110 gtk_tree_store_remove(upload_summary, 104 gtk_tree_store_remove (upload_summary, &iter);
111 &iter); 105 FREE (list->filename);
112 FREE(list->filename); 106 if (list->uri != NULL)
113 if (list->uri != NULL) { 107 {
114 ECRS_freeUri(list->uri); 108 ECRS_freeUri (list->uri);
115 list->uri = NULL; 109 list->uri = NULL;
116 } 110 }
117 if (upload_head == list) 111 if (upload_head == list)
118 upload_head = list->next; 112 upload_head = list->next;
119 else { 113 else
120 prev = upload_head; 114 {
121 while ( (prev != NULL) && 115 prev = upload_head;
122 (prev->next != list) ) 116 while ((prev != NULL) && (prev->next != list))
123 prev = prev->next; 117 prev = prev->next;
124 if (prev != NULL) 118 if (prev != NULL)
125 prev->next = list->next; 119 prev->next = list->next;
126 else 120 else
127 GE_BREAK(ectx, 0); 121 GE_BREAK (ectx, 0);
128 } 122 }
129 FREE(list); 123 FREE (list);
130} 124}
131 125
132UploadList * 126UploadList *
133fs_upload_started(struct FSUI_UploadList * fsui, 127fs_upload_started (struct FSUI_UploadList *fsui,
134 UploadList * parent, 128 UploadList * parent,
135 const char * filename, 129 const char *filename,
136 struct ECRS_URI * uri, 130 struct ECRS_URI *uri,
137 unsigned long long total, 131 unsigned long long total,
138 unsigned long long completed, 132 unsigned long long completed, FSUI_State state)
139 FSUI_State state) { 133{
140 UploadList * ret; 134 UploadList *ret;
141 GtkTreeIter iter; 135 GtkTreeIter iter;
142 GtkTreePath * path; 136 GtkTreePath *path;
143 int progress; 137 int progress;
144 GtkTreeIter par; 138 GtkTreeIter par;
145 139
146 ret = MALLOC(sizeof(UploadList)); 140 ret = MALLOC (sizeof (UploadList));
147 memset(ret, 141 memset (ret, 0, sizeof (UploadList));
148 0, 142 ret->filename = STRDUP (filename);
149 sizeof(UploadList));
150 ret->filename = STRDUP(filename);
151 ret->fsui_list = fsui; 143 ret->fsui_list = fsui;
152 ret->total = total; 144 ret->total = total;
153 ret->is_top = parent == NULL; 145 ret->is_top = parent == NULL;
154 if ( (parent != NULL) && 146 if ((parent != NULL) &&
155 (NULL != (path = gtk_tree_row_reference_get_path(parent->summaryViewRowReference))) ) { 147 (NULL !=
156 gtk_tree_model_get_iter(GTK_TREE_MODEL(upload_summary), 148 (path =
157 &par, 149 gtk_tree_row_reference_get_path (parent->summaryViewRowReference))))
158 path); 150 {
159 gtk_tree_path_free(path); 151 gtk_tree_model_get_iter (GTK_TREE_MODEL (upload_summary), &par, path);
160 gtk_tree_store_append(upload_summary, 152 gtk_tree_path_free (path);
161 &iter, 153 gtk_tree_store_append (upload_summary, &iter, &par);
162 &par); 154 }
163 } else { 155 else
164 gtk_tree_store_append(upload_summary, 156 {
165 &iter, 157 gtk_tree_store_append (upload_summary, &iter, NULL);
166 NULL); 158 }
167 }
168 if (total != 0) 159 if (total != 0)
169 progress = 100 * completed / total; 160 progress = 100 * completed / total;
170 else 161 else
171 progress = 100; 162 progress = 100;
172 gtk_tree_store_set(upload_summary, 163 gtk_tree_store_set (upload_summary, &iter, UPLOAD_FILENAME, filename, UPLOAD_PROGRESS, progress, UPLOAD_URISTRING, "", /* FIXME: set if URI != NULL! */
173 &iter, 164 UPLOAD_INTERNAL, ret, -1);
174 UPLOAD_FILENAME, filename, 165 path = gtk_tree_model_get_path (GTK_TREE_MODEL (upload_summary), &iter);
175 UPLOAD_PROGRESS, progress,
176 UPLOAD_URISTRING, "", /* FIXME: set if URI != NULL! */
177 UPLOAD_INTERNAL, ret,
178 -1);
179 path = gtk_tree_model_get_path(GTK_TREE_MODEL(upload_summary),
180 &iter);
181 ret->summaryViewRowReference 166 ret->summaryViewRowReference
182 = gtk_tree_row_reference_new(GTK_TREE_MODEL(upload_summary), 167 = gtk_tree_row_reference_new (GTK_TREE_MODEL (upload_summary), path);
183 path); 168 ret->has_terminated = ((state != FSUI_ACTIVE) && (state != FSUI_PENDING));
184 ret->has_terminated = ( (state != FSUI_ACTIVE) &&
185 (state != FSUI_PENDING) );
186 169
187 ret->next = upload_head; 170 ret->next = upload_head;
188 upload_head = ret; 171 upload_head = ret;
@@ -192,476 +175,452 @@ fs_upload_started(struct FSUI_UploadList * fsui,
192/* *************** user upload event handling ************** */ 175/* *************** user upload event handling ************** */
193 176
194 177
195void on_selectAlternativePreviewButton_selection_changed_fs(GtkWidget * preview, 178void
196 GtkWidget * fileChooser) { 179on_selectAlternativePreviewButton_selection_changed_fs (GtkWidget * preview,
197 char * fn; 180 GtkWidget *
198 181 fileChooser)
199 fn = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fileChooser)); 182{
200 if (fn == NULL) { 183 char *fn;
201 gtk_image_set_from_pixbuf(GTK_IMAGE(preview), 184
202 NULL); 185 fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser));
203 } else { 186 if (fn == NULL)
204 GdkPixbuf * buf; 187 {
205 188 gtk_image_set_from_pixbuf (GTK_IMAGE (preview), NULL);
206 buf = gdk_pixbuf_new_from_file(fn, 189 }
207 NULL); 190 else
208 gtk_image_set_from_pixbuf(GTK_IMAGE(preview), 191 {
209 buf); 192 GdkPixbuf *buf;
210 g_object_unref(buf); 193
211 free(fn); 194 buf = gdk_pixbuf_new_from_file (fn, NULL);
212 } 195 gtk_image_set_from_pixbuf (GTK_IMAGE (preview), buf);
196 g_object_unref (buf);
197 free (fn);
198 }
213} 199}
214 200
215void on_metaDataDialogKeywordAddButton_clicked_fs(gpointer dummy, 201void
216 GtkWidget * button) { 202on_metaDataDialogKeywordAddButton_clicked_fs (gpointer dummy,
217 handleKeywordListUpdate(metaXML, 203 GtkWidget * button)
218 "fileInformationKeywordEntry", 204{
219 "metaDataDialogKeywordList"); 205 handleKeywordListUpdate (metaXML,
206 "fileInformationKeywordEntry",
207 "metaDataDialogKeywordList");
220} 208}
221 209
222void on_metaDataDialogMetaDataAddButton_clicked_fs(gpointer dummy, 210void
223 GtkWidget * button) { 211on_metaDataDialogMetaDataAddButton_clicked_fs (gpointer dummy,
224 handleMetaDataListUpdate(metaXML, 212 GtkWidget * button)
225 "metaDataDialogMetaTypeComboBox", 213{
226 "metaDataDialogValueEntry", 214 handleMetaDataListUpdate (metaXML,
227 "metaDataDialogMetaDataList"); 215 "metaDataDialogMetaTypeComboBox",
216 "metaDataDialogValueEntry",
217 "metaDataDialogMetaDataList");
228} 218}
229 219
230void on_metaDataDialogKeywordRemoveButton_clicked_fs(gpointer dummy, 220void
231 GtkWidget * button) { 221on_metaDataDialogKeywordRemoveButton_clicked_fs (gpointer dummy,
232 handleListRemove(metaXML, 222 GtkWidget * button)
233 "metaDataDialogKeywordList"); 223{
224 handleListRemove (metaXML, "metaDataDialogKeywordList");
234} 225}
235 226
236void on_metaDataDialogMetaDataRemoveButton_clicked_fs(gpointer dummy, 227void
237 GtkWidget * button) { 228on_metaDataDialogMetaDataRemoveButton_clicked_fs (gpointer dummy,
238 handleListRemove(metaXML, 229 GtkWidget * button)
239 "metaDataDialogMetaDataList"); 230{
231 handleListRemove (metaXML, "metaDataDialogMetaDataList");
240} 232}
241 233
242/** 234/**
243 * The selection of the keyword list changed. 235 * The selection of the keyword list changed.
244 * Update button status. 236 * Update button status.
245 */ 237 */
246static void on_keyword_list_selection_changed(gpointer signal, 238static void
247 gpointer cls) { 239on_keyword_list_selection_changed (gpointer signal, gpointer cls)
248 GtkTreeSelection * selection; 240{
249 GtkWidget * button; 241 GtkTreeSelection *selection;
250 242 GtkWidget *button;
251 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(metaXML, 243
252 "metaDataDialogKeywordList"))); 244 selection =
253 button 245 gtk_tree_view_get_selection (GTK_TREE_VIEW
254 = glade_xml_get_widget(metaXML, 246 (glade_xml_get_widget
255 "metaDataDialogKeywordRemoveButton"); 247 (metaXML, "metaDataDialogKeywordList")));
256 gtk_widget_set_sensitive(button, 248 button =
257 gtk_tree_selection_count_selected_rows(selection) > 0); 249 glade_xml_get_widget (metaXML, "metaDataDialogKeywordRemoveButton");
250 gtk_widget_set_sensitive (button,
251 gtk_tree_selection_count_selected_rows (selection)
252 > 0);
258} 253}
259 254
260/** 255/**
261 * The selection of the metadata list changed. 256 * The selection of the metadata list changed.
262 * Update button status. 257 * Update button status.
263 */ 258 */
264static void on_metadata_list_selection_changed(gpointer signal, 259static void
265 gpointer cls) { 260on_metadata_list_selection_changed (gpointer signal, gpointer cls)
266 GtkTreeSelection * selection; 261{
267 GtkWidget * button; 262 GtkTreeSelection *selection;
268 263 GtkWidget *button;
269 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(metaXML, 264
270 "metaDataDialogMetaDataList"))); 265 selection =
271 button 266 gtk_tree_view_get_selection (GTK_TREE_VIEW
272 = glade_xml_get_widget(metaXML, 267 (glade_xml_get_widget
273 "metaDataDialogMetaDataRemoveButton"); 268 (metaXML, "metaDataDialogMetaDataList")));
274 gtk_widget_set_sensitive(button, 269 button =
275 gtk_tree_selection_count_selected_rows(selection) > 0); 270 glade_xml_get_widget (metaXML, "metaDataDialogMetaDataRemoveButton");
271 gtk_widget_set_sensitive (button,
272 gtk_tree_selection_count_selected_rows (selection)
273 > 0);
276} 274}
277 275
278/** 276/**
279 * The user has edited the metadata entry. 277 * The user has edited the metadata entry.
280 * Update add button status. 278 * Update add button status.
281 */ 279 */
282void on_metaDataDialogValueEntry_changed_fs(gpointer dummy2, 280void
283 GtkWidget * searchEntry) { 281on_metaDataDialogValueEntry_changed_fs (gpointer dummy2,
284 const char * input; 282 GtkWidget * searchEntry)
285 GtkWidget * button; 283{
286 284 const char *input;
287 input = gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(metaXML, 285 GtkWidget *button;
288 "metaDataDialogValueEntry"))); 286
287 input = gtk_entry_get_text (GTK_ENTRY (glade_xml_get_widget (metaXML,
288 "metaDataDialogValueEntry")));
289 if (input == NULL) 289 if (input == NULL)
290 return; 290 return;
291 button 291 button = glade_xml_get_widget (metaXML, "metaDataDialogMetaDataAddButton");
292 = glade_xml_get_widget(metaXML, 292 gtk_widget_set_sensitive (button, strlen (input) > 0);
293 "metaDataDialogMetaDataAddButton");
294 gtk_widget_set_sensitive(button,
295 strlen(input) > 0);
296} 293}
297 294
298/** 295/**
299 * The user has edited the keyword entry. 296 * The user has edited the keyword entry.
300 * Update add button status. 297 * Update add button status.
301 */ 298 */
302void on_fileInformationKeywordEntry_changed_fs(gpointer dummy2, 299void
303 GtkWidget * searchEntry) { 300on_fileInformationKeywordEntry_changed_fs (gpointer dummy2,
304 const char * input; 301 GtkWidget * searchEntry)
305 GtkWidget * button; 302{
306 303 const char *input;
307 input = gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(metaXML, 304 GtkWidget *button;
308 "fileInformationKeywordEntry"))); 305
306 input = gtk_entry_get_text (GTK_ENTRY (glade_xml_get_widget (metaXML,
307 "fileInformationKeywordEntry")));
309 if (input == NULL) 308 if (input == NULL)
310 return; 309 return;
311 button 310 button = glade_xml_get_widget (metaXML, "metaDataDialogKeywordAddButton");
312 = glade_xml_get_widget(metaXML, 311 gtk_widget_set_sensitive (button, strlen (input) > 0);
313 "metaDataDialogKeywordAddButton");
314 gtk_widget_set_sensitive(button,
315 strlen(input) > 0);
316} 312}
317 313
318typedef struct { 314typedef struct
319 char * filename; 315{
316 char *filename;
320 unsigned int anonymity; 317 unsigned int anonymity;
321 unsigned int priority; 318 unsigned int priority;
322 int index; 319 int index;
323 int extract; 320 int extract;
324 int deep_index; 321 int deep_index;
325 cron_t expire; 322 cron_t expire;
326 struct ECRS_MetaData * meta; 323 struct ECRS_MetaData *meta;
327 struct ECRS_URI * gkeywordURI; 324 struct ECRS_URI *gkeywordURI;
328 struct ECRS_URI * keywordURI; 325 struct ECRS_URI *keywordURI;
329} FSUC; 326} FSUC;
330 327
331static void * start_upload_helper(void * cls) { 328static void *
332 FSUC * fsuc = cls; 329start_upload_helper (void *cls)
333 330{
334 FSUI_startUpload(ctx, 331 FSUC *fsuc = cls;
335 fsuc->filename, 332
336 (DirectoryScanCallback) &disk_directory_scan, 333 FSUI_startUpload (ctx,
337 ectx, 334 fsuc->filename,
338 fsuc->anonymity, 335 (DirectoryScanCallback) & disk_directory_scan,
339 fsuc->priority, 336 ectx,
340 fsuc->index, 337 fsuc->anonymity,
341 fsuc->extract, 338 fsuc->priority,
342 fsuc->deep_index, 339 fsuc->index,
343 fsuc->expire, 340 fsuc->extract,
344 fsuc->meta, 341 fsuc->deep_index,
345 fsuc->gkeywordURI, 342 fsuc->expire,
346 fsuc->keywordURI); 343 fsuc->meta, fsuc->gkeywordURI, fsuc->keywordURI);
347 return NULL; 344 return NULL;
348} 345}
349 346
350void on_fsinsertuploadbutton_clicked_fs(gpointer dummy, 347void
351 GtkWidget * uploadButton) { 348on_fsinsertuploadbutton_clicked_fs (gpointer dummy, GtkWidget * uploadButton)
349{
352 FSUC fsuc; 350 FSUC fsuc;
353 const char * filename; 351 const char *filename;
354 const char * filenamerest; 352 const char *filenamerest;
355 GtkWidget * dialog; 353 GtkWidget *dialog;
356 EXTRACTOR_ExtractorList * extractors; 354 EXTRACTOR_ExtractorList *extractors;
357 char * config; 355 char *config;
358 struct ECRS_MetaData * meta; 356 struct ECRS_MetaData *meta;
359 struct ECRS_URI * keywordURI; 357 struct ECRS_URI *keywordURI;
360 358
361 extractors = EXTRACTOR_loadDefaultLibraries(); 359 extractors = EXTRACTOR_loadDefaultLibraries ();
362 config = NULL; 360 config = NULL;
363 GC_get_configuration_value_string(cfg, 361 GC_get_configuration_value_string (cfg, "FS", "EXTRACTORS", "", &config);
364 "FS", 362 if (strlen (config) > 0)
365 "EXTRACTORS", 363 extractors = EXTRACTOR_loadConfigLibraries (extractors, config);
366 "", 364 FREE (config);
367 &config); 365 filename = getEntryLineValue (getMainXML (), "uploadFilenameComboBoxEntry");
368 if (strlen(config) > 0)
369 extractors = EXTRACTOR_loadConfigLibraries(extractors,
370 config);
371 FREE(config);
372 filename = getEntryLineValue(getMainXML(),
373 "uploadFilenameComboBoxEntry");
374 metaXML 366 metaXML
375 = glade_xml_new(getGladeFileName(), 367 = glade_xml_new (getGladeFileName (), "metaDataDialog", PACKAGE_NAME);
376 "metaDataDialog", 368 connectGladeWithPlugins (metaXML);
377 PACKAGE_NAME); 369 dialog = glade_xml_get_widget (metaXML, "metaDataDialog");
378 connectGladeWithPlugins(metaXML); 370 meta = ECRS_createMetaData ();
379 dialog = glade_xml_get_widget(metaXML, 371 ECRS_extractMetaData (ectx, meta, filename, extractors);
380 "metaDataDialog"); 372 EXTRACTOR_removeAll (extractors);
381 meta = ECRS_createMetaData(); 373 filenamerest = &filename[strlen (filename) - 1];
382 ECRS_extractMetaData(ectx, 374 while ((filenamerest > filename) && (filenamerest[-1] != DIR_SEPARATOR))
383 meta,
384 filename,
385 extractors);
386 EXTRACTOR_removeAll(extractors);
387 filenamerest = &filename[strlen(filename)-1];
388 while ( (filenamerest > filename) &&
389 (filenamerest[-1] != DIR_SEPARATOR) )
390 filenamerest--; 375 filenamerest--;
391 ECRS_addToMetaData(meta, 376 ECRS_addToMetaData (meta, EXTRACTOR_FILENAME, filenamerest);
392 EXTRACTOR_FILENAME, 377 createMetaDataListTreeView (metaXML,
393 filenamerest); 378 "metaDataDialogMetaDataList",
394 createMetaDataListTreeView(metaXML, 379 "previewImage", meta);
395 "metaDataDialogMetaDataList", 380 keywordURI = ECRS_metaDataToUri (meta);
396 "previewImage", 381 ECRS_freeMetaData (meta);
397 meta); 382 createKeywordListTreeView (metaXML,
398 keywordURI = ECRS_metaDataToUri(meta); 383 "metaDataDialogKeywordList", keywordURI);
399 ECRS_freeMetaData(meta); 384 ECRS_freeUri (keywordURI);
400 createKeywordListTreeView(metaXML, 385 createMetaTypeComboBox (metaXML, "metaDataDialogMetaTypeComboBox");
401 "metaDataDialogKeywordList", 386 g_signal_connect_data (gtk_tree_view_get_selection
402 keywordURI); 387 (GTK_TREE_VIEW
403 ECRS_freeUri(keywordURI); 388 (glade_xml_get_widget
404 createMetaTypeComboBox(metaXML, 389 (metaXML, "metaDataDialogKeywordList"))),
405 "metaDataDialogMetaTypeComboBox"); 390 "changed",
406 g_signal_connect_data(gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(metaXML, 391 G_CALLBACK (&on_keyword_list_selection_changed),
407 "metaDataDialogKeywordList"))), 392 NULL, NULL, 0);
408 "changed", 393 g_signal_connect_data (gtk_tree_view_get_selection
409 G_CALLBACK(&on_keyword_list_selection_changed), 394 (GTK_TREE_VIEW
410 NULL, 395 (glade_xml_get_widget
411 NULL, 396 (metaXML, "metaDataDialogMetaDataList"))),
412 0); 397 "changed",
413 g_signal_connect_data(gtk_tree_view_get_selection(GTK_TREE_VIEW(glade_xml_get_widget(metaXML, 398 G_CALLBACK (&on_metadata_list_selection_changed),
414 "metaDataDialogMetaDataList"))), 399 NULL, NULL, 0);
415 "changed", 400 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
416 G_CALLBACK(&on_metadata_list_selection_changed), 401 if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_CANCEL)
417 NULL, 402 {
418 NULL, 403 fsuc.anonymity = getSpinButtonValue (getMainXML (),
419 0); 404 "uploadAnonymityLevelSpinButton");
420 gtk_dialog_set_default_response(GTK_DIALOG(dialog), 405 fsuc.priority = getSpinButtonValue (getMainXML (),
421 GTK_RESPONSE_OK); 406 "contentPrioritySpinButton");
422 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL) { 407 fsuc.index = getToggleButtonValue (getMainXML (), "indexbutton");
423 fsuc.anonymity = getSpinButtonValue(getMainXML(), 408 fsuc.extract = getToggleButtonValue (getMainXML (),
424 "uploadAnonymityLevelSpinButton"); 409 "doExtractCheckButton");
425 fsuc.priority = getSpinButtonValue(getMainXML(), 410 fsuc.deep_index = getToggleButtonValue (getMainXML (),
426 "contentPrioritySpinButton"); 411 "deepIndexCheckButton");
427 fsuc.index = getToggleButtonValue(getMainXML(), 412 fsuc.expire = get_time () + 2 * cronYEARS;
428 "indexbutton"); 413 fsuc.meta = getMetaDataFromList (metaXML,
429 fsuc.extract = getToggleButtonValue(getMainXML(), 414 "metaDataDialogMetaDataList",
430 "doExtractCheckButton"); 415 "previewImage");
431 fsuc.deep_index = getToggleButtonValue(getMainXML(), 416 fsuc.keywordURI = getKeywordURIFromList (metaXML,
432 "deepIndexCheckButton"); 417 "metaDataDialogKeywordList");
433 fsuc.expire = get_time() + 2 * cronYEARS; 418 fsuc.gkeywordURI = ECRS_stringToUri (ectx,
434 fsuc.meta = getMetaDataFromList(metaXML, 419 ECRS_URI_PREFIX ECRS_SEARCH_INFIX);
435 "metaDataDialogMetaDataList", 420 fsuc.filename = STRDUP (filename);
436 "previewImage"); 421 run_with_save_calls (&start_upload_helper, &fsuc);
437 fsuc.keywordURI = getKeywordURIFromList(metaXML, 422 FREE (fsuc.filename);
438 "metaDataDialogKeywordList"); 423 ECRS_freeMetaData (fsuc.meta);
439 fsuc.gkeywordURI = ECRS_stringToUri(ectx, 424 ECRS_freeUri (fsuc.gkeywordURI);
440 ECRS_URI_PREFIX 425 ECRS_freeUri (fsuc.keywordURI);
441 ECRS_SEARCH_INFIX); 426 }
442 fsuc.filename = STRDUP(filename);
443 run_with_save_calls(&start_upload_helper,
444 &fsuc);
445 FREE(fsuc.filename);
446 ECRS_freeMetaData(fsuc.meta);
447 ECRS_freeUri(fsuc.gkeywordURI);
448 ECRS_freeUri(fsuc.keywordURI);
449 }
450 gtk_widget_destroy (dialog); 427 gtk_widget_destroy (dialog);
451 UNREF(metaXML); 428 UNREF (metaXML);
452 metaXML = NULL; 429 metaXML = NULL;
453} 430}
454 431
455#ifndef MINGW 432#ifndef MINGW
456static char * 433static char *
457selectFile(const char * oldfilename) { 434selectFile (const char *oldfilename)
458 GladeXML * uploadXML; 435{
459 GtkFileChooser * dialog; 436 GladeXML *uploadXML;
460 char * ret; 437 GtkFileChooser *dialog;
438 char *ret;
461 439
462 uploadXML 440 uploadXML
463 = glade_xml_new(getGladeFileName(), 441 = glade_xml_new (getGladeFileName (),
464 "uploadfilechooserdialog", 442 "uploadfilechooserdialog", PACKAGE_NAME);
465 PACKAGE_NAME); 443 connectGladeWithPlugins (uploadXML);
466 connectGladeWithPlugins(uploadXML); 444 dialog = GTK_FILE_CHOOSER (glade_xml_get_widget (uploadXML,
467 dialog = GTK_FILE_CHOOSER(glade_xml_get_widget(uploadXML, 445 "uploadfilechooserdialog"));
468 "uploadfilechooserdialog")); 446 gtk_file_chooser_set_filename (dialog, oldfilename);
469 gtk_file_chooser_set_filename(dialog, 447 if (getToggleButtonValue (getMainXML (), "scopeRecursiveButton"))
470 oldfilename); 448 gtk_file_chooser_set_action (dialog,
471 if (getToggleButtonValue(getMainXML(), 449 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
472 "scopeRecursiveButton")) 450 if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_CANCEL)
473 gtk_file_chooser_set_action(dialog, 451 ret = gtk_file_chooser_get_filename (dialog);
474 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
475 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL)
476 ret = gtk_file_chooser_get_filename(dialog);
477 else 452 else
478 ret = NULL; 453 ret = NULL;
479 gtk_widget_destroy(GTK_WIDGET(dialog)); 454 gtk_widget_destroy (GTK_WIDGET (dialog));
480 UNREF(uploadXML); 455 UNREF (uploadXML);
481 return ret; 456 return ret;
482} 457}
483 458
484#else /* MINGW */ 459#else /* MINGW */
485 460
486static char * 461static char *
487selectFile(const char * oldfilename) { 462selectFile (const char *oldfilename)
488 if (getToggleButtonValue(getMainXML(), 463{
489 "scopeFileOnlyButton")) 464 if (getToggleButtonValue (getMainXML (), "scopeFileOnlyButton"))
490 return plibc_ChooseFile(_("Choose the file you want to publish."), 465 return plibc_ChooseFile (_("Choose the file you want to publish."),
491 OFN_FILEMUSTEXIST | OFN_SHAREAWARE); 466 OFN_FILEMUSTEXIST | OFN_SHAREAWARE);
492 return plibc_ChooseDir(_("Choose the directory you want to publish."), 467 return plibc_ChooseDir (_("Choose the directory you want to publish."),
493 BIF_USENEWUI | BIF_SHAREABLE | BIF_NONEWFOLDERBUTTON); 468 BIF_USENEWUI | BIF_SHAREABLE |
469 BIF_NONEWFOLDERBUTTON);
494} 470}
495#endif /* MINGW */ 471#endif /* MINGW */
496 472
497void on_mainFileSharingInsertBrowseButton_clicked_fs(GtkWidget * browseButton, 473void
498 gpointer dummy) { 474on_mainFileSharingInsertBrowseButton_clicked_fs (GtkWidget * browseButton,
499 char * filename; 475 gpointer dummy)
500 char * ofn; 476{
477 char *filename;
478 char *ofn;
501 const char *oldfilename; 479 const char *oldfilename;
502 GtkWidget * uploadLine; 480 GtkWidget *uploadLine;
503 GtkEntry * entry; 481 GtkEntry *entry;
504 GtkListStore * model; 482 GtkListStore *model;
505 GtkTreeIter iter; 483 GtkTreeIter iter;
506 484
507 uploadLine = glade_xml_get_widget(getMainXML(), 485 uploadLine = glade_xml_get_widget (getMainXML (),
508 "uploadFilenameComboBoxEntry"); 486 "uploadFilenameComboBoxEntry");
509 entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(uploadLine))); 487 entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (uploadLine)));
510 oldfilename = gtk_entry_get_text(entry); 488 oldfilename = gtk_entry_get_text (entry);
511 if (oldfilename == NULL) 489 if (oldfilename == NULL)
512 oldfilename = getenv("PWD"); 490 oldfilename = getenv ("PWD");
513 if (oldfilename == NULL) 491 if (oldfilename == NULL)
514 oldfilename = getenv("HOME"); 492 oldfilename = getenv ("HOME");
515 if (oldfilename == NULL) 493 if (oldfilename == NULL)
516 oldfilename = "/"; 494 oldfilename = "/";
517 ofn = string_expandFileName(ectx, oldfilename); 495 ofn = string_expandFileName (ectx, oldfilename);
518 filename = selectFile(ofn); 496 filename = selectFile (ofn);
519 FREE(ofn); 497 FREE (ofn);
520 if (NULL == filename) 498 if (NULL == filename)
521 return; 499 return;
522 gtk_entry_set_text(entry, 500 gtk_entry_set_text (entry, filename);
523 filename); 501 model =
524 model = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(uploadLine))); 502 GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (uploadLine)));
525 gtk_list_store_prepend(model, 503 gtk_list_store_prepend (model, &iter);
526 &iter); 504 gtk_list_store_set (model, &iter, 0, filename, -1);
527 gtk_list_store_set(model, 505 free (filename);
528 &iter,
529 0,
530 filename,
531 -1);
532 free(filename);
533} 506}
534 507
535struct FCBC { 508struct FCBC
536 int (*method)(struct FSUI_Context * ctx, 509{
537 struct FSUI_UploadList * list); 510 int (*method) (struct FSUI_Context * ctx, struct FSUI_UploadList * list);
538 struct FSUI_UploadList * argument; 511 struct FSUI_UploadList *argument;
539}; 512};
540 513
541static void * fsui_callback(void * cls) { 514static void *
542 struct FCBC * fcbc = cls; 515fsui_callback (void *cls)
543 fcbc->method(ctx, 516{
544 fcbc->argument); 517 struct FCBC *fcbc = cls;
518 fcbc->method (ctx, fcbc->argument);
545 return NULL; 519 return NULL;
546} 520}
547 521
548static void 522static void
549clearCompletedUploadCallback(GtkTreeModel * model, 523clearCompletedUploadCallback (GtkTreeModel * model,
550 GtkTreePath * path, 524 GtkTreePath * path,
551 GtkTreeIter * iter, 525 GtkTreeIter * iter, gpointer unused)
552 gpointer unused) { 526{
553 UploadList * ul; 527 UploadList *ul;
554 struct FCBC fcbc; 528 struct FCBC fcbc;
555 529
556 GE_ASSERT(ectx, 530 GE_ASSERT (ectx, model == GTK_TREE_MODEL (upload_summary));
557 model == GTK_TREE_MODEL(upload_summary)); 531 gtk_tree_model_get (model, iter, UPLOAD_INTERNAL, &ul, -1);
558 gtk_tree_model_get(model, 532 if ((ul->has_terminated) && (ul->is_top))
559 iter, 533 {
560 UPLOAD_INTERNAL, &ul, 534 fcbc.method = &FSUI_stopUpload;
561 -1); 535 fcbc.argument = ul->fsui_list;
562 if ( (ul->has_terminated) && 536 run_with_save_calls (&fsui_callback, &fcbc);
563 (ul->is_top) ) { 537 }
564 fcbc.method = &FSUI_stopUpload;
565 fcbc.argument = ul->fsui_list;
566 run_with_save_calls(&fsui_callback,
567 &fcbc);
568 }
569} 538}
570 539
571/** 540/**
572 * The user has edited the search entry. 541 * The user has edited the search entry.
573 * Update search button status. 542 * Update search button status.
574 */ 543 */
575void on_uploadFilenameComboBoxEntry_changed_fs(gpointer dummy2, 544void
576 GtkWidget * searchEntry) { 545on_uploadFilenameComboBoxEntry_changed_fs (gpointer dummy2,
577 const char * filename; 546 GtkWidget * searchEntry)
578 GtkWidget * uploadButton; 547{
548 const char *filename;
549 GtkWidget *uploadButton;
579 struct stat buf; 550 struct stat buf;
580 int ok; 551 int ok;
581 GtkWidget * toggle; 552 GtkWidget *toggle;
582 553
583 filename = getEntryLineValue(getMainXML(), 554 filename = getEntryLineValue (getMainXML (), "uploadFilenameComboBoxEntry");
584 "uploadFilenameComboBoxEntry"); 555 ok = (0 == stat (filename, &buf));
585 ok = (0 == stat(filename, &buf)); 556 if (ok)
557 ok = (0 == ACCESS (filename, R_OK));
586 if (ok) 558 if (ok)
587 ok = (0 == ACCESS(filename, R_OK)); 559 {
588 if (ok) { 560 if (S_ISDIR (buf.st_mode))
589 if (S_ISDIR(buf.st_mode)) { 561 {
590 toggle = glade_xml_get_widget(getMainXML(), 562 toggle = glade_xml_get_widget (getMainXML (),
591 "scopeRecursiveButton"); 563 "scopeRecursiveButton");
592 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), 564 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), 1);
593 1); 565 }
594 } else { 566 else
595 toggle = glade_xml_get_widget(getMainXML(), 567 {
596 "scopeFileOnlyButton"); 568 toggle = glade_xml_get_widget (getMainXML (),
597 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), 569 "scopeFileOnlyButton");
598 1); 570 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), 1);
571 }
599 } 572 }
600 } 573 uploadButton = glade_xml_get_widget (getMainXML (), "fsinsertuploadbutton");
601 uploadButton 574 gtk_widget_set_sensitive (uploadButton, ok);
602 = glade_xml_get_widget(getMainXML(),
603 "fsinsertuploadbutton");
604 gtk_widget_set_sensitive(uploadButton,
605 ok);
606} 575}
607 576
608void on_clearCompletedUploadsButton_clicked_fs(void * unused, 577void
609 GtkWidget * clearButton) { 578on_clearCompletedUploadsButton_clicked_fs (void *unused,
610 ggc_tree_model_foreach(GTK_TREE_MODEL(upload_summary), 579 GtkWidget * clearButton)
611 &clearCompletedUploadCallback, 580{
612 NULL); 581 ggc_tree_model_foreach (GTK_TREE_MODEL (upload_summary),
582 &clearCompletedUploadCallback, NULL);
613} 583}
614 584
615static void 585static void
616fsuiCallUploadCallback(GtkTreeModel * model, 586fsuiCallUploadCallback (GtkTreeModel * model,
617 GtkTreePath * path, 587 GtkTreePath * path,
618 GtkTreeIter * iter, 588 GtkTreeIter * iter, gpointer fsui_call)
619 gpointer fsui_call) { 589{
620 UploadList * ul; 590 UploadList *ul;
621 struct FCBC fcbc; 591 struct FCBC fcbc;
622 592
623 GE_ASSERT(ectx, 593 GE_ASSERT (ectx, model == GTK_TREE_MODEL (upload_summary));
624 model == GTK_TREE_MODEL(upload_summary)); 594 gtk_tree_model_get (model, iter, UPLOAD_INTERNAL, &ul, -1);
625 gtk_tree_model_get(model,
626 iter,
627 UPLOAD_INTERNAL, &ul,
628 -1);
629 fcbc.method = fsui_call; 595 fcbc.method = fsui_call;
630 fcbc.argument = ul->fsui_list; 596 fcbc.argument = ul->fsui_list;
631 run_with_save_calls(&fsui_callback, 597 run_with_save_calls (&fsui_callback, &fcbc);
632 &fcbc);
633} 598}
634 599
635void on_abortUploadButton_clicked_fs(void * unused, 600void
636 GtkWidget * clearButton) { 601on_abortUploadButton_clicked_fs (void *unused, GtkWidget * clearButton)
637 GtkTreeSelection * selection; 602{
638 GtkWidget * uploadList; 603 GtkTreeSelection *selection;
604 GtkWidget *uploadList;
639 605
640 uploadList = glade_xml_get_widget(getMainXML(), 606 uploadList = glade_xml_get_widget (getMainXML (), "activeUploadsList");
641 "activeUploadsList"); 607 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (uploadList));
642 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(uploadList));
643 ggc_tree_selection_selected_foreach 608 ggc_tree_selection_selected_foreach
644 (selection, 609 (selection, &fsuiCallUploadCallback, &FSUI_abortUpload);
645 &fsuiCallUploadCallback,
646 &FSUI_abortUpload);
647} 610}
648 611
649void on_stopUploadButton_clicked_fs(void * unused, 612void
650 GtkWidget * clearButton) { 613on_stopUploadButton_clicked_fs (void *unused, GtkWidget * clearButton)
651 GtkTreeSelection * selection; 614{
652 GtkWidget * uploadList; 615 GtkTreeSelection *selection;
616 GtkWidget *uploadList;
653 617
654 uploadList = glade_xml_get_widget(getMainXML(), 618 uploadList = glade_xml_get_widget (getMainXML (), "activeUploadsList");
655 "activeUploadsList"); 619 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (uploadList));
656 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(uploadList));
657 ggc_tree_selection_selected_foreach 620 ggc_tree_selection_selected_foreach
658 (selection, 621 (selection, &fsuiCallUploadCallback, &FSUI_abortUpload);
659 &fsuiCallUploadCallback,
660 &FSUI_abortUpload);
661 ggc_tree_selection_selected_foreach 622 ggc_tree_selection_selected_foreach
662 (selection, 623 (selection, &fsuiCallUploadCallback, &FSUI_stopUpload);
663 &fsuiCallUploadCallback,
664 &FSUI_stopUpload);
665} 624}
666 625
667 626
diff --git a/src/plugins/fs/upload.h b/src/plugins/fs/upload.h
index 69e2e49d..b88f05d1 100644
--- a/src/plugins/fs/upload.h
+++ b/src/plugins/fs/upload.h
@@ -29,26 +29,23 @@
29 29
30#include "fs.h" 30#include "fs.h"
31 31
32void fs_upload_update(UploadList * list, 32void fs_upload_update (UploadList * list, unsigned long long completed);
33 unsigned long long completed);
34 33
35void fs_upload_complete(UploadList * list, 34void fs_upload_complete (UploadList * list, struct ECRS_URI *uri);
36 struct ECRS_URI * uri);
37 35
38void fs_upload_error(UploadList * list); 36void fs_upload_error (UploadList * list);
39 37
40void fs_upload_stopped(UploadList * list); 38void fs_upload_stopped (UploadList * list);
41 39
42/** 40/**
43 * @param uri NULL if upload is not yet finished 41 * @param uri NULL if upload is not yet finished
44 */ 42 */
45UploadList * 43UploadList *fs_upload_started (struct FSUI_UploadList *fsui,
46fs_upload_started(struct FSUI_UploadList * fsui, 44 UploadList * parent,
47 UploadList * parent, 45 const char *filename,
48 const char * filename, 46 struct ECRS_URI *uri,
49 struct ECRS_URI * uri, 47 unsigned long long total,
50 unsigned long long total, 48 unsigned long long completed,
51 unsigned long long completed, 49 FSUI_State state);
52 FSUI_State state);
53 50
54#endif 51#endif
diff --git a/src/plugins/peers/peers.c b/src/plugins/peers/peers.c
index ae8dee56..9e5cbac0 100644
--- a/src/plugins/peers/peers.c
+++ b/src/plugins/peers/peers.c
@@ -36,121 +36,118 @@
36 36
37#define REFRESH_RATE (15 * cronSECONDS) 37#define REFRESH_RATE (15 * cronSECONDS)
38 38
39static struct CronManager * cron; 39static struct CronManager *cron;
40 40
41static struct GE_Context * ectx; 41static struct GE_Context *ectx;
42 42
43static struct GC_Configuration * cfg; 43static struct GC_Configuration *cfg;
44 44
45static GdkPixbuf * green; 45static GdkPixbuf *green;
46 46
47static GdkPixbuf * yellow; 47static GdkPixbuf *yellow;
48 48
49static GdkPixbuf * red; 49static GdkPixbuf *red;
50 50
51static GdkPixbuf * black; 51static GdkPixbuf *black;
52 52
53static int collector(void * data, 53static int
54 const PeerIdentity * identity, 54collector (void *data,
55 const void * address, 55 const PeerIdentity * identity,
56 unsigned int addr_len, 56 const void *address,
57 cron_t last_message, 57 unsigned int addr_len,
58 unsigned int trust, 58 cron_t last_message, unsigned int trust, unsigned int bpmFromPeer)
59 unsigned int bpmFromPeer) { 59{
60 GtkListStore * model = data; 60 GtkListStore *model = data;
61 GtkTreeIter iter; 61 GtkTreeIter iter;
62 EncName enc; 62 EncName enc;
63 GdkPixbuf * ledBuf; 63 GdkPixbuf *ledBuf;
64 GdkPixbuf * flagBuf; 64 GdkPixbuf *flagBuf;
65 char * cc; 65 char *cc;
66 char * dir; 66 char *dir;
67 char * fn; 67 char *fn;
68 char * prefix; 68 char *prefix;
69 char * have; 69 char *have;
70 char * haddress; 70 char *haddress;
71 char * hostname; 71 char *hostname;
72 cron_t now; 72 cron_t now;
73 int i; 73 int i;
74 int found; 74 int found;
75 75
76 hash2enc(&identity->hashPubKey, 76 hash2enc (&identity->hashPubKey, &enc);
77 &enc);
78 /* check if same peer is already in model! */ 77 /* check if same peer is already in model! */
79 found = NO; 78 found = NO;
80 if (TRUE == gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), 79 if (TRUE == gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter))
81 &iter)) { 80 {
82 do { 81 do
83 gtk_tree_model_get(GTK_TREE_MODEL(model), 82 {
84 &iter, 83 gtk_tree_model_get (GTK_TREE_MODEL (model),
85 0, &haddress, 84 &iter, 0, &haddress, 3, &have, -1);
86 3, &have, 85 if (have != NULL)
87 -1); 86 {
88 if (have != NULL) { 87 if (0 == strcmp (have, (char *) &enc))
89 if (0 == strcmp(have, (char*) &enc)) { 88 {
90 if (strlen(haddress) > 0) { 89 if (strlen (haddress) > 0)
91 FREE(have); 90 {
92 FREE(haddress); 91 FREE (have);
93 return OK; 92 FREE (haddress);
94 } 93 return OK;
95 found = YES; 94 }
96 } 95 found = YES;
97 FREENONNULL(haddress); 96 }
98 FREE(have); 97 FREENONNULL (haddress);
99 } 98 FREE (have);
100 } while ( (found == NO) && 99 }
101 (TRUE == gtk_tree_model_iter_next(GTK_TREE_MODEL(model), 100 }
102 &iter)) ); 101 while ((found == NO) &&
103 } 102 (TRUE == gtk_tree_model_iter_next (GTK_TREE_MODEL (model),
104 103 &iter)));
105 hostname = network_get_ip_as_string(address, 104 }
106 addr_len, 105
107 YES); 106 hostname = network_get_ip_as_string (address, addr_len, YES);
108 if (hostname == NULL) 107 if (hostname == NULL)
109 hostname = STRDUP("NAT"); 108 hostname = STRDUP ("NAT");
110 /* get flag */ 109 /* get flag */
111 flagBuf = NULL; 110 flagBuf = NULL;
112 ledBuf = NULL; 111 ledBuf = NULL;
113 cc = NULL; 112 cc = NULL;
114 prefix = STRDUP(hostname); 113 prefix = STRDUP (hostname);
115 if (strstr(prefix, " ") != NULL) 114 if (strstr (prefix, " ") != NULL)
116 *strstr(prefix, " ") = '\0'; 115 *strstr (prefix, " ") = '\0';
117 cc = prefix; 116 cc = prefix;
118 while (strstr(cc, ".") != NULL) 117 while (strstr (cc, ".") != NULL)
119 cc = strstr(cc, ".") + 1; 118 cc = strstr (cc, ".") + 1;
120 if (strstr(hostname, ".") == NULL) 119 if (strstr (hostname, ".") == NULL)
121 cc = NULL; 120 cc = NULL;
122 else if ( (0 == strcasecmp(cc, "edu")) || 121 else if ((0 == strcasecmp (cc, "edu")) ||
123 (0 == strcasecmp(cc, "com")) || 122 (0 == strcasecmp (cc, "com")) ||
124 (0 == strcasecmp(cc, "net")) || 123 (0 == strcasecmp (cc, "net")) ||
125 (0 == strcasecmp(cc, "org")) || 124 (0 == strcasecmp (cc, "org")) ||
126 (0 == strcasecmp(cc, "gov")) || 125 (0 == strcasecmp (cc, "gov")) || (0 == strcasecmp (cc, "mil")))
127 (0 == strcasecmp(cc, "mil")) )
128 cc = "us"; 126 cc = "us";
129 if ( (cc != NULL) && 127 if ((cc != NULL) && (strlen (cc) > 2))
130 (strlen(cc) > 2) )
131 cc = NULL; 128 cc = NULL;
132 if (cc != NULL) { 129 if (cc != NULL)
133 cc = STRDUP(cc); 130 {
134 for (i=0;i<strlen(cc);i++) 131 cc = STRDUP (cc);
135 cc[i] = tolower(cc[i]); 132 for (i = 0; i < strlen (cc); i++)
136 dir = os_get_installation_path(IPK_DATADIR); 133 cc[i] = tolower (cc[i]);
137 fn = MALLOC(strlen(dir) + 32); 134 dir = os_get_installation_path (IPK_DATADIR);
138 strcpy(fn, dir); 135 fn = MALLOC (strlen (dir) + 32);
139 strcat(fn, 136 strcpy (fn, dir);
140 DIR_SEPARATOR_STR ".." 137 strcat (fn,
141 DIR_SEPARATOR_STR "gnunet-gtk" 138 DIR_SEPARATOR_STR ".."
142 DIR_SEPARATOR_STR "flags" 139 DIR_SEPARATOR_STR "gnunet-gtk"
143 DIR_SEPARATOR_STR); 140 DIR_SEPARATOR_STR "flags" DIR_SEPARATOR_STR);
144 strcat(fn, cc); 141 strcat (fn, cc);
145 strcat(fn, ".png"); 142 strcat (fn, ".png");
146 FREE(dir); 143 FREE (dir);
147 flagBuf = gdk_pixbuf_new_from_file(fn, NULL); 144 flagBuf = gdk_pixbuf_new_from_file (fn, NULL);
148 FREE(fn); 145 FREE (fn);
149 } 146 }
150 FREE(prefix); 147 FREE (prefix);
151 148
152 /* get LED */ 149 /* get LED */
153 now = get_time(); 150 now = get_time ();
154 if (last_message + 150 * cronSECONDS > now) 151 if (last_message + 150 * cronSECONDS > now)
155 ledBuf = green; 152 ledBuf = green;
156 else if (last_message + 5 * cronMINUTES > now) 153 else if (last_message + 5 * cronMINUTES > now)
@@ -160,25 +157,20 @@ static int collector(void * data,
160 else 157 else
161 ledBuf = black; 158 ledBuf = black;
162 if (ledBuf != NULL) 159 if (ledBuf != NULL)
163 g_object_ref(ledBuf); 160 g_object_ref (ledBuf);
164 161
165 /* add to model */ 162 /* add to model */
166 if (found == NO) 163 if (found == NO)
167 gtk_list_store_append(model, 164 gtk_list_store_append (model, &iter);
168 &iter); 165 gtk_list_store_set (model,
169 gtk_list_store_set(model, 166 &iter,
170 &iter, 167 0, hostname,
171 0, hostname, 168 1, trust,
172 1, trust, 169 2, bpmFromPeer,
173 2, bpmFromPeer, 170 3, (const char *) &enc,
174 3, (const char*) &enc, 171 4, ledBuf, 5, flagBuf, 6, cc, 7, last_message, -1);
175 4, ledBuf, 172 FREENONNULL (cc);
176 5, flagBuf, 173 FREE (hostname);
177 6, cc,
178 7, last_message,
179 -1);
180 FREENONNULL(cc);
181 FREE(hostname);
182 return OK; 174 return OK;
183} 175}
184 176
@@ -187,26 +179,26 @@ static int collector(void * data,
187/** 179/**
188 * Compute an updated peer model. 180 * Compute an updated peer model.
189 */ 181 */
190static void * getPeerModel() { 182static void *
191 struct ClientServerConnection * sock; 183getPeerModel ()
192 GtkListStore * model; 184{
193 185 struct ClientServerConnection *sock;
194 model = gtk_list_store_new(8, 186 GtkListStore *model;
195 G_TYPE_STRING, /* address */ 187
196 G_TYPE_UINT, /* trust */ 188 model = gtk_list_store_new (8, G_TYPE_STRING, /* address */
197 G_TYPE_UINT, /* bpm */ 189 G_TYPE_UINT, /* trust */
198 G_TYPE_STRING, /* identity */ 190 G_TYPE_UINT, /* bpm */
199 GDK_TYPE_PIXBUF, /* LED */ 191 G_TYPE_STRING, /* identity */
200 GDK_TYPE_PIXBUF, /* flag */ 192 GDK_TYPE_PIXBUF, /* LED */
201 G_TYPE_STRING, /* country name */ 193 GDK_TYPE_PIXBUF, /* flag */
202 G_TYPE_UINT64); /* last time seen */ 194 G_TYPE_STRING, /* country name */
203 sock = client_connection_create(ectx, cfg); 195 G_TYPE_UINT64); /* last time seen */
204 if (sock != NULL) { 196 sock = client_connection_create (ectx, cfg);
205 gnunet_identity_request_peer_infos(sock, 197 if (sock != NULL)
206 &collector, 198 {
207 model); 199 gnunet_identity_request_peer_infos (sock, &collector, model);
208 connection_destroy(sock); 200 connection_destroy (sock);
209 } 201 }
210 return model; 202 return model;
211} 203}
212 204
@@ -214,197 +206,175 @@ static void * getPeerModel() {
214/** 206/**
215 * Update the model for the peers list. 207 * Update the model for the peers list.
216 */ 208 */
217static void * updatePeerInfoSafe(void * m) { 209static void *
218 GtkListStore * model = m; 210updatePeerInfoSafe (void *m)
219 GtkTreeModel * old_model; 211{
220 GtkWidget * w; 212 GtkListStore *model = m;
213 GtkTreeModel *old_model;
214 GtkWidget *w;
221 GtkSortType order; 215 GtkSortType order;
222 gint sort_column; 216 gint sort_column;
223 217
224 w = glade_xml_get_widget(getMainXML(), 218 w = glade_xml_get_widget (getMainXML (), "peersTreeView");
225 "peersTreeView"); 219 old_model = gtk_tree_view_get_model (GTK_TREE_VIEW (w));
226 old_model = gtk_tree_view_get_model(GTK_TREE_VIEW(w)); 220 if (old_model != NULL)
227 if (old_model != NULL) { 221 {
228 if (TRUE == gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(old_model), 222 if (TRUE ==
229 &sort_column, 223 gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (old_model),
230 &order)) 224 &sort_column, &order))
231 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), 225 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
232 sort_column, 226 sort_column, order);
233 order); 227 }
234 } 228 gtk_tree_view_set_model (GTK_TREE_VIEW (w), GTK_TREE_MODEL (model));
235 gtk_tree_view_set_model(GTK_TREE_VIEW(w), 229 gtk_tree_selection_set_mode (gtk_tree_view_get_selection
236 GTK_TREE_MODEL(model)); 230 (GTK_TREE_VIEW (w)), GTK_SELECTION_NONE);
237 gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(w)),
238 GTK_SELECTION_NONE);
239 return NULL; 231 return NULL;
240} 232}
241 233
242static void updatePeerInfo(void * dummy) { 234static void
243 GtkListStore * model; 235updatePeerInfo (void *dummy)
236{
237 GtkListStore *model;
244 238
245 model = getPeerModel(); 239 model = getPeerModel ();
246 gtkSaveCall(&updatePeerInfoSafe, model); 240 gtkSaveCall (&updatePeerInfoSafe, model);
247} 241}
248 242
249 243
250void init_peers(struct GE_Context * e, 244void
251 struct GC_Configuration * c) { 245init_peers (struct GE_Context *e, struct GC_Configuration *c)
252 GtkWidget * tab; 246{
253 GtkWidget * peers; 247 GtkWidget *tab;
254 GtkCellRenderer * renderer; 248 GtkWidget *peers;
249 GtkCellRenderer *renderer;
255 int col; 250 int col;
256 GtkTreeViewColumn * column; 251 GtkTreeViewColumn *column;
257 char * dir; 252 char *dir;
258 char * fn; 253 char *fn;
259 254
260 ectx = e; 255 ectx = e;
261 cfg = c; 256 cfg = c;
262 peers 257 peers = glade_xml_get_widget (getMainXML (), "peersTreeView");
263 = glade_xml_get_widget(getMainXML(), 258 renderer = gtk_cell_renderer_text_new ();
264 "peersTreeView"); 259 col = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (peers),
265 renderer = gtk_cell_renderer_text_new(); 260 -1,
266 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(peers), 261 _("Address"),
267 -1, 262 renderer,
268 _("Address"), 263 "text", 0, NULL);
269 renderer, 264 column = gtk_tree_view_get_column (GTK_TREE_VIEW (peers), col - 1);
270 "text", 0, 265 gtk_tree_view_column_set_resizable (column, TRUE);
271 NULL); 266 gtk_tree_view_column_set_clickable (column, TRUE);
272 column = gtk_tree_view_get_column(GTK_TREE_VIEW(peers), 267 gtk_tree_view_column_set_reorderable (column, TRUE);
273 col - 1); 268 gtk_tree_view_column_set_sort_column_id (column, 0);
274 gtk_tree_view_column_set_resizable(column, TRUE); 269
275 gtk_tree_view_column_set_clickable(column, TRUE); 270 renderer = gtk_cell_renderer_text_new ();
276 gtk_tree_view_column_set_reorderable(column, TRUE); 271 col = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (peers),
277 gtk_tree_view_column_set_sort_column_id(column, 0); 272 -1,
278 273 _("Trust"),
279 renderer = gtk_cell_renderer_text_new(); 274 renderer,
280 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(peers), 275 "text", 1, NULL);
281 -1, 276 column = gtk_tree_view_get_column (GTK_TREE_VIEW (peers), col - 1);
282 _("Trust"), 277 gtk_tree_view_column_set_resizable (column, TRUE);
283 renderer, 278 gtk_tree_view_column_set_clickable (column, TRUE);
284 "text", 1, 279 gtk_tree_view_column_set_reorderable (column, TRUE);
285 NULL); 280 gtk_tree_view_column_set_sort_column_id (column, 1);
286 column = gtk_tree_view_get_column(GTK_TREE_VIEW(peers), 281
287 col - 1); 282 renderer = gtk_cell_renderer_text_new ();
288 gtk_tree_view_column_set_resizable(column, TRUE); 283 col = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (peers),
289 gtk_tree_view_column_set_clickable(column, TRUE); 284 -1,
290 gtk_tree_view_column_set_reorderable(column, TRUE); 285 _("Bandwidth"),
291 gtk_tree_view_column_set_sort_column_id(column, 1); 286 renderer,
292 287 "text", 2, NULL);
293 renderer = gtk_cell_renderer_text_new(); 288 column = gtk_tree_view_get_column (GTK_TREE_VIEW (peers), col - 1);
294 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(peers), 289 gtk_tree_view_column_set_resizable (column, TRUE);
295 -1, 290 gtk_tree_view_column_set_clickable (column, TRUE);
296 _("Bandwidth"), 291 gtk_tree_view_column_set_reorderable (column, TRUE);
297 renderer, 292 gtk_tree_view_column_set_sort_column_id (column, 2);
298 "text", 2, 293
299 NULL); 294
300 column = gtk_tree_view_get_column(GTK_TREE_VIEW(peers), 295 renderer = gtk_cell_renderer_pixbuf_new ();
301 col - 1); 296 col = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (peers),
302 gtk_tree_view_column_set_resizable(column, TRUE); 297 -1,
303 gtk_tree_view_column_set_clickable(column, TRUE); 298 _("Country"),
304 gtk_tree_view_column_set_reorderable(column, TRUE); 299 renderer,
305 gtk_tree_view_column_set_sort_column_id(column, 2); 300 "pixbuf", 5, NULL);
306 301 column = gtk_tree_view_get_column (GTK_TREE_VIEW (peers), col - 1);
307 302 gtk_tree_view_column_set_resizable (column, FALSE);
308 renderer = gtk_cell_renderer_pixbuf_new(); 303 gtk_tree_view_column_set_clickable (column, TRUE);
309 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(peers), 304 gtk_tree_view_column_set_reorderable (column, TRUE);
310 -1, 305 gtk_tree_view_column_set_sort_column_id (column, 6);
311 _("Country"), 306
312 renderer, 307 renderer = gtk_cell_renderer_pixbuf_new ();
313 "pixbuf", 5, 308 col = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (peers),
314 NULL); 309 -1,
315 column = gtk_tree_view_get_column(GTK_TREE_VIEW(peers), 310 _("Status"),
316 col - 1); 311 renderer,
317 gtk_tree_view_column_set_resizable(column, FALSE); 312 "pixbuf", 4, NULL);
318 gtk_tree_view_column_set_clickable(column, TRUE); 313 column = gtk_tree_view_get_column (GTK_TREE_VIEW (peers), col - 1);
319 gtk_tree_view_column_set_reorderable(column, TRUE); 314 gtk_tree_view_column_set_clickable (column, TRUE);
320 gtk_tree_view_column_set_sort_column_id(column, 6); 315 gtk_tree_view_column_set_reorderable (column, TRUE);
321 316 gtk_tree_view_column_set_sort_column_id (column, 7);
322 renderer = gtk_cell_renderer_pixbuf_new(); 317 gtk_tree_view_column_set_resizable (column, FALSE);
323 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(peers), 318
324 -1, 319 renderer = gtk_cell_renderer_text_new ();
325 _("Status"), 320 col = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (peers),
326 renderer, 321 -1,
327 "pixbuf", 4, 322 _("Identity"),
328 NULL); 323 renderer,
329 column = gtk_tree_view_get_column(GTK_TREE_VIEW(peers), 324 "text", 3, NULL);
330 col - 1); 325 column = gtk_tree_view_get_column (GTK_TREE_VIEW (peers), col - 1);
331 gtk_tree_view_column_set_clickable(column, TRUE); 326 gtk_tree_view_column_set_resizable (column, TRUE);
332 gtk_tree_view_column_set_reorderable(column, TRUE); 327 gtk_tree_view_column_set_clickable (column, TRUE);
333 gtk_tree_view_column_set_sort_column_id(column, 7); 328 gtk_tree_view_column_set_reorderable (column, TRUE);
334 gtk_tree_view_column_set_resizable(column, FALSE); 329 gtk_tree_view_column_set_sort_column_id (column, 3);
335 330
336 renderer = gtk_cell_renderer_text_new(); 331
337 col = gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(peers), 332 dir = os_get_installation_path (IPK_DATADIR);
338 -1, 333 fn = MALLOC (strlen (dir) + 32);
339 _("Identity"), 334 strcpy (fn, dir);
340 renderer, 335 strcat (fn,
341 "text", 3, 336 DIR_SEPARATOR_STR ".."
342 NULL); 337 DIR_SEPARATOR_STR "gnunet-gtk" DIR_SEPARATOR_STR "red.png");
343 column = gtk_tree_view_get_column(GTK_TREE_VIEW(peers), 338 red = gdk_pixbuf_new_from_file (fn, NULL);
344 col - 1); 339
345 gtk_tree_view_column_set_resizable(column, TRUE); 340 strcpy (fn, dir);
346 gtk_tree_view_column_set_clickable(column, TRUE); 341 strcat (fn,
347 gtk_tree_view_column_set_reorderable(column, TRUE); 342 DIR_SEPARATOR_STR ".."
348 gtk_tree_view_column_set_sort_column_id(column, 3); 343 DIR_SEPARATOR_STR "gnunet-gtk" DIR_SEPARATOR_STR "yellow.png");
349 344 yellow = gdk_pixbuf_new_from_file (fn, NULL);
350 345
351 dir = os_get_installation_path(IPK_DATADIR); 346 strcpy (fn, dir);
352 fn = MALLOC(strlen(dir) + 32); 347 strcat (fn,
353 strcpy(fn, dir); 348 DIR_SEPARATOR_STR ".."
354 strcat(fn, 349 DIR_SEPARATOR_STR "gnunet-gtk" DIR_SEPARATOR_STR "green.png");
355 DIR_SEPARATOR_STR ".." 350 green = gdk_pixbuf_new_from_file (fn, NULL);
356 DIR_SEPARATOR_STR "gnunet-gtk" 351
357 DIR_SEPARATOR_STR "red.png"); 352 strcpy (fn, dir);
358 red = gdk_pixbuf_new_from_file(fn, NULL); 353 strcat (fn,
359 354 DIR_SEPARATOR_STR ".."
360 strcpy(fn, dir); 355 DIR_SEPARATOR_STR "gnunet-gtk" DIR_SEPARATOR_STR "black.png");
361 strcat(fn, 356 black = gdk_pixbuf_new_from_file (fn, NULL);
362 DIR_SEPARATOR_STR ".." 357 FREE (fn);
363 DIR_SEPARATOR_STR "gnunet-gtk" 358 FREE (dir);
364 DIR_SEPARATOR_STR "yellow.png"); 359
365 yellow = gdk_pixbuf_new_from_file(fn, NULL); 360 tab = glade_xml_get_widget (getMainXML (), "peersScrolledWindow");
366 361 gtk_widget_show (tab);
367 strcpy(fn, dir); 362 cron = gnunet_gtk_get_cron ();
368 strcat(fn, 363 cron_add_job (cron, &updatePeerInfo, REFRESH_RATE, REFRESH_RATE, NULL);
369 DIR_SEPARATOR_STR ".."
370 DIR_SEPARATOR_STR "gnunet-gtk"
371 DIR_SEPARATOR_STR "green.png");
372 green = gdk_pixbuf_new_from_file(fn, NULL);
373
374 strcpy(fn, dir);
375 strcat(fn,
376 DIR_SEPARATOR_STR ".."
377 DIR_SEPARATOR_STR "gnunet-gtk"
378 DIR_SEPARATOR_STR "black.png");
379 black = gdk_pixbuf_new_from_file(fn, NULL);
380 FREE(fn);
381 FREE(dir);
382
383 tab
384 = glade_xml_get_widget(getMainXML(),
385 "peersScrolledWindow");
386 gtk_widget_show(tab);
387 cron = gnunet_gtk_get_cron();
388 cron_add_job(cron,
389 &updatePeerInfo,
390 REFRESH_RATE,
391 REFRESH_RATE,
392 NULL);
393} 364}
394 365
395void done_peers() { 366void
396 cron_del_job(cron, 367done_peers ()
397 &updatePeerInfo, 368{
398 REFRESH_RATE, 369 cron_del_job (cron, &updatePeerInfo, REFRESH_RATE, NULL);
399 NULL);
400 if (red != NULL) 370 if (red != NULL)
401 g_object_unref(red); 371 g_object_unref (red);
402 if (green != NULL) 372 if (green != NULL)
403 g_object_unref(green); 373 g_object_unref (green);
404 if (black != NULL) 374 if (black != NULL)
405 g_object_unref(black); 375 g_object_unref (black);
406 if (yellow != NULL) 376 if (yellow != NULL)
407 g_object_unref(yellow); 377 g_object_unref (yellow);
408} 378}
409 379
410 380
diff --git a/src/plugins/stats/functions.c b/src/plugins/stats/functions.c
index 5b6e2542..9c5e90db 100644
--- a/src/plugins/stats/functions.c
+++ b/src/plugins/stats/functions.c
@@ -29,13 +29,13 @@
29 29
30#define FUNCTIONS_DEBUG NO 30#define FUNCTIONS_DEBUG NO
31 31
32static StatPair * lastStatValues; 32static StatPair *lastStatValues;
33 33
34static unsigned int lsv_size; 34static unsigned int lsv_size;
35 35
36static struct ClientServerConnection * sock; 36static struct ClientServerConnection *sock;
37 37
38static struct MUTEX * lock; 38static struct MUTEX *lock;
39 39
40static long connectionGoal; 40static long connectionGoal;
41 41
@@ -43,126 +43,106 @@ static long long banddown;
43 43
44static long long bandup; 44static long long bandup;
45 45
46static struct GE_Context * ectx; 46static struct GE_Context *ectx;
47 47
48static struct GC_Configuration * cfg; 48static struct GC_Configuration *cfg;
49 49
50static struct CronManager * cron; 50static struct CronManager *cron;
51 51
52static int getStatValue(long long * value, 52static int
53 long long * lvalue, 53getStatValue (long long *value,
54 cron_t * dtime, 54 long long *lvalue,
55 const char * optName, 55 cron_t * dtime, const char *optName, int monotone)
56 int monotone) { 56{
57 unsigned int i; 57 unsigned int i;
58 58
59 *value = 0; 59 *value = 0;
60 if (lvalue != NULL) 60 if (lvalue != NULL)
61 *lvalue = 0; 61 *lvalue = 0;
62 for (i=0;i<lsv_size;i++) { 62 for (i = 0; i < lsv_size; i++)
63 if (0 == strcmp(optName, 63 {
64 lastStatValues[i].statName)) { 64 if (0 == strcmp (optName, lastStatValues[i].statName))
65 *value = lastStatValues[i].value; 65 {
66 if (lvalue != NULL) 66 *value = lastStatValues[i].value;
67 *lvalue = lastStatValues[i].lvalue; 67 if (lvalue != NULL)
68 if (dtime != NULL) 68 *lvalue = lastStatValues[i].lvalue;
69 *dtime = lastStatValues[i].delta; 69 if (dtime != NULL)
70 if ( (monotone == YES) && 70 *dtime = lastStatValues[i].delta;
71 (lvalue != NULL) && 71 if ((monotone == YES) && (lvalue != NULL) && (*lvalue > *value))
72 (*lvalue > *value) ) 72 return SYSERR; /* gnunetd restart? */
73 return SYSERR; /* gnunetd restart? */ 73 return OK;
74 return OK; 74 }
75 } 75 }
76 }
77#if FUNCTIONS_DEBUG 76#if FUNCTIONS_DEBUG
78 GE_LOG(ectx, 77 GE_LOG (ectx,
79 GE_DEBUG | GE_DEVELOPER | GE_REQUEST, 78 GE_DEBUG | GE_DEVELOPER | GE_REQUEST,
80 "Statistic not found: `%s'\n", 79 "Statistic not found: `%s'\n", optName);
81 optName);
82#endif 80#endif
83 return SYSERR; 81 return SYSERR;
84} 82}
85 83
86static void updateConnectionGoal(void * unused) { 84static void
87 char * cmh; 85updateConnectionGoal (void *unused)
88 char * availableDown; 86{
89 char * availableUp; 87 char *cmh;
90 88 char *availableDown;
91 MUTEX_LOCK(lock); 89 char *availableUp;
92 cmh = getConfigurationOptionValue(sock, 90
93 "gnunetd", 91 MUTEX_LOCK (lock);
94 "connection-max-hosts"); 92 cmh = getConfigurationOptionValue (sock, "gnunetd", "connection-max-hosts");
95 availableDown = getConfigurationOptionValue(sock, 93 availableDown = getConfigurationOptionValue (sock,
96 "LOAD", 94 "LOAD", "MAXNETDOWNBPSTOTAL");
97 "MAXNETDOWNBPSTOTAL"); 95 availableUp = getConfigurationOptionValue (sock,
98 availableUp = getConfigurationOptionValue(sock, 96 "LOAD", "MAXNETUPBPSTOTAL");
99 "LOAD", 97 MUTEX_UNLOCK (lock);
100 "MAXNETUPBPSTOTAL");
101 MUTEX_UNLOCK(lock);
102 if (cmh == NULL) 98 if (cmh == NULL)
103 connectionGoal = 0; 99 connectionGoal = 0;
104 else 100 else
105 connectionGoal = atol(cmh); 101 connectionGoal = atol (cmh);
106 if (availableDown == NULL) 102 if (availableDown == NULL)
107 banddown = 0; 103 banddown = 0;
108 else 104 else
109 banddown = atol(availableDown); 105 banddown = atol (availableDown);
110 if (availableUp == NULL) 106 if (availableUp == NULL)
111 bandup = 0; 107 bandup = 0;
112 else 108 else
113 bandup = atol(availableUp); 109 bandup = atol (availableUp);
114 110
115 FREENONNULL(cmh); 111 FREENONNULL (cmh);
116 FREENONNULL(availableDown); 112 FREENONNULL (availableDown);
117 FREENONNULL(availableUp); 113 FREENONNULL (availableUp);
118} 114}
119 115
120static int getConnectedNodesStat(const void * closure, 116static int
121 gfloat ** data) { 117getConnectedNodesStat (const void *closure, gfloat ** data)
118{
122 long long val; 119 long long val;
123 120
124 if (connectionGoal == 0) 121 if (connectionGoal == 0)
125 return SYSERR; 122 return SYSERR;
126 if (OK != getStatValue(&val, 123 if (OK != getStatValue (&val, NULL, NULL, "# of connected peers", NO))
127 NULL,
128 NULL,
129 "# of connected peers",
130 NO))
131 return SYSERR; 124 return SYSERR;
132 data[0][0] = ((gfloat) val) / connectionGoal; 125 data[0][0] = ((gfloat) val) / connectionGoal;
133 return OK; 126 return OK;
134} 127}
135 128
136static int getLoadStat(const void * closure, 129static int
137 gfloat ** data) { 130getLoadStat (const void *closure, gfloat ** data)
131{
138 long long valc; 132 long long valc;
139 long long vali; 133 long long vali;
140 long long valu; 134 long long valu;
141 long long vald; 135 long long vald;
142 136
143 if (OK != getStatValue(&valc, 137 if (OK != getStatValue (&valc, NULL, NULL, "% of allowed cpu load", NO))
144 NULL,
145 NULL,
146 "% of allowed cpu load",
147 NO))
148 return SYSERR; 138 return SYSERR;
149 if (OK != getStatValue(&vali, 139 if (OK != getStatValue (&vali, NULL, NULL, "% of allowed io load", NO))
150 NULL,
151 NULL,
152 "% of allowed io load",
153 NO))
154 return SYSERR; 140 return SYSERR;
155 if (OK != getStatValue(&valu, 141 if (OK != getStatValue (&valu,
156 NULL, 142 NULL, NULL, "% of allowed network load (up)", NO))
157 NULL,
158 "% of allowed network load (up)",
159 NO))
160 return SYSERR; 143 return SYSERR;
161 if (OK != getStatValue(&vald, 144 if (OK != getStatValue (&vald,
162 NULL, 145 NULL, NULL, "% of allowed network load (down)", NO))
163 NULL,
164 "% of allowed network load (down)",
165 NO))
166 return SYSERR; 146 return SYSERR;
167 data[0][0] = (gfloat) valc / 100.0; 147 data[0][0] = (gfloat) valc / 100.0;
168 data[0][1] = (gfloat) vali / 100.0; 148 data[0][1] = (gfloat) vali / 100.0;
@@ -171,31 +151,26 @@ static int getLoadStat(const void * closure,
171 return OK; 151 return OK;
172} 152}
173 153
174static int getQuotaStat(const void * closure, 154static int
175 gfloat ** data) { 155getQuotaStat (const void *closure, gfloat ** data)
156{
176 long long allowed; 157 long long allowed;
177 long long have; 158 long long have;
178 159
179 if (OK != getStatValue(&allowed, 160 if (OK != getStatValue (&allowed,
180 NULL, 161 NULL, NULL, "# bytes allowed in datastore", NO))
181 NULL,
182 "# bytes allowed in datastore",
183 NO))
184 return SYSERR; 162 return SYSERR;
185 if (allowed == 0) 163 if (allowed == 0)
186 return SYSERR; 164 return SYSERR;
187 if (OK != getStatValue(&have, 165 if (OK != getStatValue (&have, NULL, NULL, "# bytes in datastore", NO))
188 NULL,
189 NULL,
190 "# bytes in datastore",
191 NO))
192 return SYSERR; 166 return SYSERR;
193 data[0][0] = ((gfloat) have) / allowed; 167 data[0][0] = ((gfloat) have) / allowed;
194 return OK; 168 return OK;
195} 169}
196 170
197static int getTrafficRecvStats(const void * closure, 171static int
198 gfloat ** data) { 172getTrafficRecvStats (const void *closure, gfloat ** data)
173{
199 long long total; 174 long long total;
200 long long noise; 175 long long noise;
201 long long content; 176 long long content;
@@ -209,66 +184,40 @@ static int getTrafficRecvStats(const void * closure,
209 long long lhellos; 184 long long lhellos;
210 long long lrlimit; 185 long long lrlimit;
211 cron_t dtime; 186 cron_t dtime;
212 char * buffer; 187 char *buffer;
213 188
214 if (OK != getStatValue(&total, 189 if (OK != getStatValue (&total, &ltotal, &dtime, "# bytes received", YES))
215 &ltotal,
216 &dtime,
217 "# bytes received",
218 YES))
219 return SYSERR; 190 return SYSERR;
220 if (OK != getStatValue(&noise, 191 if (OK != getStatValue (&noise,
221 &lnoise, 192 &lnoise, NULL, "# bytes of noise received", YES))
222 NULL,
223 "# bytes of noise received",
224 YES))
225 return SYSERR; 193 return SYSERR;
226 buffer = MALLOC(512); 194 buffer = MALLOC (512);
227 SNPRINTF(buffer, 195 SNPRINTF (buffer, 512, "# bytes received of type %d", P2P_PROTO_gap_RESULT);
228 512, 196 if (OK != getStatValue (&content, &lcontent, NULL, buffer, YES))
229 "# bytes received of type %d", 197 {
230 P2P_PROTO_gap_RESULT); 198 content = 0;
231 if (OK != getStatValue(&content, 199 lcontent = 0;
232 &lcontent, 200 }
233 NULL, 201 SNPRINTF (buffer, 512, "# bytes received of type %d", p2p_PROTO_hello);
234 buffer, 202 if (OK != getStatValue (&hellos, &lhellos, NULL, buffer, YES))
235 YES)) { 203 {
236 content = 0; 204 hellos = 0;
237 lcontent = 0; 205 lhellos = 0;
238 } 206 }
239 SNPRINTF(buffer, 207 SNPRINTF (buffer, 512, "# bytes received of type %d", P2P_PROTO_gap_QUERY);
240 512, 208 if (OK != getStatValue (&queries, &lqueries, NULL, buffer, YES))
241 "# bytes received of type %d", 209 {
242 p2p_PROTO_hello); 210 queries = 0;
243 if (OK != getStatValue(&hellos, 211 lqueries = 0;
244 &lhellos, 212 }
245 NULL, 213 if (OK != getStatValue (&rlimit,
246 buffer, 214 &lrlimit,
247 YES)) { 215 NULL, "# total bytes per second receive limit", NO))
248 hellos = 0; 216 {
249 lhellos = 0; 217 rlimit = 0;
250 } 218 lrlimit = 0;
251 SNPRINTF(buffer, 219 }
252 512, 220 FREE (buffer);
253 "# bytes received of type %d",
254 P2P_PROTO_gap_QUERY);
255 if (OK != getStatValue(&queries,
256 &lqueries,
257 NULL,
258 buffer,
259 YES)) {
260 queries = 0;
261 lqueries = 0;
262 }
263 if (OK != getStatValue(&rlimit,
264 &lrlimit,
265 NULL,
266 "# total bytes per second receive limit",
267 NO)) {
268 rlimit = 0;
269 lrlimit = 0;
270 }
271 FREE(buffer);
272 if (banddown == 0) 221 if (banddown == 0)
273 return SYSERR; 222 return SYSERR;
274 223
@@ -277,32 +226,31 @@ static int getTrafficRecvStats(const void * closure,
277 queries -= lqueries; 226 queries -= lqueries;
278 content -= lcontent; 227 content -= lcontent;
279 hellos -= lhellos; 228 hellos -= lhellos;
280 if (banddown < 0) { 229 if (banddown < 0)
281 data[0][0] = 0.0; 230 {
282 data[0][1] = 0.0; 231 data[0][0] = 0.0;
283 data[0][2] = 0.0; 232 data[0][1] = 0.0;
284 data[0][3] = 0.0; 233 data[0][2] = 0.0;
285 data[0][4] = 0.0; 234 data[0][3] = 0.0;
286 data[0][5] = 0.0; 235 data[0][4] = 0.0;
287 return OK; 236 data[0][5] = 0.0;
288 } 237 return OK;
289 data[0][0] = ((gfloat) noise) / (banddown * dtime / cronSECONDS); /* red */ 238 }
290 data[0][1] = ((gfloat) (content+noise)) / (banddown * dtime / cronSECONDS); /* green */ 239 data[0][0] = ((gfloat) noise) / (banddown * dtime / cronSECONDS); /* red */
291 data[0][2] = ((gfloat)(queries+content+noise)) / (banddown * dtime / cronSECONDS); /* yellow */ 240 data[0][1] = ((gfloat) (content + noise)) / (banddown * dtime / cronSECONDS); /* green */
292 data[0][3] = ((gfloat)(queries+content+noise+hellos)) / (banddown * dtime / cronSECONDS); /* blue */ 241 data[0][2] = ((gfloat) (queries + content + noise)) / (banddown * dtime / cronSECONDS); /* yellow */
293 data[0][4] = ((gfloat) total) / (banddown * dtime / cronSECONDS); /* gray */ 242 data[0][3] = ((gfloat) (queries + content + noise + hellos)) / (banddown * dtime / cronSECONDS); /* blue */
294 data[0][5] = (gfloat) rlimit / banddown; /* magenta */ 243 data[0][4] = ((gfloat) total) / (banddown * dtime / cronSECONDS); /* gray */
244 data[0][5] = (gfloat) rlimit / banddown; /* magenta */
295#if 0 245#if 0
296 printf("I: %f %f %f %f\n", 246 printf ("I: %f %f %f %f\n", data[0][0], data[0][1], data[0][2]);
297 data[0][0],
298 data[0][1],
299 data[0][2]);
300#endif 247#endif
301 return OK; 248 return OK;
302} 249}
303 250
304static int getTrafficSendStats(const void * closure, 251static int
305 gfloat ** data) { 252getTrafficSendStats (const void *closure, gfloat ** data)
253{
306 long long total; 254 long long total;
307 long long noise; 255 long long noise;
308 long long content; 256 long long content;
@@ -316,66 +264,42 @@ static int getTrafficSendStats(const void * closure,
316 long long lhellos; 264 long long lhellos;
317 long long lslimit; 265 long long lslimit;
318 cron_t dtime; 266 cron_t dtime;
319 char * buffer; 267 char *buffer;
320 268
321 if (OK != getStatValue(&total, 269 if (OK != getStatValue (&total,
322 &ltotal, 270 &ltotal, &dtime, "# bytes transmitted", YES))
323 &dtime,
324 "# bytes transmitted",
325 YES))
326 return SYSERR; 271 return SYSERR;
327 if (OK != getStatValue(&noise, 272 if (OK != getStatValue (&noise, &lnoise, NULL, "# bytes noise sent", YES))
328 &lnoise,
329 NULL,
330 "# bytes noise sent",
331 YES))
332 return SYSERR; 273 return SYSERR;
333 buffer = MALLOC(512); 274 buffer = MALLOC (512);
334 SNPRINTF(buffer, 275 SNPRINTF (buffer,
335 512, 276 512, "# bytes transmitted of type %d", P2P_PROTO_gap_RESULT);
336 "# bytes transmitted of type %d", 277 if (OK != getStatValue (&content, &lcontent, NULL, buffer, YES))
337 P2P_PROTO_gap_RESULT); 278 {
338 if (OK != getStatValue(&content, 279 content = 0;
339 &lcontent, 280 lcontent = 0;
340 NULL, 281 }
341 buffer, 282 SNPRINTF (buffer,
342 YES)) { 283 512, "# bytes transmitted of type %d", P2P_PROTO_gap_QUERY);
343 content = 0; 284 if (OK != getStatValue (&queries, &lqueries, NULL, buffer, YES))
344 lcontent = 0; 285 {
345 } 286 queries = 0;
346 SNPRINTF(buffer, 287 lqueries = 0;
347 512, 288 }
348 "# bytes transmitted of type %d", 289 SNPRINTF (buffer, 512, "# bytes transmitted of type %d", p2p_PROTO_hello);
349 P2P_PROTO_gap_QUERY); 290 if (OK != getStatValue (&hellos, &lhellos, NULL, buffer, YES))
350 if (OK != getStatValue(&queries, 291 {
351 &lqueries, 292 queries = 0;
352 NULL, 293 lqueries = 0;
353 buffer, 294 }
354 YES)) { 295 if (OK != getStatValue (&slimit,
355 queries = 0; 296 &lslimit,
356 lqueries = 0; 297 NULL, "# total bytes per second send limit", NO))
357 } 298 {
358 SNPRINTF(buffer, 299 slimit = 0;
359 512, 300 lslimit = 0;
360 "# bytes transmitted of type %d", 301 }
361 p2p_PROTO_hello); 302 FREE (buffer);
362 if (OK != getStatValue(&hellos,
363 &lhellos,
364 NULL,
365 buffer,
366 YES)) {
367 queries = 0;
368 lqueries = 0;
369 }
370 if (OK != getStatValue(&slimit,
371 &lslimit,
372 NULL,
373 "# total bytes per second send limit",
374 NO)) {
375 slimit = 0;
376 lslimit = 0;
377 }
378 FREE(buffer);
379 if (bandup == 0) 303 if (bandup == 0)
380 return SYSERR; 304 return SYSERR;
381 total -= ltotal; 305 total -= ltotal;
@@ -383,34 +307,32 @@ static int getTrafficSendStats(const void * closure,
383 queries -= lqueries; 307 queries -= lqueries;
384 content -= lcontent; 308 content -= lcontent;
385 hellos -= lhellos; 309 hellos -= lhellos;
386 if (bandup < 0) { 310 if (bandup < 0)
387 data[0][0] = 0.0; 311 {
388 data[0][1] = 0.0; 312 data[0][0] = 0.0;
389 data[0][2] = 0.0; 313 data[0][1] = 0.0;
390 data[0][3] = 0.0; 314 data[0][2] = 0.0;
391 data[0][4] = 0.0; 315 data[0][3] = 0.0;
392 data[0][5] = 0.0; 316 data[0][4] = 0.0;
393 return OK; 317 data[0][5] = 0.0;
394 } 318 return OK;
395 data[0][0] = ((gfloat) noise) / (bandup * dtime / cronSECONDS); /* red */ 319 }
396 data[0][1] = ((gfloat) (noise + content)) / (bandup*dtime / cronSECONDS); /* green */ 320 data[0][0] = ((gfloat) noise) / (bandup * dtime / cronSECONDS); /* red */
397 data[0][2] = ((gfloat) (noise + content + queries)) / (bandup*dtime / cronSECONDS); /* yellow */ 321 data[0][1] = ((gfloat) (noise + content)) / (bandup * dtime / cronSECONDS); /* green */
398 data[0][3] = ((gfloat) (noise + content + queries + hellos)) / (bandup*dtime / cronSECONDS); /* blue */ 322 data[0][2] = ((gfloat) (noise + content + queries)) / (bandup * dtime / cronSECONDS); /* yellow */
399 data[0][4] = ((gfloat) total) / (bandup*dtime / cronSECONDS); /* grey */ 323 data[0][3] = ((gfloat) (noise + content + queries + hellos)) / (bandup * dtime / cronSECONDS); /* blue */
400 data[0][5] = ((gfloat) slimit) / bandup ; /* magenta */ 324 data[0][4] = ((gfloat) total) / (bandup * dtime / cronSECONDS); /* grey */
325 data[0][5] = ((gfloat) slimit) / bandup; /* magenta */
401#if 0 326#if 0
402 printf("O: %f %f %f %f\n", 327 printf ("O: %f %f %f %f\n", data[0][0], data[0][1], data[0][2], data[0][3]);
403 data[0][0],
404 data[0][1],
405 data[0][2],
406 data[0][3]);
407#endif 328#endif
408 return OK; 329 return OK;
409} 330}
410 331
411 332
412static int getEffectivenessStats(const void * closure, 333static int
413 gfloat ** data) { 334getEffectivenessStats (const void *closure, gfloat ** data)
335{
414 static cron_t last; 336 static cron_t last;
415 static double lastdata; 337 static double lastdata;
416 static double lastavg; 338 static double lastavg;
@@ -422,39 +344,41 @@ static int getEffectivenessStats(const void * closure,
422 long long llocal; 344 long long llocal;
423 cron_t now; 345 cron_t now;
424 346
425 now = get_time(); 347 now = get_time ();
426 if (now < last + 2 * cronMINUTES) { 348 if (now < last + 2 * cronMINUTES)
427 data[0][0] = lastdata; 349 {
428 data[0][1] = lastavg; 350 data[0][0] = lastdata;
429 return OK; 351 data[0][1] = lastavg;
430 } 352 return OK;
353 }
431 last = now; 354 last = now;
432 if (OK != getStatValue(&total, 355 if (OK != getStatValue (&total,
433 &ltotal, 356 &ltotal,
434 NULL, 357 NULL,
435 "# gap requests forwarded (counting each peer)", 358 "# gap requests forwarded (counting each peer)",
436 YES)) 359 YES))
437 return SYSERR; 360 return SYSERR;
438 if (OK != getStatValue(&success, 361 if (OK != getStatValue (&success,
439 &lsuccess, 362 &lsuccess,
440 NULL, 363 NULL, "# gap routing successes (total)", YES))
441 "# gap routing successes (total)",
442 YES))
443 return SYSERR; 364 return SYSERR;
444 if (OK != getStatValue(&local, 365 if (OK != getStatValue (&local,
445 &llocal, 366 &llocal,
446 NULL, 367 NULL,
447 "# gap requests processed: local result", 368 "# gap requests processed: local result", YES))
448 YES))
449 return SYSERR; 369 return SYSERR;
450 total -= ltotal; 370 total -= ltotal;
451 data[0][0] = 0.0; 371 data[0][0] = 0.0;
452 if (ltotal + total > 0) { 372 if (ltotal + total > 0)
453 data[0][1] = lastavg = 1.0 * (success + lsuccess - local - llocal) / (total + ltotal); 373 {
454 } else { 374 data[0][1] = lastavg =
455 data[0][1] = 0.0; 375 1.0 * (success + lsuccess - local - llocal) / (total + ltotal);
456 return OK; 376 }
457 } 377 else
378 {
379 data[0][1] = 0.0;
380 return OK;
381 }
458 if (total == 0) 382 if (total == 0)
459 return OK; 383 return OK;
460 success -= lsuccess; 384 success -= lsuccess;
@@ -467,9 +391,9 @@ static int getEffectivenessStats(const void * closure,
467 return OK; 391 return OK;
468} 392}
469 393
470static int statsProcessor(const char * optName, 394static int
471 unsigned long long value, 395statsProcessor (const char *optName, unsigned long long value, void *data)
472 void * data) { 396{
473 /** 397 /**
474 * Keep track of last match (or, more precisely, position 398 * Keep track of last match (or, more precisely, position
475 * of next expected match) since 99.99% of the time we 399 * of next expected match) since 99.99% of the time we
@@ -477,7 +401,7 @@ static int statsProcessor(const char * optName,
477 * this will predict correctly). 401 * this will predict correctly).
478 */ 402 */
479 static unsigned int last; 403 static unsigned int last;
480 cron_t * delta = data; 404 cron_t *delta = data;
481 int j; 405 int j;
482 int found; 406 int found;
483 407
@@ -485,33 +409,28 @@ static int statsProcessor(const char * optName,
485 last = 0; 409 last = 0;
486 j = last; 410 j = last;
487 found = -1; 411 found = -1;
488 if ( (j < lsv_size) && 412 if ((j < lsv_size) && (0 == strcmp (optName, lastStatValues[j].statName)))
489 (0 == strcmp(optName,
490 lastStatValues[j].statName)) )
491 found = j; 413 found = j;
492 if (found == -1) { 414 if (found == -1)
493 for (j=0;j<lsv_size;j++) { 415 {
494 if (0 == strcmp(optName, 416 for (j = 0; j < lsv_size; j++)
495 lastStatValues[j].statName)) { 417 {
496 found = j; 418 if (0 == strcmp (optName, lastStatValues[j].statName))
497 break; 419 {
498 } 420 found = j;
421 break;
422 }
423 }
424 }
425 if (found == -1)
426 {
427 found = lsv_size;
428 GROW (lastStatValues, lsv_size, lsv_size + 1);
429 lastStatValues[found].statName = STRDUP (optName);
499 } 430 }
500 } 431 lastStatValues[found].lvalue = lastStatValues[found].value;
501 if (found == -1) { 432 lastStatValues[found].value = value;
502 found = lsv_size; 433 lastStatValues[found].delta = *delta;
503 GROW(lastStatValues,
504 lsv_size,
505 lsv_size+1);
506 lastStatValues[found].statName
507 = STRDUP(optName);
508 }
509 lastStatValues[found].lvalue
510 = lastStatValues[found].value;
511 lastStatValues[found].value
512 = value;
513 lastStatValues[found].delta
514 = *delta;
515 last = found + 1; 434 last = found + 1;
516 return OK; 435 return OK;
517} 436}
@@ -519,129 +438,127 @@ static int statsProcessor(const char * optName,
519/** 438/**
520 * Cron-job that updates all stat values. 439 * Cron-job that updates all stat values.
521 */ 440 */
522static void updateStatValues(void * unused) { 441static void
442updateStatValues (void *unused)
443{
523 static cron_t lastUpdate; 444 static cron_t lastUpdate;
524 cron_t now; 445 cron_t now;
525 cron_t delta; 446 cron_t delta;
526 447
527 now = get_time(); 448 now = get_time ();
528 delta = now - lastUpdate; 449 delta = now - lastUpdate;
529 MUTEX_LOCK(lock); 450 MUTEX_LOCK (lock);
530 if (OK == STATS_getStatistics(ectx, 451 if (OK == STATS_getStatistics (ectx, sock, &statsProcessor, &delta))
531 sock,
532 &statsProcessor,
533 &delta))
534 lastUpdate = now; 452 lastUpdate = now;
535 MUTEX_UNLOCK(lock); 453 MUTEX_UNLOCK (lock);
536} 454}
537 455
538 456
539StatEntry stats[] = { 457StatEntry stats[] = {
540 { 458 {
541 gettext_noop("Connectivity"), 459 gettext_noop ("Connectivity"),
542 gettext_noop("# connected nodes (100% = connection table size)"), 460 gettext_noop ("# connected nodes (100% = connection table size)"),
543 &getConnectedNodesStat, 461 &getConnectedNodesStat,
544 NULL, 462 NULL,
545 1, 463 1,
546 NO, 464 NO,
547 }, 465 }
466 ,
548 { 467 {
549 gettext_noop("System load"), 468 gettext_noop ("System load"),
550 gettext_noop("CPU load (red), IO load (green), Network upload (yellow), Network download (blue)"), 469 gettext_noop
551 &getLoadStat, 470 ("CPU load (red), IO load (green), Network upload (yellow), Network download (blue)"),
552 NULL, 471 &getLoadStat,
553 4, 472 NULL,
554 NO, 473 4,
555 }, 474 NO,
475 }
476 ,
556 { 477 {
557 gettext_noop("Datastore capacity"), 478 gettext_noop ("Datastore capacity"),
558 gettext_noop("Data in datastore (in percent of allowed quota)"), 479 gettext_noop ("Data in datastore (in percent of allowed quota)"),
559 &getQuotaStat, 480 &getQuotaStat,
560 NULL, 481 NULL,
561 1, 482 1,
562 NO, 483 NO,
563 }, 484 }
485 ,
564 { 486 {
565 gettext_noop("Inbound Traffic"), 487 gettext_noop ("Inbound Traffic"),
566 gettext_noop("Noise (red), Content (green), Queries (yellow), Hellos (blue), other (gray), limit (magenta)"), 488 gettext_noop
567 &getTrafficRecvStats, 489 ("Noise (red), Content (green), Queries (yellow), Hellos (blue), other (gray), limit (magenta)"),
568 NULL, 490 &getTrafficRecvStats,
569 6, 491 NULL,
570 5, 492 6,
571 }, 493 5,
494 }
495 ,
572 { 496 {
573 gettext_noop("Outbound Traffic"), 497 gettext_noop ("Outbound Traffic"),
574 gettext_noop("Noise (red), Content (green), Queries (yellow), Hellos (blue), other (gray), limit (magenta)"), 498 gettext_noop
575 &getTrafficSendStats, 499 ("Noise (red), Content (green), Queries (yellow), Hellos (blue), other (gray), limit (magenta)"),
576 NULL, 500 &getTrafficSendStats,
577 6, 501 NULL,
578 5, 502 6,
579 }, 503 5,
504 }
505 ,
580 { 506 {
581 gettext_noop("Routing Effectiveness"), 507 gettext_noop ("Routing Effectiveness"),
582 gettext_noop("Current (red) and average (green) effectiveness (100% = perfect)"), 508 gettext_noop
583 &getEffectivenessStats, 509 ("Current (red) and average (green) effectiveness (100% = perfect)"),
584 NULL, 510 &getEffectivenessStats,
585 2, 511 NULL,
586 NO, 512 2,
587 }, 513 NO,
514 }
515 ,
588 { 516 {
589 NULL, 517 NULL,
590 NULL, 518 NULL,
591 NULL, 519 NULL,
592 NULL, 520 NULL,
593 0, 521 0,
594 NO, 522 NO,
595 }, 523 }
524 ,
596}; 525};
597 526
598static unsigned long long UPDATE_INTERVAL; 527static unsigned long long UPDATE_INTERVAL;
599 528
600void init_functions(struct GE_Context * e, 529void
601 struct GC_Configuration * c) { 530init_functions (struct GE_Context *e, struct GC_Configuration *c)
531{
602 ectx = e; 532 ectx = e;
603 cfg = c; 533 cfg = c;
604 GC_get_configuration_value_number(cfg, 534 GC_get_configuration_value_number (cfg,
605 "GNUNET-GTK", 535 "GNUNET-GTK",
606 "STATS-INTERVAL", 536 "STATS-INTERVAL",
607 1, 537 1,
608 99 * cronYEARS, 538 99 * cronYEARS,
609 30 * cronSECONDS, 539 30 * cronSECONDS, &UPDATE_INTERVAL);
610 &UPDATE_INTERVAL); 540 sock = client_connection_create (ectx, cfg);
611 sock = client_connection_create(ectx, 541 lock = MUTEX_CREATE (NO);
612 cfg); 542 cron = gnunet_gtk_get_cron ();
613 lock = MUTEX_CREATE(NO); 543 cron_add_job (cron,
614 cron = gnunet_gtk_get_cron(); 544 &updateStatValues, UPDATE_INTERVAL, UPDATE_INTERVAL, NULL);
615 cron_add_job(cron, 545 cron_add_job (cron,
616 &updateStatValues, 546 &updateConnectionGoal,
617 UPDATE_INTERVAL, 547 5 * cronMINUTES, 5 * cronMINUTES, NULL);
618 UPDATE_INTERVAL,
619 NULL);
620 cron_add_job(cron,
621 &updateConnectionGoal,
622 5 * cronMINUTES,
623 5 * cronMINUTES,
624 NULL);
625} 548}
626 549
627void done_functions() { 550void
551done_functions ()
552{
628 int i; 553 int i;
629 554
630 cron_del_job(cron, 555 cron_del_job (cron, &updateConnectionGoal, 5 * cronMINUTES, NULL);
631 &updateConnectionGoal, 556 cron_del_job (cron, &updateStatValues, UPDATE_INTERVAL, NULL);
632 5 * cronMINUTES, 557 MUTEX_DESTROY (lock);
633 NULL); 558 connection_destroy (sock);
634 cron_del_job(cron, 559 for (i = 0; i < lsv_size; i++)
635 &updateStatValues, 560 FREE (lastStatValues[i].statName);
636 UPDATE_INTERVAL, 561 GROW (lastStatValues, lsv_size, 0);
637 NULL);
638 MUTEX_DESTROY(lock);
639 connection_destroy(sock);
640 for (i=0;i<lsv_size;i++)
641 FREE(lastStatValues[i].statName);
642 GROW(lastStatValues,
643 lsv_size,
644 0);
645 sock = NULL; 562 sock = NULL;
646} 563}
647 564
diff --git a/src/plugins/stats/functions.h b/src/plugins/stats/functions.h
index ebd54cf1..a02ac4fa 100644
--- a/src/plugins/stats/functions.h
+++ b/src/plugins/stats/functions.h
@@ -24,8 +24,9 @@
24 24
25#include <GNUnet/gnunet_util.h> 25#include <GNUnet/gnunet_util.h>
26 26
27typedef struct { 27typedef struct
28 char * statName; 28{
29 char *statName;
29 long long value; 30 long long value;
30 long long lvalue; 31 long long lvalue;
31 cron_t delta; 32 cron_t delta;
@@ -35,24 +36,23 @@ typedef struct {
35 * Callback function to obtain the latest stats 36 * Callback function to obtain the latest stats
36 * data for this stat display. 37 * data for this stat display.
37 */ 38 */
38typedef int (*UpdateData)(const void * closure, 39typedef int (*UpdateData) (const void *closure, gfloat ** data);
39 gfloat ** data);
40 40
41 41
42typedef struct SE_ { 42typedef struct SE_
43 char * paneName; 43{
44 char * frameName; 44 char *paneName;
45 char *frameName;
45 UpdateData getData; 46 UpdateData getData;
46 void * get_closure; 47 void *get_closure;
47 unsigned int count; 48 unsigned int count;
48 int fill; /* fill first "fill" entries */ 49 int fill; /* fill first "fill" entries */
49} StatEntry; 50} StatEntry;
50 51
51extern StatEntry stats[]; 52extern StatEntry stats[];
52 53
53void init_functions(struct GE_Context * e, 54void init_functions (struct GE_Context *e, struct GC_Configuration *c);
54 struct GC_Configuration * c);
55 55
56void done_functions(void); 56void done_functions (void);
57 57
58#endif 58#endif
diff --git a/src/plugins/stats/statistics.c b/src/plugins/stats/statistics.c
index d1da9422..4f8c34b1 100644
--- a/src/plugins/stats/statistics.c
+++ b/src/plugins/stats/statistics.c
@@ -32,7 +32,8 @@
32#define FRAME_WIDTH 0 32#define FRAME_WIDTH 0
33 33
34 34
35typedef struct { 35typedef struct
36{
36 gint type; 37 gint type;
37 guint count; 38 guint count;
38 guint speed; 39 guint speed;
@@ -54,10 +55,11 @@ typedef struct {
54 int statIdx; 55 int statIdx;
55} LoadGraph; 56} LoadGraph;
56 57
57typedef struct { 58typedef struct
58 GdkColor bg_color; 59{
59 GdkColor frame_color; 60 GdkColor bg_color;
60 GdkColor mem_color[MAX_COLOR]; 61 GdkColor frame_color;
62 GdkColor mem_color[MAX_COLOR];
61} ProcConfig; 63} ProcConfig;
62 64
63static unsigned long long UPDATE_INTERVAL; 65static unsigned long long UPDATE_INTERVAL;
@@ -65,13 +67,15 @@ static unsigned long long UPDATE_INTERVAL;
65/** 67/**
66 * Redraws the backing pixmap for the load graph and updates the window 68 * Redraws the backing pixmap for the load graph and updates the window
67 */ 69 */
68static void load_graph_draw(LoadGraph *g) { 70static void
71load_graph_draw (LoadGraph * g)
72{
69 guint i; 73 guint i;
70 guint j; 74 guint j;
71 gint dely; 75 gint dely;
72 float delx; 76 float delx;
73 float max; 77 float max;
74 GdkFont * font; 78 GdkFont *font;
75 79
76 if (!g->disp->window) 80 if (!g->disp->window)
77 return; 81 return;
@@ -81,345 +85,342 @@ static void load_graph_draw(LoadGraph *g) {
81 85
82 if (!g->pixmap) 86 if (!g->pixmap)
83 g->pixmap = gdk_pixmap_new (g->disp->window, 87 g->pixmap = gdk_pixmap_new (g->disp->window,
84 g->draw_width, g->draw_height, 88 g->draw_width, g->draw_height,
85 gtk_widget_get_visual (g->disp)->depth); 89 gtk_widget_get_visual (g->disp)->depth);
86 90
87 /* Create GC if necessary. */ 91 /* Create GC if necessary. */
88 if (!g->gc) { 92 if (!g->gc)
89 g->gc = gdk_gc_new (g->disp->window); 93 {
90 gdk_gc_copy (g->gc, g->disp->style->white_gc); 94 g->gc = gdk_gc_new (g->disp->window);
91 } 95 gdk_gc_copy (g->gc, g->disp->style->white_gc);
96 }
92 97
93 /* Allocate colors. */ 98 /* Allocate colors. */
94 if (!g->colors_allocated) { 99 if (!g->colors_allocated)
95 GdkColormap *colormap; 100 {
101 GdkColormap *colormap;
96 102
97 colormap = gdk_window_get_colormap (g->disp->window); 103 colormap = gdk_window_get_colormap (g->disp->window);
98 for (i=0;i<2+g->count;i++) 104 for (i = 0; i < 2 + g->count; i++)
99 gdk_color_alloc (colormap, &(g->colors [i])); 105 gdk_color_alloc (colormap, &(g->colors[i]));
100 106
101 g->colors_allocated = 1; 107 g->colors_allocated = 1;
102 } 108 }
103 /* Erase Rectangle */ 109 /* Erase Rectangle */
104 gdk_gc_set_foreground (g->gc, &(g->colors [0])); 110 gdk_gc_set_foreground (g->gc, &(g->colors[0]));
105 gdk_draw_rectangle (g->pixmap, 111 gdk_draw_rectangle (g->pixmap,
106 g->gc, 112 g->gc,
107 TRUE, 0, 0, 113 TRUE, 0, 0,
108 g->disp->allocation.width, 114 g->disp->allocation.width, g->disp->allocation.height);
109 g->disp->allocation.height);
110 115
111 /* draw frame */ 116 /* draw frame */
112 gdk_gc_set_foreground (g->gc, &(g->colors [1])); 117 gdk_gc_set_foreground (g->gc, &(g->colors[1]));
113 gdk_draw_rectangle (g->pixmap, 118 gdk_draw_rectangle (g->pixmap,
114 g->gc, 119 g->gc,
115 FALSE, 0, 0, 120 FALSE, 0, 0, g->draw_width, g->disp->allocation.height);
116 g->draw_width,
117 g->disp->allocation.height);
118 121
119 max = 0.26; /* force showing at least the 25% line */ 122 max = 0.26; /* force showing at least the 25% line */
120 for (i = 0; i < g->num_points - 1; i++) 123 for (i = 0; i < g->num_points - 1; i++)
121 for (j=0;j<g->count;j++) 124 for (j = 0; j < g->count; j++)
122 if (g->data[i][j] > max) 125 if (g->data[i][j] > max)
123 max = g->data[i][j]; 126 max = g->data[i][j];
124 max = max * 1.01; /* leave top 1% free */ 127 max = max * 1.01; /* leave top 1% free */
125 128
126 font = gdk_font_load("fixed"); /* deprecated, but pango is far more than 129 font = gdk_font_load ("fixed"); /* deprecated, but pango is far more than
127 what we need here -- fix later? */ 130 what we need here -- fix later? */
128 /* draw lines at 25%, 50%, 75% and 100% of max */ 131 /* draw lines at 25%, 50%, 75% and 100% of max */
129 dely = g->draw_height / max / 4; 132 dely = g->draw_height / max / 4;
130 for (i = 1; i < 5; i++) { 133 for (i = 1; i < 5; i++)
131 gint y1 = g->draw_height + 1 - i * dely; 134 {
132 if ( (dely < 30) && (i != 4) ) 135 gint y1 = g->draw_height + 1 - i * dely;
133 continue; /* only print additional 136 if ((dely < 30) && (i != 4))
134 lines if there is enough space! */ 137 continue; /* only print additional
135 if (y1 > 0) { 138 lines if there is enough space! */
136 const gchar * label[] = { 139 if (y1 > 0)
137 NULL, 140 {
138 " 25%", 141 const gchar *label[] = {
139 " 50%", 142 NULL,
140 " 75%", 143 " 25%",
141 "100%", 144 " 50%",
142 }; 145 " 75%",
143 gdk_draw_string(g->pixmap, 146 "100%",
144 font, 147 };
145 g->gc, 148 gdk_draw_string (g->pixmap, font, g->gc, 10, y1 - 8, label[i]);
146 10, 149 gdk_draw_line (g->pixmap, g->gc, 0, y1, g->draw_width, y1);
147 y1 - 8, 150 if (i == 4)
148 label[i]); 151 {
149 gdk_draw_line (g->pixmap, g->gc, 152 /* extra-thick line at 100% */
150 0, y1, g->draw_width, y1); 153 gdk_draw_line (g->pixmap, g->gc,
151 if (i == 4) { 154 0, y1 - 1, g->draw_width, y1 - 1);
152 /* extra-thick line at 100% */ 155 gdk_draw_line (g->pixmap, g->gc,
153 gdk_draw_line (g->pixmap, g->gc, 156 0, y1 + 1, g->draw_width, y1 + 1);
154 0, y1 - 1, g->draw_width, y1 - 1); 157
155 gdk_draw_line (g->pixmap, g->gc, 158 }
156 0, y1 + 1, g->draw_width, y1 + 1); 159 }
157
158 }
159 } 160 }
160 } 161 gdk_gc_set_line_attributes (g->gc,
161 gdk_gc_set_line_attributes(g->gc, 162 2,
162 2, 163 GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_MITER);
163 GDK_LINE_SOLID, 164 delx = (float) g->draw_width / (g->num_points - 1);
164 GDK_CAP_ROUND, 165
165 GDK_JOIN_MITER); 166 for (j = 0; j < g->count; j++)
166 delx = (float)g->draw_width / ( g->num_points - 1); 167 {
167 168 gdk_gc_set_foreground (g->gc, &(g->colors[j + 2]));
168 for (j=0;j<g->count;j++) { 169 for (i = 0; i < g->num_points - 1; i++)
169 gdk_gc_set_foreground (g->gc, &(g->colors [j + 2])); 170 {
170 for (i = 0; i < g->num_points - 1; i++) { 171 gint x1 = i * delx;
171 gint x1 = i * delx; 172 gint x2 = (i + 1) * delx;
172 gint x2 = (i + 1) * delx; 173 gint y1 = g->data[i][j] / max * g->draw_height - 1;
173 gint y1 = g->data[i][j] / max * g->draw_height - 1; 174 gint y2 = g->data[i + 1][j] / max * g->draw_height - 1;
174 gint y2 = g->data[i+1][j] / max * g->draw_height - 1; 175
175 176 if ((g->data[i][j] != -1) && (g->data[i + 1][j] != -1))
176 if ((g->data[i][j] != -1) && (g->data[i+1][j] != -1)) { 177 {
177 if (stats[g->statIdx].fill <= j) { 178 if (stats[g->statIdx].fill <= j)
178 gdk_draw_line(g->pixmap, g->gc, 179 {
179 g->draw_width - x2, 180 gdk_draw_line (g->pixmap, g->gc,
180 g->draw_height - y2, 181 g->draw_width - x2,
181 g->draw_width - x1, 182 g->draw_height - y2,
182 g->draw_height - y1); 183 g->draw_width - x1, g->draw_height - y1);
183 } else { 184 }
184 GdkPoint points[4]; 185 else
185 186 {
186 points[0].x = g->draw_width - x2; 187 GdkPoint points[4];
187 points[0].y = g->draw_height - y2; 188
188 points[1].x = g->draw_width - x1; 189 points[0].x = g->draw_width - x2;
189 points[1].y = g->draw_height - y1; 190 points[0].y = g->draw_height - y2;
190 points[2].x = g->draw_width - x1; 191 points[1].x = g->draw_width - x1;
191 points[3].x = g->draw_width - x2; 192 points[1].y = g->draw_height - y1;
192 if (j == 0) { 193 points[2].x = g->draw_width - x1;
193 points[2].y = g->draw_height; 194 points[3].x = g->draw_width - x2;
194 points[3].y = g->draw_height; 195 if (j == 0)
195 } else { 196 {
196 gint ly1 = g->data[i][j-1] / max * g->draw_height - 1; 197 points[2].y = g->draw_height;
197 gint ly2 = g->data[i+1][j-1] / max * g->draw_height - 1; 198 points[3].y = g->draw_height;
198 points[2].y = g->draw_height - ly1; 199 }
199 points[3].y = g->draw_height - ly2; 200 else
200 } 201 {
201 gdk_draw_polygon(g->pixmap, 202 gint ly1 = g->data[i][j - 1] / max * g->draw_height - 1;
202 g->gc, 203 gint ly2 =
203 1, 204 g->data[i + 1][j - 1] / max * g->draw_height - 1;
204 points, 205 points[2].y = g->draw_height - ly1;
205 4); 206 points[3].y = g->draw_height - ly2;
206 } 207 }
207 } 208 gdk_draw_polygon (g->pixmap, g->gc, 1, points, 4);
209 }
210 }
211 }
208 } 212 }
209 }
210 213
211 gdk_gc_set_line_attributes (g->gc, 1, 214 gdk_gc_set_line_attributes (g->gc, 1,
212 GDK_LINE_SOLID, 215 GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_MITER);
213 GDK_CAP_ROUND,
214 GDK_JOIN_MITER );
215 216
216 gdk_draw_pixmap (g->disp->window, 217 gdk_draw_pixmap (g->disp->window,
217 g->disp->style->fg_gc [GTK_WIDGET_STATE(g->disp)], 218 g->disp->style->fg_gc[GTK_WIDGET_STATE (g->disp)],
218 g->pixmap, 219 g->pixmap,
219 0, 0, 220 0, 0,
220 0, 0, 221 0, 0,
221 g->disp->allocation.width, 222 g->disp->allocation.width, g->disp->allocation.height);
222 g->disp->allocation.height);
223} 223}
224 224
225 225
226/* Updates the load graph when the timeout expires */ 226/* Updates the load graph when the timeout expires */
227static gboolean load_graph_update(gpointer ptr) { 227static gboolean
228load_graph_update (gpointer ptr)
229{
228 LoadGraph *g = ptr; 230 LoadGraph *g = ptr;
229 guint i; 231 guint i;
230 guint j; 232 guint j;
231 233
232 for (i=0;i<g->num_points;i++) 234 for (i = 0; i < g->num_points; i++)
233 memcpy(g->odata[i], 235 memcpy (g->odata[i], g->data[i], g->data_size * g->count);
234 g->data[i], 236 stats[g->statIdx].getData (stats[g->statIdx].get_closure, g->data);
235 g->data_size * g->count); 237 for (i = 0; i < g->num_points - 1; i++)
236 stats[g->statIdx].getData(stats[g->statIdx].get_closure, 238 for (j = 0; j < g->count; j++)
237 g->data); 239 g->data[i + 1][j] = g->odata[i][j];
238 for (i=0;i<g->num_points-1;i++)
239 for (j=0;j<g->count;j++)
240 g->data[i+1][j] = g->odata[i][j];
241 if (g->draw) 240 if (g->draw)
242 load_graph_draw (g); 241 load_graph_draw (g);
243 return TRUE; 242 return TRUE;
244} 243}
245 244
246static void load_graph_unalloc(LoadGraph *g) { 245static void
246load_graph_unalloc (LoadGraph * g)
247{
247 int i; 248 int i;
248 if (!g->allocated) 249 if (!g->allocated)
249 return; 250 return;
250 for (i = 0; i < g->num_points; i++) { 251 for (i = 0; i < g->num_points; i++)
251 FREE(g->data[i]); 252 {
252 FREE(g->odata[i]); 253 FREE (g->data[i]);
253 } 254 FREE (g->odata[i]);
254 FREE(g->data); 255 }
255 FREE(g->odata); 256 FREE (g->data);
257 FREE (g->odata);
256 g->data = g->odata = NULL; 258 g->data = g->odata = NULL;
257 if (g->pixmap) { 259 if (g->pixmap)
258 gdk_pixmap_unref(g->pixmap); 260 {
259 g->pixmap = NULL; 261 gdk_pixmap_unref (g->pixmap);
260 } 262 g->pixmap = NULL;
263 }
261 g->allocated = FALSE; 264 g->allocated = FALSE;
262} 265}
263 266
264static void load_graph_alloc (LoadGraph *g) { 267static void
268load_graph_alloc (LoadGraph * g)
269{
265 int i; 270 int i;
266 int j; 271 int j;
267 272
268 if (g->allocated) 273 if (g->allocated)
269 return; 274 return;
270 275
271 g->data = MALLOC(sizeof(gfloat *) * g->num_points); 276 g->data = MALLOC (sizeof (gfloat *) * g->num_points);
272 g->odata = MALLOC(sizeof(gfloat*) * g->num_points); 277 g->odata = MALLOC (sizeof (gfloat *) * g->num_points);
273 g->data_size = sizeof (gfloat); 278 g->data_size = sizeof (gfloat);
274 for (i = 0; i < g->num_points; i++) { 279 for (i = 0; i < g->num_points; i++)
275 g->data[i] = MALLOC(g->data_size * g->count); 280 {
276 g->odata[i] = MALLOC(g->data_size * g->count); 281 g->data[i] = MALLOC (g->data_size * g->count);
277 } 282 g->odata[i] = MALLOC (g->data_size * g->count);
278 for (i=0;i<g->num_points;i++) 283 }
279 for (j=0;j<g->count;j++) 284 for (i = 0; i < g->num_points; i++)
285 for (j = 0; j < g->count; j++)
280 g->data[i][j] = -1; 286 g->data[i][j] = -1;
281 g->allocated = TRUE; 287 g->allocated = TRUE;
282} 288}
283 289
284static gint load_graph_configure(GtkWidget *widget, 290static gint
285 GdkEventConfigure *event, 291load_graph_configure (GtkWidget * widget,
286 gpointer data_ptr) { 292 GdkEventConfigure * event, gpointer data_ptr)
293{
287 LoadGraph *c = (LoadGraph *) data_ptr; 294 LoadGraph *c = (LoadGraph *) data_ptr;
288 295
289 if (c->pixmap) { 296 if (c->pixmap)
290 gdk_pixmap_unref (c->pixmap); 297 {
291 c->pixmap = NULL; 298 gdk_pixmap_unref (c->pixmap);
292 } 299 c->pixmap = NULL;
300 }
293 301
294 if (!c->pixmap) 302 if (!c->pixmap)
295 c->pixmap = gdk_pixmap_new(widget->window, 303 c->pixmap = gdk_pixmap_new (widget->window,
296 widget->allocation.width, 304 widget->allocation.width,
297 widget->allocation.height, 305 widget->allocation.height,
298 gtk_widget_get_visual (c->disp)->depth); 306 gtk_widget_get_visual (c->disp)->depth);
299 gdk_draw_rectangle(c->pixmap, 307 gdk_draw_rectangle (c->pixmap,
300 widget->style->black_gc, 308 widget->style->black_gc,
301 TRUE, 0,0, 309 TRUE, 0, 0,
302 widget->allocation.width, 310 widget->allocation.width, widget->allocation.height);
303 widget->allocation.height); 311 gdk_draw_pixmap (widget->window,
304 gdk_draw_pixmap(widget->window, 312 c->disp->style->fg_gc[GTK_WIDGET_STATE (widget)],
305 c->disp->style->fg_gc[GTK_WIDGET_STATE(widget)], 313 c->pixmap,
306 c->pixmap, 314 0, 0,
307 0, 0, 315 0, 0,
308 0, 0, 316 c->disp->allocation.width, c->disp->allocation.height);
309 c->disp->allocation.width, 317
310 c->disp->allocation.height); 318 load_graph_draw (c);
311
312 load_graph_draw(c);
313 return TRUE; 319 return TRUE;
314} 320}
315 321
316static gint load_graph_expose(GtkWidget *widget, 322static gint
317 GdkEventExpose *event, 323load_graph_expose (GtkWidget * widget,
318 gpointer data_ptr) { 324 GdkEventExpose * event, gpointer data_ptr)
325{
319 LoadGraph *g = (LoadGraph *) data_ptr; 326 LoadGraph *g = (LoadGraph *) data_ptr;
320 327
321 gdk_draw_pixmap(widget->window, 328 gdk_draw_pixmap (widget->window,
322 widget->style->fg_gc [GTK_WIDGET_STATE(widget)], 329 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
323 g->pixmap, 330 g->pixmap,
324 event->area.x, event->area.y, 331 event->area.x, event->area.y,
325 event->area.x, event->area.y, 332 event->area.x, event->area.y,
326 event->area.width, event->area.height); 333 event->area.width, event->area.height);
327 return FALSE; 334 return FALSE;
328} 335}
329 336
330static void load_graph_stop (LoadGraph *g) { 337static void
338load_graph_stop (LoadGraph * g)
339{
331 if (!g) 340 if (!g)
332 return; 341 return;
333 if (g->timer_index != -1) { 342 if (g->timer_index != -1)
334 gtk_timeout_remove(g->timer_index); 343 {
335 g->timer_index = -1; 344 gtk_timeout_remove (g->timer_index);
336 } 345 g->timer_index = -1;
346 }
337 g->draw = FALSE; 347 g->draw = FALSE;
338} 348}
339 349
340static void load_graph_destroy(GtkWidget *widget, 350static void
341 gpointer data_ptr) { 351load_graph_destroy (GtkWidget * widget, gpointer data_ptr)
352{
342 LoadGraph *g = (LoadGraph *) data_ptr; 353 LoadGraph *g = (LoadGraph *) data_ptr;
343 load_graph_stop(g); 354 load_graph_stop (g);
344 if (g->timer_index != -1) 355 if (g->timer_index != -1)
345 gtk_timeout_remove (g->timer_index); 356 gtk_timeout_remove (g->timer_index);
346 load_graph_unalloc(g); 357 load_graph_unalloc (g);
347 FREE(g->colors); 358 FREE (g->colors);
348 FREE(g); 359 FREE (g);
349} 360}
350 361
351static LoadGraph * load_graph_new(int statIdx, 362static LoadGraph *
352 const ProcConfig * config) { 363load_graph_new (int statIdx, const ProcConfig * config)
364{
353 LoadGraph *g; 365 LoadGraph *g;
354 unsigned int i; 366 unsigned int i;
355 367
356 if (stats[statIdx].count > MAX_COLOR) { 368 if (stats[statIdx].count > MAX_COLOR)
357 GE_BREAK(NULL, 0); 369 {
358 return NULL; 370 GE_BREAK (NULL, 0);
359 } 371 return NULL;
372 }
360 373
361 g = MALLOC(sizeof(LoadGraph)); 374 g = MALLOC (sizeof (LoadGraph));
362 g->statIdx = statIdx; 375 g->statIdx = statIdx;
363 g->count = stats[statIdx].count; 376 g->count = stats[statIdx].count;
364 g->speed = UPDATE_INTERVAL / cronMILLIS; 377 g->speed = UPDATE_INTERVAL / cronMILLIS;
365 g->num_points = 600; 378 g->num_points = 600;
366 g->colors = MALLOC(sizeof(GdkColor) * (2+g->count)); 379 g->colors = MALLOC (sizeof (GdkColor) * (2 + g->count));
367 g->colors[0] = config->bg_color; 380 g->colors[0] = config->bg_color;
368 g->colors[1] = config->frame_color; 381 g->colors[1] = config->frame_color;
369 for (i=0;i<g->count;i++) 382 for (i = 0; i < g->count; i++)
370 g->colors[2+i] = config->mem_color[i]; 383 g->colors[2 + i] = config->mem_color[i];
371 g->timer_index = -1; 384 g->timer_index = -1;
372 g->draw = FALSE; 385 g->draw = FALSE;
373 g->main_widget = gtk_vbox_new (FALSE, FALSE); 386 g->main_widget = gtk_vbox_new (FALSE, FALSE);
374 gtk_widget_show(g->main_widget); 387 gtk_widget_show (g->main_widget);
375 g->disp = gtk_drawing_area_new(); 388 g->disp = gtk_drawing_area_new ();
376 gtk_widget_show (g->disp); 389 gtk_widget_show (g->disp);
377 gtk_signal_connect(GTK_OBJECT (g->disp), 390 gtk_signal_connect (GTK_OBJECT (g->disp),
378 "expose_event", 391 "expose_event", GTK_SIGNAL_FUNC (load_graph_expose), g);
379 GTK_SIGNAL_FUNC (load_graph_expose), g); 392 gtk_signal_connect (GTK_OBJECT (g->disp),
380 gtk_signal_connect(GTK_OBJECT(g->disp), 393 "configure_event",
381 "configure_event", 394 GTK_SIGNAL_FUNC (load_graph_configure), g);
382 GTK_SIGNAL_FUNC (load_graph_configure), g); 395 gtk_signal_connect (GTK_OBJECT (g->disp),
383 gtk_signal_connect(GTK_OBJECT(g->disp), 396 "destroy", GTK_SIGNAL_FUNC (load_graph_destroy), g);
384 "destroy", 397 gtk_widget_add_events (g->disp, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
385 GTK_SIGNAL_FUNC (load_graph_destroy), g); 398 gtk_box_pack_start (GTK_BOX (g->main_widget), g->disp, TRUE, TRUE, 0);
386 gtk_widget_add_events(g->disp, 399 load_graph_alloc (g);
387 GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK); 400 gtk_widget_show_all (g->main_widget);
388 gtk_box_pack_start(GTK_BOX(g->main_widget), 401 g->timer_index = gtk_timeout_add (g->speed, &load_graph_update, g);
389 g->disp,
390 TRUE,
391 TRUE,
392 0);
393 load_graph_alloc(g);
394 gtk_widget_show_all(g->main_widget);
395 g->timer_index = gtk_timeout_add(g->speed,
396 &load_graph_update, g);
397 402
398 return g; 403 return g;
399} 404}
400 405
401static GtkWidget * create_sys_view(int statIdx, 406static GtkWidget *
402 const ProcConfig * config) { 407create_sys_view (int statIdx, const ProcConfig * config)
403 GtkWidget * mem_frame; 408{
404 LoadGraph * mem_graph; 409 GtkWidget *mem_frame;
410 LoadGraph *mem_graph;
405 411
406 mem_graph = load_graph_new(statIdx, 412 mem_graph = load_graph_new (statIdx, config);
407 config);
408 if (mem_graph == NULL) 413 if (mem_graph == NULL)
409 return NULL; /* oops */ 414 return NULL; /* oops */
410 mem_frame = gtk_frame_new(_(stats[statIdx].frameName)); 415 mem_frame = gtk_frame_new (_(stats[statIdx].frameName));
411 gtk_container_add(GTK_CONTAINER(mem_frame), 416 gtk_container_add (GTK_CONTAINER (mem_frame), mem_graph->main_widget);
412 mem_graph->main_widget); 417 gtk_container_set_border_width (GTK_CONTAINER (mem_graph->main_widget),
413 gtk_container_set_border_width(GTK_CONTAINER(mem_graph->main_widget), 418 GNOME_PAD_SMALL);
414 GNOME_PAD_SMALL); 419 gtk_container_set_border_width (GTK_CONTAINER (mem_frame), GNOME_PAD_SMALL);
415 gtk_container_set_border_width(GTK_CONTAINER(mem_frame), 420 gtk_widget_show (mem_frame);
416 GNOME_PAD_SMALL);
417 gtk_widget_show(mem_frame);
418 if (mem_graph->timer_index == -1) 421 if (mem_graph->timer_index == -1)
419 mem_graph->timer_index 422 mem_graph->timer_index
420 = gtk_timeout_add(mem_graph->speed, 423 = gtk_timeout_add (mem_graph->speed, &load_graph_update, mem_graph);
421 &load_graph_update,
422 mem_graph);
423 mem_graph->draw = TRUE; 424 mem_graph->draw = TRUE;
424 return mem_frame; 425 return mem_frame;
425} 426}
@@ -428,64 +429,50 @@ static GtkWidget * create_sys_view(int statIdx,
428 429
429 430
430 431
431void init_stats(struct GE_Context * ectx, 432void
432 struct GC_Configuration * cfg) { 433init_stats (struct GE_Context *ectx, struct GC_Configuration *cfg)
433 GtkWidget * sys_box; 434{
434 GtkWidget * label; 435 GtkWidget *sys_box;
435 GtkWidget * notebook; 436 GtkWidget *label;
437 GtkWidget *notebook;
436 ProcConfig config; 438 ProcConfig config;
437 int i; 439 int i;
438 440
439 GC_get_configuration_value_number(cfg, 441 GC_get_configuration_value_number (cfg,
440 "GNUNET-GTK", 442 "GNUNET-GTK",
441 "STATS-INTERVAL", 443 "STATS-INTERVAL",
442 1, 444 1,
443 99 * cronYEARS, 445 99 * cronYEARS,
444 30 * cronSECONDS, 446 30 * cronSECONDS, &UPDATE_INTERVAL);
445 &UPDATE_INTERVAL); 447 init_functions (ectx, cfg);
446 init_functions(ectx, 448 notebook = glade_xml_get_widget (getMainXML (), "statsNotebook");
447 cfg); 449 memset (&config, 0, sizeof (ProcConfig));
448 notebook 450 gdk_color_parse ("black", &config.bg_color);
449 = glade_xml_get_widget(getMainXML(), 451 gdk_color_parse ("gray", &config.frame_color);
450 "statsNotebook"); 452 gdk_color_parse ("red", &config.mem_color[0]);
451 memset(&config, 453 gdk_color_parse ("green", &config.mem_color[1]);
452 0, 454 gdk_color_parse ("yellow", &config.mem_color[2]);
453 sizeof(ProcConfig)); 455 gdk_color_parse ("blue", &config.mem_color[3]);
454 gdk_color_parse("black", 456 gdk_color_parse ("gray", &config.mem_color[4]);
455 &config.bg_color); 457 gdk_color_parse ("magenta", &config.mem_color[5]);
456 gdk_color_parse("gray", 458 GE_ASSERT (ectx, MAX_COLOR == 6);
457 &config.frame_color);
458 gdk_color_parse("red",
459 &config.mem_color[0]);
460 gdk_color_parse("green",
461 &config.mem_color[1]);
462 gdk_color_parse("yellow",
463 &config.mem_color[2]);
464 gdk_color_parse("blue",
465 &config.mem_color[3]);
466 gdk_color_parse("gray",
467 &config.mem_color[4]);
468 gdk_color_parse("magenta",
469 &config.mem_color[5]);
470 GE_ASSERT(ectx,
471 MAX_COLOR == 6);
472 i = -1; 459 i = -1;
473 while (stats[++i].paneName != NULL) { 460 while (stats[++i].paneName != NULL)
474 sys_box = create_sys_view(i, 461 {
475 &config); 462 sys_box = create_sys_view (i, &config);
476 if (sys_box == NULL) 463 if (sys_box == NULL)
477 continue; /* oops */ 464 continue; /* oops */
478 465
479 label = gtk_label_new(gettext(stats[i].paneName)); 466 label = gtk_label_new (gettext (stats[i].paneName));
480 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), 467 gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, label);
481 sys_box, 468 }
482 label); 469 gtk_widget_show (notebook);
483 }
484 gtk_widget_show(notebook);
485} 470}
486 471
487void done_stats() { 472void
488 done_functions(); 473done_stats ()
474{
475 done_functions ();
489} 476}
490 477
491 478
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-09 07:37:24 +0000