aboutsummaryrefslogtreecommitdiff
path: root/src/plugins/fs/namespace.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/fs/namespace.c')
-rw-r--r--src/plugins/fs/namespace.c1586
1 files changed, 747 insertions, 839 deletions
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 */
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-18 14:30:32 +0000