?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r3768: Updated years.
[rox-filer.git] / ROX-Filer / src / infobox.c
blob43d19c0d41864d3a4e73f326021f6998befd1c61
1 /*
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2005, the ROX-Filer team.
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19 * Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 /* infobox.c - code for showing a file's attributes */
23
24 #include "config.h"
25
26 #include <errno.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <sys/param.h>
30 #include <signal.h>
31 #include <libxml/parser.h>
32
33 #include <gtk/gtk.h>
34
35 #include "global.h"
36
37 #include "support.h"
38 #include "main.h"
39 #include "gui_support.h"
40 #include "diritem.h"
41 #include "type.h"
42 #include "infobox.h"
43 #include "appinfo.h"
44 #include "dnd.h" /* For xa_string */
45 #include "run.h" /* For show_help_files() */
46 #include "xml.h"
47 #include "mount.h"
48 #include "pixmaps.h"
49 #include "xtypes.h"
50
51 typedef struct _FileStatus FileStatus;
52
53 /* This is for the 'file(1) says...' thing */
54 struct _FileStatus
55 {
56 int fd; /* FD to read from, -1 if closed */
57 int input; /* Input watcher tag if fd valid */
58 GtkLabel *label; /* Widget to output to */
59 gchar *text; /* String so far */
60 };
61
62 typedef struct du {
63 gchar *path;
64 GtkListStore *store;
65 guint watch;
66 GIOChannel *chan;
67 gint child;
68 } DU;
69
70 typedef struct _Permissions Permissions;
71
72 struct _Permissions
73 {
74 gchar *path;
75 DirItem *item;
76 GtkWidget *bits[12];
77 };
78
79 /* Static prototypes */
80 static void refresh_info(GObject *window);
81 static GtkWidget *make_vbox(const guchar *path, GObject *window);
82 static GtkWidget *make_details(const guchar *path, DirItem *item,
83 GObject *window);
84 static GtkWidget *make_about(const guchar *path, XMLwrapper *ai);
85 static GtkWidget *make_file_says(const guchar *path);
86 static GtkWidget *make_permissions(const gchar *path, DirItem *item);
87 static void add_file_output(FileStatus *fs,
88 gint source, GdkInputCondition condition);
89 static const gchar *pretty_type(DirItem *file, const guchar *path);
90 static void got_response(GObject *window, gint response, gpointer data);
91 static void file_info_destroyed(GtkWidget *widget, FileStatus *fs);
92
93 /****************************************************************
94 * EXTERNAL INTERFACE *
95 ****************************************************************/
96
97 /* Open each item in a new infobox. Confirms if there are a large
98 * number of items to show.
99 */
100 void infobox_show_list(GList *paths)
101 {
102 int n;
103
104 n = g_list_length(paths);
105
106 if (n >= 10)
107 {
108 gchar *message;
109 gboolean ok;
110
111 message = g_strdup_printf(
112 _("Are you sure you want to open %d windows?"), n);
113 ok = confirm(message, GTK_STOCK_YES, _("Show Info"));
114 g_free(message);
115 if (!ok)
116 return;
117 }
118
119 g_list_foreach(paths, (GFunc) infobox_new, NULL);
120 }
121
122 /* Create and display a new info box showing details about this item */
123 void infobox_new(const gchar *pathname)
124 {
125 GtkWidget *window, *details;
126 gchar *path;
127 GObject *owindow;
128
129 g_return_if_fail(pathname != NULL);
130
131 path = g_strdup(pathname); /* Gets attached to window & freed later */
132
133 window = gtk_dialog_new_with_buttons(
134 g_utf8_validate(path, -1, NULL) ? path
135 : _("(bad utf-8)"),
136 NULL, GTK_DIALOG_NO_SEPARATOR,
137 GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL,
138 GTK_STOCK_REFRESH, GTK_RESPONSE_APPLY,
139 NULL);
140
141 gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
142
143 owindow = G_OBJECT(window);
144 details = make_vbox(path, owindow);
145 gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(window)->vbox),
146 details);
147
148 g_object_set_data(owindow, "details", details);
149 g_object_set_data_full(owindow, "path", path, g_free);
150
151 g_signal_connect(window, "response", G_CALLBACK(got_response), NULL);
152
153 number_of_windows++;
154 gtk_widget_show_all(window);
155 }
156
157 /****************************************************************
158 * INTERNAL FUNCTIONS *
159 ****************************************************************/
160
161 static void got_response(GObject *window, gint response, gpointer data)
162 {
163 if (response == GTK_RESPONSE_APPLY)
164 refresh_info(window);
165 else
166 {
167 gtk_widget_destroy(GTK_WIDGET(window));
168 one_less_window();
169 }
170 }
171
172 static void refresh_info(GObject *window)
173 {
174 GtkWidget *details, *vbox;
175 guchar *path;
176
177 path = g_object_get_data(window, "path");
178 details = g_object_get_data(window, "details");
179 g_return_if_fail(details != NULL);
180 g_return_if_fail(path != NULL);
181
182 vbox = details->parent;
183 gtk_widget_destroy(details);
184
185 details = make_vbox(path, window);
186 g_object_set_data(window, "details", details);
187 gtk_box_pack_start_defaults(GTK_BOX(vbox), details);
188 gtk_widget_show_all(details);
189 }
190
191 static void add_frame(GtkBox *vbox, GtkWidget *list)
192 {
193 GtkWidget *frame;
194
195 frame = gtk_frame_new(NULL);
196 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
197 gtk_container_add(GTK_CONTAINER(frame), list);
198 gtk_box_pack_start_defaults(vbox, frame);
199 }
200
201 /* Create the VBox widget that contains the details.
202 * Note that 'path' must not be freed until the vbox is destroyed.
203 */
204 static GtkWidget *make_vbox(const guchar *path, GObject *window)
205 {
206 DirItem *item;
207 GtkBox *vbox;
208 XMLwrapper *ai;
209 xmlNode *about = NULL;
210 gchar *help_dir;
211 GtkWidget *hbox, *name, *label;
212
213 g_return_val_if_fail(path[0] == '/', NULL);
214
215 item = diritem_new(g_basename(path));
216 diritem_restat(path, item, NULL);
217
218 ai = appinfo_get(path, item);
219 if (ai)
220 about = xml_get_section(ai, NULL, "About");
221
222 vbox = GTK_BOX(gtk_vbox_new(FALSE, 4));
223 gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
224
225 /* Heading, with icon and name */
226 hbox = gtk_hbox_new(FALSE, 4);
227 gtk_box_pack_start(vbox, hbox, FALSE, TRUE, 0);
228 gtk_box_pack_start(GTK_BOX(hbox),
229 gtk_image_new_from_pixbuf(di_image(item)->pixbuf),
230 FALSE, FALSE, 4);
231
232 if (g_utf8_validate(item->leafname, -1, NULL))
233 name = gtk_label_new(item->leafname);
234 else
235 {
236 guchar *u8;
237
238 u8 = to_utf8(item->leafname);
239 name = gtk_label_new(u8);
240 g_free(u8);
241 }
242 gtk_label_set_selectable(GTK_LABEL(name), TRUE);
243 gtk_box_pack_start(GTK_BOX(hbox), name, FALSE, TRUE, 4);
244
245 /* Make the name bolder and larger */
246 {
247 PangoAttribute *attr;
248 PangoAttrList *list;
249
250 list = pango_attr_list_new();
251
252 attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
253 attr->start_index = 0;
254 attr->end_index = -1;
255 pango_attr_list_insert(list, attr);
256
257 attr = pango_attr_scale_new(PANGO_SCALE_X_LARGE);
258 attr->start_index = 0;
259 attr->end_index = -1;
260 pango_attr_list_insert(list, attr);
261
262 gtk_label_set_attributes(GTK_LABEL(name), list);
263 }
264
265 /* List of file attributes */
266 add_frame(vbox, make_details(path, item, window));
267
268 help_dir = g_strconcat(path, "/Help", NULL);
269
270 if (access(help_dir, F_OK) == 0)
271 {
272 GtkWidget *button, *align;
273
274 align = gtk_alignment_new(0.5, 0.5, 0, 0);
275
276 button = button_new_mixed(GTK_STOCK_JUMP_TO,
277 _("Show _Help Files"));
278 gtk_box_pack_start(vbox, align, FALSE, TRUE, 0);
279 gtk_container_add(GTK_CONTAINER(align), button);
280 g_signal_connect_swapped(button, "clicked",
281 G_CALLBACK(show_help_files),
282 (gpointer) path);
283 }
284 g_free(help_dir);
285
286 label = gtk_label_new(NULL);
287 gtk_label_set_markup(GTK_LABEL(label), _("<b>Permissions</b>"));
288 gtk_misc_set_alignment(GTK_MISC(label), 0, 1);
289 gtk_box_pack_start(vbox, label, FALSE, TRUE, 2);
290
291 gtk_box_pack_start(vbox, make_permissions(path, item),
292 FALSE, TRUE, 0);
293
294 if (about)
295 add_frame(vbox, make_about(path, ai));
296 else if (item->base_type == TYPE_FILE)
297 {
298 label = gtk_label_new(NULL);
299 gtk_label_set_markup(GTK_LABEL(label),
300 _("<b>Contents indicate...</b>"));
301 gtk_misc_set_alignment(GTK_MISC(label), 0, 1);
302 gtk_box_pack_start(vbox, label, FALSE, TRUE, 2);
303
304 gtk_box_pack_start_defaults(vbox, make_file_says(path));
305 }
306
307 if (ai)
308 g_object_unref(ai);
309
310 diritem_free(item);
311
312 return (GtkWidget *) vbox;
313 }
314
315 /* The selection has changed - grab or release the primary selection */
316 static void set_selection(GtkTreeView *view, gpointer data)
317 {
318 static GtkClipboard *primary = NULL;
319 GtkTreeModel *model;
320 GtkTreePath *path = NULL;
321 GtkTreeIter iter;
322 gchar *text;
323
324 gtk_tree_view_get_cursor(view, &path, NULL);
325 if (!path)
326 return;
327
328 if (!primary)
329 primary = gtk_clipboard_get(gdk_atom_intern("PRIMARY", FALSE));
330
331 model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
332
333 gtk_tree_model_get_iter(model, &iter, path);
334 gtk_tree_path_free(path);
335
336 gtk_tree_model_get(model, &iter, 1, &text, -1);
337
338 gtk_clipboard_set_text(primary, text, -1);
339
340 g_free(text);
341 }
342
343 /* Returns a GtkTreePath for the item */
344 static const gchar *add_row(GtkListStore *store, const gchar *label,
345 const gchar *data)
346 {
347 GtkTreeIter iter;
348 gchar *u8 = NULL;
349 GtkTreePath *tpath;
350 static gchar *last = NULL;
351
352 if (!g_utf8_validate(data, -1, NULL))
353 u8 = to_utf8(data);
354
355 gtk_list_store_append(store, &iter);
356 gtk_list_store_set(store, &iter, 0, label, 1, u8 ? u8 : data, -1);
357
358 g_free(u8);
359
360 tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
361 if (last)
362 g_free(last);
363 last = gtk_tree_path_to_string(tpath);
364 gtk_tree_path_free(tpath);
365
366 return last;
367 }
368
369 static void add_row_and_free(GtkListStore *store,
370 const gchar *label, gchar *data)
371 {
372 add_row(store, label, data);
373 g_free(data);
374 }
375
376 /* Create an empty list view, ready to place some data in */
377 static void make_list(GtkListStore **list_store, GtkWidget **list_view,
378 GCallback cell_edited)
379 {
380 GtkListStore *store;
381 GtkTreeView *view;
382 GtkCellRenderer *cell_renderer;
383
384 /* Field name, value, editable */
385 store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING,
386 G_TYPE_BOOLEAN);
387 view = GTK_TREE_VIEW(
388 gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)));
389 g_object_unref(G_OBJECT(store));
390 gtk_tree_view_set_headers_visible(view, FALSE);
391
392 cell_renderer = gtk_cell_renderer_text_new();
393 g_object_set(G_OBJECT(cell_renderer), "xalign", 1.0, NULL);
394 gtk_tree_view_insert_column_with_attributes(view,
395 0, NULL, cell_renderer, "text", 0, NULL);
396
397 cell_renderer = gtk_cell_renderer_text_new();
398 gtk_tree_view_insert_column_with_attributes(view,
399 1, NULL, cell_renderer, "text", 1, "editable", 2, NULL);
400
401 if (cell_edited) {
402 g_signal_connect(G_OBJECT(cell_renderer), "edited",
403 G_CALLBACK(cell_edited), store);
404 }
405
406 g_signal_connect(view, "cursor_changed",
407 G_CALLBACK(set_selection), NULL);
408
409 *list_store = store;
410 *list_view = (GtkWidget *) view;
411 }
412
413 static void set_cell(GtkListStore *store, const gchar *path,
414 const gchar *ctext)
415 {
416 GtkTreeIter iter;
417
418 gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store),
419 &iter, path);
420 gtk_list_store_set(store, &iter, 1, ctext, -1);
421 }
422
423 static void insert_size(DU *du, const char *line)
424 {
425 off_t size;
426 gchar *cell;
427
428 #ifdef LARGE_FILE_SUPPORT
429 size = strtoll(line, NULL, 10);
430 #else
431 size = strtol(line, NULL, 10);
432 #endif
433 size <<= 10; /* Because du reports in K */
434 cell = (size >= PRETTY_SIZE_LIMIT)
435 ? g_strdup_printf("%s (%" SIZE_FMT " %s)",
436 format_size(size),
437 size, _("bytes"))
438 : g_strdup(format_size(size));
439
440 set_cell(du->store, du->path, cell);
441
442 g_free(cell);
443 }
444
445 static gboolean read_du_output(GIOChannel *source, GIOCondition cond, DU *du)
446 {
447 GString *line;
448 GIOStatus stat;
449 GError *err = NULL;
450
451 line = g_string_new("");
452 stat = g_io_channel_read_line_string(source, line, NULL, &err);
453 switch (stat)
454 {
455 case G_IO_STATUS_NORMAL:
456 insert_size(du, line->str);
457 break;
458 case G_IO_STATUS_EOF:
459 set_cell(du->store, du->path,
460 _("Failed to read size"));
461 break;
462 case G_IO_STATUS_AGAIN:
463 g_string_free(line, TRUE);
464 return TRUE;
465 case G_IO_STATUS_ERROR:
466 set_cell(du->store, du->path, err->message);
467 break;
468 }
469 g_string_free(line, TRUE);
470
471 return FALSE;
472 }
473
474 static void kill_du_output(GtkWidget *widget, DU *du)
475 {
476 g_source_remove(du->watch);
477 g_io_channel_shutdown(du->chan, FALSE, NULL);
478 g_io_channel_unref(du->chan);
479 kill((pid_t) du->child, SIGTERM);
480 g_object_unref(G_OBJECT(du->store));
481 g_free(du->path);
482 g_free(du);
483 }
484
485 static gboolean refresh_info_idle(gpointer data)
486 {
487 GObject *window = G_OBJECT(data);
488
489 refresh_info(window);
490 g_object_unref(window);
491 return FALSE;
492 }
493
494 static void cell_edited(GtkCellRendererText *cell,
495 const gchar *path_string,
496 const gchar *new_text,
497 gpointer data)
498 {
499 GtkTreeModel *model = (GtkTreeModel *) data;
500 GtkTreePath *path;
501 GtkTreeIter iter;
502 GObject *window;
503 const char *fullpath;
504 char *oldlink;
505
506 window = g_object_get_data(G_OBJECT(model), "rox_window");
507 g_return_if_fail(window != NULL);
508
509 fullpath = g_object_get_data(window, "path");
510 g_return_if_fail(fullpath != NULL);
511
512 path = gtk_tree_path_new_from_string(path_string);
513 gtk_tree_model_get_iter(model, &iter, path);
514 gtk_tree_path_free(path);
515
516 oldlink = readlink_dup(fullpath);
517 if (!oldlink) {
518 report_error(_("'%s' is no longer a symlink"), fullpath);
519 return;
520 }
521 if (strcmp(oldlink, new_text) == 0)
522 return; /* No change */
523 g_free(oldlink);
524 if (unlink(fullpath)) {
525 report_error(_("Failed to unlink '%s':\n%s"),
526 fullpath, g_strerror(errno));
527 return;
528 }
529 if (symlink(new_text, fullpath)) {
530 report_error(_("Failed to create symlink from '%s':\n%s\n"
531 "(note: old link has been deleted)"));
532 return;
533 }
534
535 g_object_ref(window);
536 g_idle_add(refresh_info_idle, window);
537 }
538
539 /* Create the TreeView widget with the file's details */
540 static GtkWidget *make_details(const guchar *path, DirItem *item,
541 GObject *window)
542 {
543 GtkListStore *store;
544 GtkWidget *view;
545 gchar *tmp, *tmp2;
546
547 make_list(&store, &view, G_CALLBACK(cell_edited));
548 g_object_set_data(G_OBJECT(store), "rox_window", window);
549
550 /* For a symlink to an error, don't show the error */
551 if (item->base_type == TYPE_ERROR && item->lstat_errno)
552 {
553 add_row(store, _("Error:"), g_strerror(item->lstat_errno));
554 return view;
555 }
556
557 tmp = g_path_get_dirname(path);
558 tmp2 = pathdup(tmp);
559 if (strcmp(tmp, tmp2) != 0)
560 add_row_and_free(store, _("Real directory:"), tmp2);
561 g_free(tmp);
562
563 add_row_and_free(store, _("Owner, Group:"),
564 g_strdup_printf("%s, %s",
565 user_name(item->uid),
566 group_name(item->gid)));
567
568 if (item->base_type != TYPE_DIRECTORY)
569 {
570 add_row_and_free(store, _("Size:"),
571 item->size >= PRETTY_SIZE_LIMIT
572 ? g_strdup_printf("%s (%" SIZE_FMT " %s)",
573 format_size(item->size),
574 item->size, _("bytes"))
575 : g_strdup(format_size(item->size)));
576 }
577 else
578 {
579 gchar *stt=NULL;
580
581 if(item->flags & ITEM_FLAG_MOUNTED)
582 stt=mount_get_fs_size(path);
583
584 if(stt) {
585 add_row_and_free(store, _("Size:"), stt);
586 } else {
587 DU *du;
588 int out;
589
590 gchar *args[] = {"du", "-sk", "", NULL};
591
592 du = g_new(DU, 1);
593 du->store = store;
594 du->path = g_strdup(add_row(store, _("Size:"),
595 _("Scanning")));
596
597 args[2] = (gchar *) path;
598 if (g_spawn_async_with_pipes(NULL, args, NULL,
599 G_SPAWN_SEARCH_PATH,
600 NULL, NULL, &du->child,
601 NULL, &out, NULL,
602 NULL))
603 {
604 du->chan = g_io_channel_unix_new(out);
605 du->watch = g_io_add_watch(du->chan,
606 G_IO_IN|G_IO_ERR|G_IO_HUP,
607 (GIOFunc) read_du_output, du);
608 g_object_ref(G_OBJECT(du->store));
609 g_signal_connect(G_OBJECT(view),
610 "destroy",
611 G_CALLBACK(kill_du_output),
612 du);
613 }
614 else
615 {
616 set_cell(store, du->path, _("Failed to scan"));
617 g_free(du->path);
618 g_free(du);
619 }
620 }
621 }
622
623 add_row_and_free(store, _("Change time:"), pretty_time(&item->ctime));
624
625 add_row_and_free(store, _("Modify time:"), pretty_time(&item->mtime));
626
627 add_row_and_free(store, _("Access time:"), pretty_time(&item->atime));
628
629 add_row(store, _("Type:"), pretty_type(item, path));
630
631 if (item->mime_type)
632 add_row(store, "", mime_type_comment(item->mime_type));
633
634 if (xtype_supported(NULL)) {
635 add_row(store, _("Extended attributes:"),
636 (item->flags & ITEM_FLAG_HAS_XATTR)
637 ? _("Present")
638 : xtype_supported(path) ? _("None")
639 : _("Not supported"));
640 }
641
642 if (item->flags & ITEM_FLAG_SYMLINK)
643 {
644 GtkTreeIter iter;
645 GtkTreeModel *model = GTK_TREE_MODEL(store);
646 char *target;
647
648 target = readlink_dup(path);
649 if (!target)
650 target = g_strdup(g_strerror(errno));
651 add_row_and_free(store, _("Link target:"), target);
652
653 /* Make cell editable */
654 gtk_tree_model_iter_nth_child(model, &iter,
655 NULL, gtk_tree_model_iter_n_children(model, NULL) - 1);
656
657 gtk_list_store_set(store, &iter, 2, TRUE, -1);
658 }
659
660 if (item->base_type != TYPE_DIRECTORY)
661 add_row_and_free(store, _("Run action:"),
662 describe_current_command(item->mime_type));
663
664 return view;
665 }
666
667 /* Create the TreeView widget with the application's details */
668 static GtkWidget *make_about(const guchar *path, XMLwrapper *ai)
669 {
670 GtkListStore *store;
671 GtkWidget *view;
672 xmlNode *prop;
673 xmlNode *about, *about_trans;
674 GHashTable *translate;
675
676 g_return_val_if_fail(ai != NULL, NULL);
677
678 about_trans = xml_get_section(ai, NULL, "About");
679
680 about = xmlDocGetRootElement(ai->doc)->xmlChildrenNode;
681 for (; about; about = about->next)
682 {
683 if (about->type != XML_ELEMENT_NODE)
684 continue;
685 if (about->ns == NULL && strcmp(about->name, "About") == 0)
686 break;
687 }
688
689 g_return_val_if_fail(about != NULL, NULL);
690
691 make_list(&store, &view, NULL);
692
693 /* Add each field in about to the list, but overriding each element
694 * with about_trans if a translation is supplied.
695 */
696 translate = g_hash_table_new(g_str_hash, g_str_equal);
697 if (about_trans != about)
698 {
699 xmlNode *p;
700 for (p = about_trans->xmlChildrenNode; p; p = p->next)
701 {
702 if (p->type != XML_ELEMENT_NODE)
703 continue;
704 g_hash_table_insert(translate, (char *) p->name, p);
705 }
706 }
707 for (prop = about->xmlChildrenNode; prop; prop = prop->next)
708 {
709 if (prop->type == XML_ELEMENT_NODE)
710 {
711 char *label = NULL;
712 char *value = NULL;
713 char *tmp = NULL;
714 xmlNode *trans;
715
716 trans = g_hash_table_lookup(translate, prop->name);
717 if (!trans)
718 trans = prop;
719
720 tmp = xmlGetProp(trans, "label");
721 label = g_strconcat(tmp ? tmp
722 : (char *) trans->name,
723 ":", NULL);
724 g_free(tmp);
725 value = xmlNodeListGetString(trans->doc,
726 trans->xmlChildrenNode, 1);
727 if (!value)
728 value = xmlNodeListGetString(prop->doc,
729 prop->xmlChildrenNode, 1);
730 if (!value)
731 value = g_strdup("-");
732 add_row_and_free(store, label, value);
733 g_free(label);
734 }
735 }
736
737 g_hash_table_destroy(translate);
738
739 return view;
740 }
741
742 static GtkWidget *make_file_says(const guchar *path)
743 {
744 GtkWidget *w_file_label;
745 GtkLabel *l_file_label;
746 int file_data[2];
747 char *argv[] = {"file", "-b", NULL, NULL};
748 FileStatus *fs = NULL;
749 guchar *tmp;
750
751 w_file_label = gtk_label_new(_("<nothing yet>"));
752 l_file_label = GTK_LABEL(w_file_label);
753 gtk_label_set_line_wrap(l_file_label, TRUE);
754
755 if (pipe(file_data))
756 {
757 tmp = g_strdup_printf("pipe(): %s", g_strerror(errno));
758 gtk_label_set_text(l_file_label, tmp);
759 g_free(tmp);
760 return w_file_label;
761 }
762
763 switch (fork())
764 {
765 case -1:
766 tmp = g_strdup_printf("pipe(): %s", g_strerror(errno));
767 gtk_label_set_text(l_file_label, tmp);
768 g_free(tmp);
769 close(file_data[0]);
770 close(file_data[1]);
771 break;
772 case 0:
773 /* We are the child */
774 close(file_data[0]);
775 dup2(file_data[1], STDOUT_FILENO);
776 dup2(file_data[1], STDERR_FILENO);
777 #ifdef FILE_B_FLAG
778 argv[2] = (char *) path;
779 #else
780 argv[1] = (char *) g_basename(path);
781 chdir(g_path_get_dirname(path));
782 #endif
783 if (execvp(argv[0], argv))
784 fprintf(stderr, "execvp() error: %s\n",
785 g_strerror(errno));
786 _exit(0);
787 default:
788 /* We are the parent */
789 close(file_data[1]);
790 fs = g_new(FileStatus, 1);
791 fs->label = l_file_label;
792 fs->fd = file_data[0];
793 fs->text = g_strdup("");
794 fs->input = gdk_input_add_full(fs->fd, GDK_INPUT_READ,
795 (GdkInputFunction) add_file_output,
796 fs, NULL);
797 g_signal_connect(w_file_label, "destroy",
798 G_CALLBACK(file_info_destroyed), fs);
799 break;
800 }
801
802 return w_file_label;
803 }
804
805 /* Got some data from file(1) - stick it in the window. */
806 static void add_file_output(FileStatus *fs,
807 gint source, GdkInputCondition condition)
808 {
809 char buffer[20];
810 char *str;
811 int got;
812
813 got = read(source, buffer, sizeof(buffer) - 1);
814 if (got <= 0)
815 {
816 int err = errno;
817 g_source_remove(fs->input);
818 close(source);
819 fs->fd = -1;
820 if (got < 0)
821 delayed_error(_("file(1) says... %s"),
822 g_strerror(err));
823 return;
824 }
825 buffer[got] = '\0';
826
827 str = g_strconcat(fs->text, buffer, NULL);
828 g_free(fs->text);
829 fs->text = str;
830
831 str = to_utf8(fs->text);
832 g_strstrip(str);
833 gtk_label_set_text(fs->label, str);
834 g_free(str);
835 }
836
837 static void file_info_destroyed(GtkWidget *widget, FileStatus *fs)
838 {
839 if (fs->fd != -1)
840 {
841 g_source_remove(fs->input);
842 close(fs->fd);
843 }
844
845 g_free(fs->text);
846 g_free(fs);
847 }
848
849 static void permissions_destroyed(GtkWidget *widget, Permissions *perm)
850 {
851 g_free(perm->path);
852 diritem_free(perm->item);
853
854 g_free(perm);
855 }
856
857 static void permissions_apply(GtkWidget *widget, Permissions *perm)
858 {
859 mode_t nmode;
860 int i;
861
862 nmode=0;
863
864 for (i = 0; i < 9; i++)
865 {
866 GtkToggleButton *bit = GTK_TOGGLE_BUTTON(perm->bits[i]);
867 if (gtk_toggle_button_get_active(bit))
868 nmode |= 1 << i;
869 }
870 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(perm->bits[9])))
871 nmode |= S_ISUID;
872 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(perm->bits[10])))
873 nmode |= S_ISGID;
874 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(perm->bits[11])))
875 nmode |= S_ISVTX;
876
877 if (chmod(perm->path, nmode))
878 report_error(_("Could not change permissions: %s"),
879 g_strerror(errno));
880 }
881
882 static GtkWidget *make_permissions(const gchar *path, DirItem *item)
883 {
884 Permissions *perm;
885 GtkWidget *table;
886 GtkWidget *tick, *label;
887 int i, x, y;
888
889 perm = g_new(Permissions, 1);
890
891 perm->path = g_strdup(path);
892 perm->item = diritem_new(path);
893
894 table = gtk_table_new(4, 5, TRUE);
895
896 label = gtk_label_new(_("Owner"));
897 gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
898 label = gtk_label_new(_("Group"));
899 gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3);
900 label = gtk_label_new(_("World"));
901 gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
902
903 label = gtk_label_new(_("Read"));
904 gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 0, 1);
905 label = gtk_label_new(_("Write"));
906 gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 0, 1);
907 label = gtk_label_new(_("Exec"));
908 gtk_table_attach_defaults(GTK_TABLE(table), label, 3, 4, 0, 1);
909
910 for (i = 0; i < 9; i++)
911 {
912 x = 1 + 2 - i % 3;
913 y = 1 + 2 - i / 3;
914 perm->bits[i] = tick = gtk_check_button_new();
915 gtk_table_attach_defaults(GTK_TABLE(table), tick,
916 x, x + 1, y, y + 1);
917 if (item->mode & (1 << i))
918 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tick),
919 TRUE);
920 g_signal_connect(tick, "toggled",
921 G_CALLBACK(permissions_apply), perm);
922 }
923
924 tick = gtk_check_button_new_with_label(_("SUID"));
925 gtk_table_attach_defaults(GTK_TABLE(table), tick, 4, 5, 1, 2);
926 if (item->mode & S_ISUID)
927 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tick), TRUE);
928 g_signal_connect(tick, "toggled", G_CALLBACK(permissions_apply), perm);
929 perm->bits[9] = tick;
930
931 tick = gtk_check_button_new_with_label(_("SGID"));
932 gtk_table_attach_defaults(GTK_TABLE(table), tick, 4, 5, 2, 3);
933 if (item->mode & S_ISGID)
934 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tick), TRUE);
935 g_signal_connect(tick, "toggled", G_CALLBACK(permissions_apply), perm);
936 perm->bits[10] = tick;
937
938 tick = gtk_check_button_new_with_label(_("Sticky"));
939 gtk_table_attach_defaults(GTK_TABLE(table), tick, 4, 5, 3, 4);
940 if (item->mode & S_ISVTX)
941 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tick), TRUE);
942 g_signal_connect(tick, "toggled", G_CALLBACK(permissions_apply), perm);
943 perm->bits[11] = tick;
944
945 g_signal_connect(table, "destroy",
946 G_CALLBACK(permissions_destroyed), perm);
947
948 gtk_widget_show_all(table);
949 return table;
950 }
951
952 /* Don't g_free() the result */
953 static const gchar *pretty_type(DirItem *file, const guchar *path)
954 {
955 static gchar *text = NULL;
956
957 null_g_free(&text);
958
959 if (file->flags & ITEM_FLAG_SYMLINK)
960 return _("Symbolic link");
961
962 if (file->flags & ITEM_FLAG_APPDIR)
963 return _("ROX application");
964
965 if (file->flags & ITEM_FLAG_MOUNT_POINT)
966 {
967 MountPoint *mp;
968 const gchar *mounted;
969
970 mounted = mount_is_mounted(path, NULL, NULL)
971 ? _("mounted") : _("unmounted");
972
973 mp = g_hash_table_lookup(fstab_mounts, path);
974 if (mp)
975 text = g_strdup_printf(_("Mount point for %s (%s)"),
976 mp->name, mounted);
977 else
978 text = g_strdup_printf(_("Mount point (%s)"), mounted);
979 return text;
980 }
981
982 if (file->mime_type)
983 {
984 text = g_strconcat(file->mime_type->media_type, "/",
985 file->mime_type->subtype, NULL);
986 return text;
987 }
988
989 return "-";
990 }
Filer for the ROX desktop