ROX-Filer/src/infobox.c

   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_heading(name, PANGO_SCALE_X_LARGE);
 246
 247         /* List of file attributes */
 248         add_frame(vbox, make_details(path, item, window));
 249
 250         help_dir = g_strconcat(path, "/Help", NULL);
 251
 252         if (access(help_dir, F_OK) == 0)
 253         {
 254                 GtkWidget *button, *align;
 255
 256                 align = gtk_alignment_new(0.5, 0.5, 0, 0);
 257
 258                 button = button_new_mixed(GTK_STOCK_JUMP_TO,
 259                                 _("Show _Help Files"));
 260                 gtk_box_pack_start(vbox, align, FALSE, TRUE, 0);
 261                 gtk_container_add(GTK_CONTAINER(align), button);
 262                 g_signal_connect_swapped(button, "clicked",
 263                                 G_CALLBACK(show_help_files),
 264                                 (gpointer) path);
 265         }
 266         g_free(help_dir);
 267
 268         if (!(item->flags & ITEM_FLAG_SYMLINK))
 269         {
 270                 label = gtk_label_new(NULL);
 271                 gtk_label_set_markup(GTK_LABEL(label),
 272                                      _("<b>Permissions</b>"));
 273                 gtk_misc_set_alignment(GTK_MISC(label), 0, 1);
 274                 gtk_box_pack_start(vbox, label, FALSE, TRUE, 2);
 275
 276                 gtk_box_pack_start(vbox, make_permissions(path, item),
 277                                    FALSE, TRUE, 0);
 278         }
 279
 280         if (about)
 281                 add_frame(vbox, make_about(path, ai));
 282         else if (item->base_type == TYPE_FILE)
 283         {
 284                 label = gtk_label_new(NULL);
 285                 gtk_label_set_markup(GTK_LABEL(label),
 286                                 _("<b>Contents indicate...</b>"));
 287                 gtk_misc_set_alignment(GTK_MISC(label), 0, 1);
 288                 gtk_box_pack_start(vbox, label, FALSE, TRUE, 2);
 289
 290                 gtk_box_pack_start_defaults(vbox, make_file_says(path));
 291         }
 292
 293         if (ai)
 294                 g_object_unref(ai);
 295
 296         diritem_free(item);
 297
 298         return (GtkWidget *) vbox;
 299 }
 300
 301 /* The selection has changed - grab or release the primary selection */
 302 static void set_selection(GtkTreeView *view, gpointer data)
 303 {
 304         static GtkClipboard *primary = NULL;
 305         GtkTreeModel *model;
 306         GtkTreePath *path = NULL;
 307         GtkTreeIter iter;
 308         gchar   *text;
 309
 310         gtk_tree_view_get_cursor(view, &path, NULL);
 311         if (!path)
 312                 return;
 313
 314         if (!primary)
 315                 primary = gtk_clipboard_get(gdk_atom_intern("PRIMARY", FALSE));
 316
 317         model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 318
 319         gtk_tree_model_get_iter(model, &iter, path);
 320         gtk_tree_path_free(path);
 321
 322         gtk_tree_model_get(model, &iter, 1, &text, -1);
 323
 324         gtk_clipboard_set_text(primary, text, -1);
 325
 326         g_free(text);
 327 }
 328
 329 /* Returns a GtkTreePath for the item */
 330 static const gchar *add_row(GtkListStore *store, const gchar *label,
 331                       const gchar *data)
 332 {
 333         GtkTreeIter     iter;
 334         gchar           *u8 = NULL;
 335         GtkTreePath     *tpath;
 336         static gchar    *last = NULL;
 337
 338         if (!g_utf8_validate(data, -1, NULL))
 339                 u8 = to_utf8(data);
 340
 341         gtk_list_store_append(store, &iter);
 342         gtk_list_store_set(store, &iter, 0, label, 1, u8 ? u8 : data, -1);
 343
 344         g_free(u8);
 345
 346         tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
 347         if (last)
 348                 g_free(last);
 349         last = gtk_tree_path_to_string(tpath);
 350         gtk_tree_path_free(tpath);
 351
 352         return last;
 353 }
 354
 355 static void add_row_and_free(GtkListStore *store,
 356                              const gchar *label, gchar *data)
 357 {
 358         add_row(store, label, data);
 359         g_free(data);
 360 }
 361
 362 /* Create an empty list view, ready to place some data in */
 363 static void make_list(GtkListStore **list_store, GtkWidget **list_view,
 364                         GCallback cell_edited)
 365 {
 366         GtkListStore    *store;
 367         GtkTreeView     *view;
 368         GtkCellRenderer *cell_renderer;
 369
 370         /* Field name, value, editable */
 371         store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING,
 372                                         G_TYPE_BOOLEAN);
 373         view = GTK_TREE_VIEW(
 374                         gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)));
 375         g_object_unref(G_OBJECT(store));
 376         gtk_tree_view_set_headers_visible(view, FALSE);
 377
 378         cell_renderer = gtk_cell_renderer_text_new();
 379         g_object_set(G_OBJECT(cell_renderer), "xalign", 1.0, NULL);
 380         gtk_tree_view_insert_column_with_attributes(view,
 381                         0, NULL, cell_renderer, "text", 0, NULL);
 382
 383         cell_renderer = gtk_cell_renderer_text_new();
 384         gtk_tree_view_insert_column_with_attributes(view,
 385                         1, NULL, cell_renderer, "text", 1, "editable", 2, NULL);
 386
 387         if (cell_edited) {
 388                 g_signal_connect(G_OBJECT(cell_renderer), "edited",
 389                                 G_CALLBACK(cell_edited), store);
 390         }
 391
 392         g_signal_connect(view, "cursor_changed",
 393                         G_CALLBACK(set_selection), NULL);
 394
 395         *list_store = store;
 396         *list_view = (GtkWidget *) view;
 397 }
 398
 399 static void set_cell(GtkListStore *store, const gchar *path,
 400                      const gchar *ctext)
 401 {
 402         GtkTreeIter iter;
 403
 404         gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store),
 405                                             &iter, path);
 406         gtk_list_store_set(store, &iter, 1, ctext, -1);
 407 }
 408
 409 static void insert_size(DU *du, const char *line)
 410 {
 411         off_t size;
 412         gchar *cell;
 413
 414 #ifdef  LARGE_FILE_SUPPORT
 415         size = strtoll(line, NULL, 10);
 416 #else
 417         size = strtol(line, NULL, 10);
 418 #endif
 419         size <<= 10; /* Because du reports in K */
 420         cell = (size >= PRETTY_SIZE_LIMIT)
 421                 ? g_strdup_printf("%s (%" SIZE_FMT " %s)",
 422                                 format_size(size),
 423                                 size, _("bytes"))
 424                 : g_strdup(format_size(size));
 425
 426         set_cell(du->store, du->path, cell);
 427
 428         g_free(cell);
 429 }
 430
 431 static gboolean read_du_output(GIOChannel *source, GIOCondition cond, DU *du)
 432 {
 433         GString *line;
 434         GIOStatus stat;
 435         GError *err = NULL;
 436
 437         line = g_string_new("");
 438         stat = g_io_channel_read_line_string(source, line, NULL, &err);
 439         switch (stat)
 440         {
 441                 case G_IO_STATUS_NORMAL:
 442                         insert_size(du, line->str);
 443                         break;
 444                 case G_IO_STATUS_EOF:
 445                         set_cell(du->store, du->path,
 446                                  _("Failed to read size"));
 447                         break;
 448                 case G_IO_STATUS_AGAIN:
 449                         g_string_free(line, TRUE);
 450                         return TRUE;
 451                 case G_IO_STATUS_ERROR:
 452                         set_cell(du->store, du->path, err->message);
 453                         break;
 454         }
 455         g_string_free(line, TRUE);
 456
 457         return FALSE;
 458 }
 459
 460 static void kill_du_output(GtkWidget *widget, DU *du)
 461 {
 462         g_source_remove(du->watch);
 463         g_io_channel_shutdown(du->chan, FALSE, NULL);
 464         g_io_channel_unref(du->chan);
 465         kill((pid_t) du->child, SIGTERM);
 466         g_object_unref(G_OBJECT(du->store));
 467         g_free(du->path);
 468         g_free(du);
 469 }
 470
 471 static gboolean refresh_info_idle(gpointer data)
 472 {
 473         GObject *window = G_OBJECT(data);
 474
 475         refresh_info(window);
 476         g_object_unref(window);
 477         return FALSE;
 478 }
 479
 480 static void cell_edited(GtkCellRendererText *cell,
 481              const gchar *path_string,
 482              const gchar *new_text,
 483              gpointer data)
 484 {
 485         GtkTreeModel *model = (GtkTreeModel *) data;
 486         GtkTreePath *path;
 487         GtkTreeIter iter;
 488         GObject *window;
 489         const char *fullpath;
 490         char *oldlink;
 491
 492         window = g_object_get_data(G_OBJECT(model), "rox_window");
 493         g_return_if_fail(window != NULL);
 494
 495         fullpath = g_object_get_data(window, "path");
 496         g_return_if_fail(fullpath != NULL);
 497
 498         path = gtk_tree_path_new_from_string(path_string);
 499         gtk_tree_model_get_iter(model, &iter, path);
 500         gtk_tree_path_free(path);
 501
 502         oldlink = readlink_dup(fullpath);
 503         if (!oldlink) {
 504                 report_error(_("'%s' is no longer a symlink"), fullpath);
 505                 return;
 506         }
 507         if (strcmp(oldlink, new_text) == 0)
 508                 return; /* No change */
 509         g_free(oldlink);
 510         if (unlink(fullpath)) {
 511                 report_error(_("Failed to unlink '%s':\n%s"),
 512                                 fullpath, g_strerror(errno));
 513                 return;
 514         }
 515         if (symlink(new_text, fullpath)) {
 516                 report_error(_("Failed to create symlink from '%s':\n%s\n"
 517                                 "(note: old link has been deleted)"));
 518                 return;
 519         }
 520
 521         g_object_ref(window);
 522         g_idle_add(refresh_info_idle, window);
 523 }
 524
 525 /* Create the TreeView widget with the file's details */
 526 static GtkWidget *make_details(const guchar *path, DirItem *item,
 527                                 GObject *window)
 528 {
 529         GtkListStore    *store;
 530         GtkWidget       *view;
 531         gchar           *tmp, *tmp2;
 532
 533         make_list(&store, &view, G_CALLBACK(cell_edited));
 534         g_object_set_data(G_OBJECT(store), "rox_window", window);
 535
 536         /* For a symlink to an error, don't show the error */
 537         if (item->base_type == TYPE_ERROR && item->lstat_errno)
 538         {
 539                 add_row(store, _("Error:"), g_strerror(item->lstat_errno));
 540                 return view;
 541         }
 542
 543         tmp = g_path_get_dirname(path);
 544         tmp2 = pathdup(tmp);
 545         if (strcmp(tmp, tmp2) != 0)
 546                 add_row_and_free(store, _("Real directory:"), tmp2);
 547         g_free(tmp);
 548
 549         add_row_and_free(store, _("Owner, Group:"),
 550                          g_strdup_printf("%s, %s",
 551                                          user_name(item->uid),
 552                                          group_name(item->gid)));
 553
 554         if (item->base_type != TYPE_DIRECTORY)
 555         {
 556                 add_row_and_free(store, _("Size:"),
 557                                  item->size >= PRETTY_SIZE_LIMIT
 558                                  ? g_strdup_printf("%s (%" SIZE_FMT " %s)",
 559                                                    format_size(item->size),
 560                                                    item->size, _("bytes"))
 561                                  : g_strdup(format_size(item->size)));
 562         }
 563         else
 564         {
 565                 gchar *stt=NULL;
 566
 567                 if(item->flags & ITEM_FLAG_MOUNTED)
 568                         stt=mount_get_fs_size(path);
 569
 570                 if(stt) {
 571                         add_row_and_free(store, _("Size:"), stt);
 572                 } else {
 573                         DU *du;
 574                         int out;
 575
 576                         gchar *args[] = {"du", "-sk", "", NULL};
 577
 578                         du = g_new(DU, 1);
 579                         du->store = store;
 580                         du->path = g_strdup(add_row(store, _("Size:"),
 581                                                     _("Scanning")));
 582
 583                         args[2] = (gchar *) path;
 584                         if (g_spawn_async_with_pipes(NULL, args, NULL,
 585                                                      G_SPAWN_SEARCH_PATH,
 586                                                      NULL, NULL, &du->child,
 587                                                      NULL, &out, NULL,
 588                                                      NULL))
 589                         {
 590                                 du->chan = g_io_channel_unix_new(out);
 591                                 du->watch = g_io_add_watch(du->chan,
 592                                                    G_IO_IN|G_IO_ERR|G_IO_HUP,
 593                                                  (GIOFunc) read_du_output, du);
 594                                 g_object_ref(G_OBJECT(du->store));
 595                                 g_signal_connect(G_OBJECT(view),
 596                                                  "destroy",
 597                                                  G_CALLBACK(kill_du_output),
 598                                                  du);
 599                         }
 600                         else
 601                         {
 602                                 set_cell(store, du->path, _("Failed to scan"));
 603                                 g_free(du->path);
 604                                 g_free(du);
 605                         }
 606                 }
 607         }
 608
 609         add_row_and_free(store, _("Change time:"), pretty_time(&item->ctime));
 610
 611         add_row_and_free(store, _("Modify time:"), pretty_time(&item->mtime));
 612
 613         add_row_and_free(store, _("Access time:"), pretty_time(&item->atime));
 614
 615         add_row(store, _("Type:"), pretty_type(item, path));
 616
 617         if (item->mime_type)
 618                 add_row(store, "", mime_type_comment(item->mime_type));
 619
 620         if (xtype_supported(NULL)) {
 621                 add_row(store, _("Extended attributes:"),
 622                   (item->flags & ITEM_FLAG_HAS_XATTR)
 623                         ? _("Present")
 624                         : xtype_supported(path) ? _("None")
 625                                                 : _("Not supported"));
 626         }
 627
 628         if (item->flags & ITEM_FLAG_SYMLINK)
 629         {
 630                 GtkTreeIter iter;
 631                 GtkTreeModel *model = GTK_TREE_MODEL(store);
 632                 char *target;
 633
 634                 target = readlink_dup(path);
 635                 if (!target)
 636                         target = g_strdup(g_strerror(errno));
 637                 add_row_and_free(store, _("Link target:"), target);
 638
 639                 /* Make cell editable */
 640                 gtk_tree_model_iter_nth_child(model, &iter,
 641                         NULL, gtk_tree_model_iter_n_children(model, NULL) - 1);
 642
 643                 gtk_list_store_set(store, &iter, 2, TRUE, -1);
 644         }
 645
 646         if (item->base_type != TYPE_DIRECTORY)
 647         {
 648                 if (EXECUTABLE_FILE(item))
 649                         add_row(store, _("Run action:"), _("Execute file"));
 650                 else
 651                 {
 652                         add_row_and_free(store, _("Run action:"),
 653                                 describe_current_command(item->mime_type));
 654                 }
 655         }
 656
 657         return view;
 658 }
 659
 660 /* Create the TreeView widget with the application's details */
 661 static GtkWidget *make_about(const guchar *path, XMLwrapper *ai)
 662 {
 663         GtkListStore    *store;
 664         GtkWidget       *view;
 665         xmlNode         *prop;
 666         xmlNode         *about, *about_trans;
 667         GHashTable      *translate;
 668
 669         g_return_val_if_fail(ai != NULL, NULL);
 670
 671         about_trans = xml_get_section(ai, NULL, "About");
 672
 673         about = xmlDocGetRootElement(ai->doc)->xmlChildrenNode;
 674         for (; about; about = about->next)
 675         {
 676                 if (about->type != XML_ELEMENT_NODE)
 677                         continue;
 678                 if (about->ns == NULL && strcmp(about->name, "About") == 0)
 679                         break;
 680         }
 681
 682         g_return_val_if_fail(about != NULL, NULL);
 683
 684         make_list(&store, &view, NULL);
 685
 686         /* Add each field in about to the list, but overriding each element
 687          * with about_trans if a translation is supplied.
 688          */
 689         translate = g_hash_table_new(g_str_hash, g_str_equal);
 690         if (about_trans != about)
 691         {
 692                 xmlNode *p;
 693                 for (p = about_trans->xmlChildrenNode; p; p = p->next)
 694                 {
 695                         if (p->type != XML_ELEMENT_NODE)
 696                                 continue;
 697                         g_hash_table_insert(translate, (char *) p->name, p);
 698                 }
 699         }
 700         for (prop = about->xmlChildrenNode; prop; prop = prop->next)
 701         {
 702                 if (prop->type == XML_ELEMENT_NODE)
 703                 {
 704                         char *label = NULL;
 705                         char *value = NULL;
 706                         char *tmp = NULL;
 707                         xmlNode *trans;
 708
 709                         trans = g_hash_table_lookup(translate, prop->name);
 710                         if (!trans)
 711                                 trans = prop;
 712
 713                         tmp = xmlGetProp(trans, "label");
 714                         label = g_strconcat(tmp ? tmp
 715                                                 : (char *) trans->name,
 716                                             ":", NULL);
 717                         g_free(tmp);
 718                         value = xmlNodeListGetString(trans->doc,
 719                                            trans->xmlChildrenNode, 1);
 720                         if (!value)
 721                                 value = xmlNodeListGetString(prop->doc,
 722                                                 prop->xmlChildrenNode, 1);
 723                         if (!value)
 724                                 value = g_strdup("-");
 725                         add_row_and_free(store, label, value);
 726                         g_free(label);
 727                 }
 728         }
 729
 730         g_hash_table_destroy(translate);
 731
 732         return view;
 733 }
 734
 735 static GtkWidget *make_file_says(const guchar *path)
 736 {
 737         GtkWidget       *w_file_label;
 738         GtkLabel        *l_file_label;
 739         int             file_data[2];
 740         char            *argv[] = {"file", "-b", NULL, NULL};
 741         FileStatus      *fs = NULL;
 742         guchar          *tmp;
 743
 744         w_file_label = gtk_label_new(_("<nothing yet>"));
 745         l_file_label = GTK_LABEL(w_file_label);
 746         gtk_label_set_line_wrap(l_file_label, TRUE);
 747
 748         if (pipe(file_data))
 749         {
 750                 tmp = g_strdup_printf("pipe(): %s", g_strerror(errno));
 751                 gtk_label_set_text(l_file_label, tmp);
 752                 g_free(tmp);
 753                 return w_file_label;
 754         }
 755
 756         switch (fork())
 757         {
 758                 case -1:
 759                         tmp = g_strdup_printf("pipe(): %s", g_strerror(errno));
 760                         gtk_label_set_text(l_file_label, tmp);
 761                         g_free(tmp);
 762                         close(file_data[0]);
 763                         close(file_data[1]);
 764                         break;
 765                 case 0:
 766                         /* We are the child */
 767                         close(file_data[0]);
 768                         dup2(file_data[1], STDOUT_FILENO);
 769                         dup2(file_data[1], STDERR_FILENO);
 770 #ifdef FILE_B_FLAG
 771                         argv[2] = (char *) path;
 772 #else
 773                         argv[1] = (char *) g_basename(path);
 774                         chdir(g_path_get_dirname(path));
 775 #endif
 776                         if (execvp(argv[0], argv))
 777                                 fprintf(stderr, "execvp() error: %s\n",
 778                                                 g_strerror(errno));
 779                         _exit(0);
 780                 default:
 781                         /* We are the parent */
 782                         close(file_data[1]);
 783                         fs = g_new(FileStatus, 1);
 784                         fs->label = l_file_label;
 785                         fs->fd = file_data[0];
 786                         fs->text = g_strdup("");
 787                         fs->input = gdk_input_add_full(fs->fd, GDK_INPUT_READ,
 788                                 (GdkInputFunction) add_file_output,
 789                                 fs, NULL);
 790                         g_signal_connect(w_file_label, "destroy",
 791                                 G_CALLBACK(file_info_destroyed), fs);
 792                         break;
 793         }
 794
 795         return w_file_label;
 796 }
 797
 798 /* Got some data from file(1) - stick it in the window. */
 799 static void add_file_output(FileStatus *fs,
 800                             gint source, GdkInputCondition condition)
 801 {
 802         char    buffer[20];
 803         char    *str;
 804         int     got;
 805
 806         got = read(source, buffer, sizeof(buffer) - 1);
 807         if (got <= 0)
 808         {
 809                 int     err = errno;
 810                 g_source_remove(fs->input);
 811                 close(source);
 812                 fs->fd = -1;
 813                 if (got < 0)
 814                         delayed_error(_("file(1) says... %s"),
 815                                         g_strerror(err));
 816                 return;
 817         }
 818         buffer[got] = '\0';
 819
 820         str = g_strconcat(fs->text, buffer, NULL);
 821         g_free(fs->text);
 822         fs->text = str;
 823
 824         str = to_utf8(fs->text);
 825         g_strstrip(str);
 826         gtk_label_set_text(fs->label, str);
 827         g_free(str);
 828 }
 829
 830 static void file_info_destroyed(GtkWidget *widget, FileStatus *fs)
 831 {
 832         if (fs->fd != -1)
 833         {
 834                 g_source_remove(fs->input);
 835                 close(fs->fd);
 836         }
 837
 838         g_free(fs->text);
 839         g_free(fs);
 840 }
 841
 842 static void permissions_destroyed(GtkWidget *widget, Permissions *perm)
 843 {
 844         g_free(perm->path);
 845         diritem_free(perm->item);
 846
 847         g_free(perm);
 848 }
 849
 850 static void permissions_apply(GtkWidget *widget, Permissions *perm)
 851 {
 852         mode_t nmode;
 853         int i;
 854
 855         nmode=0;
 856
 857         for (i = 0; i < 9; i++)
 858         {
 859                 GtkToggleButton *bit = GTK_TOGGLE_BUTTON(perm->bits[i]);
 860                 if (gtk_toggle_button_get_active(bit))
 861                         nmode |= 1 << i;
 862         }
 863         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(perm->bits[9])))
 864                 nmode |= S_ISUID;
 865         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(perm->bits[10])))
 866                 nmode |= S_ISGID;
 867         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(perm->bits[11])))
 868                 nmode |= S_ISVTX;
 869
 870         if (chmod(perm->path, nmode))
 871                 report_error(_("Could not change permissions: %s"),
 872                              g_strerror(errno));
 873 }
 874
 875 static GtkWidget *make_permissions(const gchar *path, DirItem *item)
 876 {
 877         Permissions *perm;
 878         GtkWidget *table;
 879         GtkWidget *tick, *label;
 880         int i, x, y;
 881
 882         perm = g_new(Permissions, 1);
 883
 884         perm->path = g_strdup(path);
 885         perm->item = diritem_new(path);
 886
 887         table = gtk_table_new(4, 5, TRUE);
 888
 889         label = gtk_label_new(_("Owner"));
 890         gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
 891         label = gtk_label_new(_("Group"));
 892         gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3);
 893         label = gtk_label_new(_("World"));
 894         gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
 895
 896         label = gtk_label_new(_("Read"));
 897         gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 0, 1);
 898         label = gtk_label_new(_("Write"));
 899         gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 0, 1);
 900         label = gtk_label_new(_("Exec"));
 901         gtk_table_attach_defaults(GTK_TABLE(table), label, 3, 4, 0, 1);
 902
 903         for (i = 0; i < 9; i++)
 904         {
 905                 x = 1 + 2 - i % 3;
 906                 y = 1 + 2 - i / 3;
 907                 perm->bits[i] = tick = gtk_check_button_new();
 908                 gtk_table_attach_defaults(GTK_TABLE(table), tick,
 909                                           x, x + 1, y, y + 1);
 910                 if (item->mode & (1 << i))
 911                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tick),
 912                                                      TRUE);
 913                 g_signal_connect(tick, "toggled",
 914                                 G_CALLBACK(permissions_apply), perm);
 915         }
 916
 917         tick = gtk_check_button_new_with_label(_("SUID"));
 918         gtk_table_attach_defaults(GTK_TABLE(table), tick, 4, 5, 1, 2);
 919         if (item->mode & S_ISUID)
 920                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tick), TRUE);
 921         g_signal_connect(tick, "toggled", G_CALLBACK(permissions_apply), perm);
 922         perm->bits[9] = tick;
 923
 924         tick = gtk_check_button_new_with_label(_("SGID"));
 925         gtk_table_attach_defaults(GTK_TABLE(table), tick, 4, 5, 2, 3);
 926         if (item->mode & S_ISGID)
 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[10] = tick;
 930
 931         tick = gtk_check_button_new_with_label(_("Sticky"));
 932         gtk_table_attach_defaults(GTK_TABLE(table), tick, 4, 5, 3, 4);
 933         if (item->mode & S_ISVTX)
 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[11] = tick;
 937
 938         g_signal_connect(table, "destroy",
 939                                 G_CALLBACK(permissions_destroyed), perm);
 940
 941         gtk_widget_show_all(table);
 942         return table;
 943 }
 944
 945 /* Don't g_free() the result */
 946 static const gchar *pretty_type(DirItem *file, const guchar *path)
 947 {
 948         static gchar *text = NULL;
 949
 950         null_g_free(&text);
 951
 952         if (file->flags & ITEM_FLAG_SYMLINK)
 953                 return _("Symbolic link");
 954
 955         if (file->flags & ITEM_FLAG_APPDIR)
 956                 return _("ROX application");
 957
 958         if (file->flags & ITEM_FLAG_MOUNT_POINT)
 959         {
 960                 MountPoint *mp;
 961                 const gchar *mounted;
 962
 963                 mounted = mount_is_mounted(path, NULL, NULL)
 964                           ? _("mounted") : _("unmounted");
 965
 966                 mp = g_hash_table_lookup(fstab_mounts, path);
 967                 if (mp)
 968                         text = g_strdup_printf(_("Mount point for %s (%s)"),
 969                                                mp->name, mounted);
 970                 else
 971                         text = g_strdup_printf(_("Mount point (%s)"), mounted);
 972                 return text;
 973         }
 974
 975         if (file->mime_type)
 976         {
 977                 text = g_strconcat(file->mime_type->media_type, "/",
 978                                           file->mime_type->subtype, NULL);
 979                 return text;
 980         }
 981
 982         return "-";
 983 }