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