ROX-Filer/src/display.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 /* display.c - code for arranging and displaying file items */
  23
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <math.h>
  29 #include <string.h>
  30 #include <errno.h>
  31 #include <sys/param.h>
  32 #include <unistd.h>
  33 #include <time.h>
  34 #include <ctype.h>
  35
  36 #include <gtk/gtk.h>
  37 #include <gdk/gdkx.h>
  38 #include <gdk/gdkkeysyms.h>
  39
  40 #include "global.h"
  41
  42 #include "main.h"
  43 #include "filer.h"
  44 #include "display.h"
  45 #include "support.h"
  46 #include "gui_support.h"
  47 #include "pixmaps.h"
  48 #include "menu.h"
  49 #include "dnd.h"
  50 #include "run.h"
  51 #include "mount.h"
  52 #include "type.h"
  53 #include "options.h"
  54 #include "action.h"
  55 #include "minibuffer.h"
  56 #include "dir.h"
  57 #include "diritem.h"
  58 #include "fscache.h"
  59 #include "view_iface.h"
  60
  61 #define HUGE_WRAP (1.5 * o_large_width.int_value)
  62
  63 /* Options bits */
  64 static Option o_display_caps_first;
  65 static Option o_display_dirs_first;
  66 Option o_display_size;
  67 Option o_display_details;
  68 Option o_display_sort_by;
  69 static Option o_large_width;
  70 Option o_small_width;
  71 Option o_display_show_hidden;
  72 Option o_display_show_thumbs;
  73 Option o_display_show_headers;
  74 Option o_display_inherit_options;
  75 static Option o_filer_change_size_num;
  76
  77 /* Static prototypes */
  78 static void display_details_set(FilerWindow *filer_window, DetailsType details);
  79 static void display_style_set(FilerWindow *filer_window, DisplayStyle style);
  80 static void options_changed(void);
  81 static char *details(FilerWindow *filer_window, DirItem *item);
  82 static void display_set_actual_size_real(FilerWindow *filer_window);
  83
  84 /****************************************************************
  85  *                      EXTERNAL INTERFACE                      *
  86  ****************************************************************/
  87
  88 void display_init()
  89 {
  90         option_add_int(&o_display_caps_first, "display_caps_first", FALSE);
  91         option_add_int(&o_display_dirs_first, "display_dirs_first", FALSE);
  92         option_add_int(&o_display_size, "display_icon_size", AUTO_SIZE_ICONS);
  93         option_add_int(&o_display_details, "display_details", DETAILS_NONE);
  94         option_add_int(&o_display_sort_by, "display_sort_by", SORT_NAME);
  95         option_add_int(&o_large_width, "display_large_width", 155);
  96         option_add_int(&o_small_width, "display_small_width", 250);
  97         option_add_int(&o_display_show_hidden, "display_show_hidden", FALSE);
  98         option_add_int(&o_display_show_thumbs, "display_show_thumbs", FALSE);
  99         option_add_int(&o_display_show_headers, "display_show_headers", TRUE);
 100         option_add_int(&o_display_inherit_options,
 101                        "display_inherit_options", FALSE);
 102         option_add_int(&o_filer_change_size_num, "filer_change_size_num", 30);
 103
 104         option_add_notify(options_changed);
 105 }
 106
 107 static void draw_emblem_on_icon(GdkWindow *window, MaskedPixmap *image,
 108                                 int *x, int y)
 109 {
 110         gdk_pixbuf_render_to_drawable_alpha(image->pixbuf,
 111                                 window,
 112                                 0, 0,                           /* src */
 113                                 *x, y,                          /* dest */
 114                                 -1, -1,
 115                                 GDK_PIXBUF_ALPHA_FULL, 128,     /* (unused) */
 116                                 GDK_RGB_DITHER_NORMAL, 0, 0);
 117
 118         *x+=image->width+1;
 119 }
 120
 121 /* Draw this icon (including any symlink or mount symbol) inside the
 122  * given rectangle.
 123  */
 124 void draw_huge_icon(GdkWindow *window, GdkRectangle *area,
 125                    DirItem  *item, MaskedPixmap *image, gboolean selected)
 126 {
 127         int             width, height;
 128         int             image_x;
 129         int             image_y;
 130
 131         if (!image)
 132                 return;
 133
 134         width = image->huge_width;
 135         height = image->huge_height;
 136         image_x = area->x + ((area->width - width) >> 1);
 137         image_y = MAX(0, area->height - height - 6);
 138
 139         gdk_pixbuf_render_to_drawable_alpha(
 140                         selected ? image->huge_pixbuf_lit
 141                                  : image->huge_pixbuf,
 142                         window,
 143                         0, 0,                           /* src */
 144                         image_x, area->y + image_y,     /* dest */
 145                         width, height,
 146                         GDK_PIXBUF_ALPHA_FULL, 128,     /* (unused) */
 147                         GDK_RGB_DITHER_NORMAL, 0, 0);
 148
 149         if (item->flags & ITEM_FLAG_MOUNT_POINT)
 150         {
 151                 MaskedPixmap    *mp = item->flags & ITEM_FLAG_MOUNTED
 152                                         ? im_mounted
 153                                         : im_unmounted;
 154                 draw_emblem_on_icon(window, mp, &image_x, area->y + 2);
 155         }
 156         if (item->flags & ITEM_FLAG_SYMLINK)
 157         {
 158                 draw_emblem_on_icon(window, im_symlink, &image_x, area->y + 2);
 159         }
 160         if (item->flags & ITEM_FLAG_HAS_XATTR)
 161         {
 162                 draw_emblem_on_icon(window, im_xattr, &image_x, area->y + 2);
 163         }
 164 }
 165
 166 /* Draw this icon (including any symlink or mount symbol) inside the
 167  * given rectangle.
 168  */
 169 void draw_large_icon(GdkWindow *window,
 170                      GdkRectangle *area,
 171                      DirItem  *item,
 172                      MaskedPixmap *image,
 173                      gboolean selected)
 174 {
 175         int     width;
 176         int     height;
 177         int     image_x;
 178         int     image_y;
 179
 180         if (!image)
 181                 return;
 182
 183         width = MIN(image->width, ICON_WIDTH);
 184         height = MIN(image->height, ICON_HEIGHT);
 185         image_x = area->x + ((area->width - width) >> 1);
 186         image_y = MAX(0, area->height - height - 6);
 187
 188         gdk_pixbuf_render_to_drawable_alpha(
 189                         selected ? image->pixbuf_lit : image->pixbuf,
 190                         window,
 191                         0, 0,                           /* src */
 192                         image_x, area->y + image_y,     /* dest */
 193                         width, height,
 194                         GDK_PIXBUF_ALPHA_FULL, 128,     /* (unused) */
 195                         GDK_RGB_DITHER_NORMAL, 0, 0);
 196
 197         if (item->flags & ITEM_FLAG_MOUNT_POINT)
 198         {
 199                 MaskedPixmap    *mp = item->flags & ITEM_FLAG_MOUNTED
 200                                         ? im_mounted
 201                                         : im_unmounted;
 202                 draw_emblem_on_icon(window, mp, &image_x, area->y + 2);
 203         }
 204         if (item->flags & ITEM_FLAG_SYMLINK)
 205         {
 206                 draw_emblem_on_icon(window, im_symlink, &image_x, area->y + 2);
 207         }
 208         if (item->flags & ITEM_FLAG_HAS_XATTR)
 209         {
 210                 draw_emblem_on_icon(window, im_xattr, &image_x, area->y + 2);
 211         }
 212 }
 213
 214 void draw_small_icon(GdkWindow *window, GdkRectangle *area,
 215                      DirItem  *item, MaskedPixmap *image, gboolean selected)
 216 {
 217         int             width, height, image_x, image_y;
 218
 219         if (!image)
 220                 return;
 221
 222         if (!image->sm_pixbuf)
 223                 pixmap_make_small(image);
 224
 225         width = MIN(image->sm_width, SMALL_WIDTH);
 226         height = MIN(image->sm_height, SMALL_HEIGHT);
 227         image_x = area->x + ((area->width - width) >> 1);
 228         image_y = MAX(0, SMALL_HEIGHT - image->sm_height);
 229
 230         gdk_pixbuf_render_to_drawable_alpha(
 231                         selected ? image->sm_pixbuf_lit : image->sm_pixbuf,
 232                         window,
 233                         0, 0,                           /* src */
 234                         image_x, area->y + image_y,     /* dest */
 235                         width, height,
 236                         GDK_PIXBUF_ALPHA_FULL, 128,     /* (unused) */
 237                         GDK_RGB_DITHER_NORMAL, 0, 0);
 238
 239         if (item->flags & ITEM_FLAG_MOUNT_POINT)
 240         {
 241                 MaskedPixmap    *mp = item->flags & ITEM_FLAG_MOUNTED
 242                                         ? im_mounted
 243                                         : im_unmounted;
 244                 draw_emblem_on_icon(window, mp, &image_x, area->y + 2);
 245         }
 246         if (item->flags & ITEM_FLAG_SYMLINK)
 247         {
 248                 draw_emblem_on_icon(window, im_symlink, &image_x, area->y + 8);
 249         }
 250         if (item->flags & ITEM_FLAG_HAS_XATTR)
 251         {
 252                 draw_emblem_on_icon(window, im_xattr, &image_x, area->y + 8);
 253         }
 254 }
 255
 256 /* The sort functions aren't called from outside, but they are
 257  * passed as arguments to display_set_sort_fn().
 258  */
 259
 260 #define IS_A_DIR(item) (item->base_type == TYPE_DIRECTORY && \
 261                         !(item->flags & ITEM_FLAG_APPDIR))
 262
 263 #define SORT_DIRS       \
 264         if (o_display_dirs_first.int_value) {   \
 265                 gboolean id1 = IS_A_DIR(i1);    \
 266                 gboolean id2 = IS_A_DIR(i2);    \
 267                 if (id1 && !id2) return -1;                             \
 268                 if (id2 && !id1) return 1;                              \
 269         }
 270
 271 int sort_by_name(const void *item1, const void *item2)
 272 {
 273         const DirItem *i1 = (DirItem *) item1;
 274         const DirItem *i2 = (DirItem *) item2;
 275         CollateKey *n1 = i1->leafname_collate;
 276         CollateKey *n2 = i2->leafname_collate;
 277         int retval;
 278
 279         SORT_DIRS;
 280
 281         retval = collate_key_cmp(n1, n2, o_display_caps_first.int_value);
 282
 283         return retval ? retval : strcmp(i1->leafname, i2->leafname);
 284 }
 285
 286 int sort_by_type(const void *item1, const void *item2)
 287 {
 288         const DirItem *i1 = (DirItem *) item1;
 289         const DirItem *i2 = (DirItem *) item2;
 290         MIME_type *m1, *m2;
 291
 292         int      diff = i1->base_type - i2->base_type;
 293
 294         if (!diff)
 295                 diff = (i1->flags & ITEM_FLAG_APPDIR)
 296                      - (i2->flags & ITEM_FLAG_APPDIR);
 297         if (diff)
 298                 return diff > 0 ? 1 : -1;
 299
 300         m1 = i1->mime_type;
 301         m2 = i2->mime_type;
 302
 303         if (m1 && m2)
 304         {
 305                 diff = strcmp(m1->media_type, m2->media_type);
 306                 if (!diff)
 307                         diff = strcmp(m1->subtype, m2->subtype);
 308         }
 309         else if (m1 || m2)
 310                 diff = m1 ? 1 : -1;
 311         else
 312                 diff = 0;
 313
 314         if (diff)
 315                 return diff > 0 ? 1 : -1;
 316
 317         return sort_by_name(item1, item2);
 318 }
 319
 320 int sort_by_owner(const void *item1, const void *item2)
 321 {
 322         const DirItem *i1 = (DirItem *) item1;
 323         const DirItem *i2 = (DirItem *) item2;
 324         const gchar *name1;
 325         const gchar *name2;
 326
 327         if(i1->uid==i2->uid)
 328                 return sort_by_name(item1, item2);
 329
 330         name1=user_name(i1->uid);
 331         name2=user_name(i2->uid);
 332
 333         return strcmp(name1, name2);
 334 }
 335
 336 int sort_by_group(const void *item1, const void *item2)
 337 {
 338         const DirItem *i1 = (DirItem *) item1;
 339         const DirItem *i2 = (DirItem *) item2;
 340         const gchar *name1;
 341         const gchar *name2;
 342
 343         if(i1->gid==i2->gid)
 344                 return sort_by_name(item1, item2);
 345
 346         name1=group_name(i1->gid);
 347         name2=group_name(i2->gid);
 348
 349         return strcmp(name1, name2);
 350 }
 351
 352 int sort_by_date(const void *item1, const void *item2)
 353 {
 354         const DirItem *i1 = (DirItem *) item1;
 355         const DirItem *i2 = (DirItem *) item2;
 356
 357         /* SORT_DIRS; -- too confusing! */
 358
 359         return i1->mtime < i2->mtime ? -1 :
 360                 i1->mtime > i2->mtime ? 1 :
 361                 sort_by_name(item1, item2);
 362 }
 363
 364 int sort_by_size(const void *item1, const void *item2)
 365 {
 366         const DirItem *i1 = (DirItem *) item1;
 367         const DirItem *i2 = (DirItem *) item2;
 368
 369         SORT_DIRS;
 370
 371         return i1->size < i2->size ? -1 :
 372                 i1->size > i2->size ? 1 :
 373                 sort_by_name(item1, item2);
 374 }
 375
 376 void display_set_sort_type(FilerWindow *filer_window, SortType sort_type,
 377                            GtkSortType order)
 378 {
 379         if (filer_window->sort_type == sort_type &&
 380             filer_window->sort_order == order)
 381                 return;
 382
 383         filer_window->sort_type = sort_type;
 384         filer_window->sort_order = order;
 385
 386         view_sort(filer_window->view);
 387 }
 388
 389 /* Change the icon size and style.
 390  * force_resize should only be TRUE for new windows.
 391  */
 392 void display_set_layout(FilerWindow  *filer_window,
 393                         DisplayStyle style,
 394                         DetailsType  details,
 395                         gboolean     force_resize)
 396 {
 397         gboolean style_changed = FALSE;
 398
 399         g_return_if_fail(filer_window != NULL);
 400
 401         if (filer_window->display_style_wanted != style
 402             || filer_window->details_type != details)
 403         {
 404                 style_changed = TRUE;
 405         }
 406
 407         display_style_set(filer_window, style);
 408         display_details_set(filer_window, details);
 409
 410         /* Recreate layouts because wrapping may have changed */
 411         view_style_changed(filer_window->view, VIEW_UPDATE_NAME);
 412
 413         if (force_resize || o_filer_auto_resize.int_value == RESIZE_ALWAYS
 414             || (o_filer_auto_resize.int_value == RESIZE_STYLE && style_changed))
 415         {
 416                 view_autosize(filer_window->view);
 417         }
 418 }
 419
 420 /* Set the 'Show Thumbnails' flag for this window */
 421 void display_set_thumbs(FilerWindow *filer_window, gboolean thumbs)
 422 {
 423         if (filer_window->show_thumbs == thumbs)
 424                 return;
 425
 426         filer_window->show_thumbs = thumbs;
 427
 428         view_style_changed(filer_window->view, VIEW_UPDATE_VIEWDATA);
 429
 430         if (!thumbs)
 431                 filer_cancel_thumbnails(filer_window);
 432
 433         filer_set_title(filer_window);
 434
 435         filer_create_thumbs(filer_window);
 436 }
 437
 438 void display_update_hidden(FilerWindow *filer_window)
 439 {
 440         filer_detach_rescan(filer_window);      /* (updates titlebar) */
 441
 442         display_set_actual_size(filer_window, FALSE);
 443 }
 444
 445 /* Set the 'Show Hidden' flag for this window */
 446 void display_set_hidden(FilerWindow *filer_window, gboolean hidden)
 447 {
 448         if (filer_window->show_hidden == hidden)
 449                 return;
 450
 451         /*
 452         filer_window->show_hidden = hidden;
 453         */
 454         filer_set_hidden(filer_window, hidden);
 455
 456         display_update_hidden(filer_window);
 457 }
 458
 459 void display_set_filter(FilerWindow *filer_window, FilterType type,
 460                         const gchar *filter_string)
 461 {
 462         if (filer_set_filter(filer_window, type, filter_string))
 463                 display_update_hidden(filer_window);
 464 }
 465
 466
 467 /* Highlight (wink or cursor) this item in the filer window. If the item
 468  * isn't already there but we're scanning then highlight it if it
 469  * appears later.
 470  */
 471 void display_set_autoselect(FilerWindow *filer_window, const gchar *leaf)
 472 {
 473         gchar *new;
 474
 475         g_return_if_fail(filer_window != NULL);
 476         g_return_if_fail(leaf != NULL);
 477
 478         new = g_strdup(leaf);   /* leaf == old value sometimes */
 479
 480         null_g_free(&filer_window->auto_select);
 481
 482         if (view_autoselect(filer_window->view, new))
 483                 g_free(new);
 484         else
 485                 filer_window->auto_select = new;
 486 }
 487
 488 /* Change the icon size (wraps) */
 489 void display_change_size(FilerWindow *filer_window, gboolean bigger)
 490 {
 491         DisplayStyle    new;
 492
 493         g_return_if_fail(filer_window != NULL);
 494
 495         switch (filer_window->display_style)
 496         {
 497                 case LARGE_ICONS:
 498                         new = bigger ? HUGE_ICONS : SMALL_ICONS;
 499                         break;
 500                 case HUGE_ICONS:
 501                         if (bigger)
 502                                 return;
 503                         new = LARGE_ICONS;
 504                         break;
 505                 default:
 506                         if (!bigger)
 507                                 return;
 508                         new = LARGE_ICONS;
 509                         break;
 510         }
 511
 512         display_set_layout(filer_window, new, filer_window->details_type,
 513                            FALSE);
 514 }
 515
 516 ViewData *display_create_viewdata(FilerWindow *filer_window, DirItem *item)
 517 {
 518         ViewData *view;
 519
 520         view = g_new(ViewData, 1);
 521
 522         view->layout = NULL;
 523         view->details = NULL;
 524         view->image = NULL;
 525
 526         display_update_view(filer_window, item, view, TRUE);
 527
 528         return view;
 529 }
 530
 531 /* Set the display style to the desired style. If the desired style
 532  * is AUTO_SIZE_ICONS, choose an appropriate size. Also resizes filer
 533  * window, if requested.
 534  */
 535 void display_set_actual_size(FilerWindow *filer_window, gboolean force_resize)
 536 {
 537         display_set_layout(filer_window, filer_window->display_style_wanted,
 538                            filer_window->details_type, force_resize);
 539 }
 540
 541
 542 /****************************************************************
 543  *                      INTERNAL FUNCTIONS                      *
 544  ****************************************************************/
 545
 546 static void options_changed(void)
 547 {
 548         GList           *next;
 549
 550         for (next = all_filer_windows; next; next = next->next)
 551         {
 552                 FilerWindow *filer_window = (FilerWindow *) next->data;
 553                 int flags = 0;
 554
 555                 if (o_display_dirs_first.has_changed ||
 556                     o_display_caps_first.has_changed)
 557                         view_sort(VIEW(filer_window->view));
 558
 559                 if (o_display_show_headers.has_changed)
 560                         flags |= VIEW_UPDATE_HEADERS;
 561
 562                 if (o_large_width.has_changed || o_small_width.has_changed)
 563                         flags |= VIEW_UPDATE_NAME; /* Recreate PangoLayout */
 564
 565                 view_style_changed(filer_window->view, flags);
 566         }
 567 }
 568
 569 /* Return a new string giving details of this item, or NULL if details
 570  * are not being displayed. If details are not yet available, return
 571  * a string of the right length.
 572  */
 573 static char *details(FilerWindow *filer_window, DirItem *item)
 574 {
 575         mode_t  m = item->mode;
 576         guchar  *buf = NULL;
 577         gboolean scanned = item->base_type != TYPE_UNKNOWN;
 578
 579         if (filer_window->details_type == DETAILS_NONE)
 580                 return NULL;
 581
 582         if (scanned && item->lstat_errno)
 583                 buf = g_strdup_printf(_("lstat(2) failed: %s"),
 584                                 g_strerror(item->lstat_errno));
 585         else if (filer_window->details_type == DETAILS_TYPE)
 586         {
 587                 MIME_type       *type = item->mime_type;
 588
 589                 if (!scanned)
 590                         return g_strdup("application/octet-stream");
 591
 592                 buf = g_strdup_printf("%s/%s",
 593                                       type->media_type, type->subtype);
 594         }
 595         else if (filer_window->details_type == DETAILS_TIMES)
 596         {
 597                 guchar  *ctime, *mtime, *atime;
 598
 599                 ctime = pretty_time(&item->ctime);
 600                 mtime = pretty_time(&item->mtime);
 601                 atime = pretty_time(&item->atime);
 602
 603                 buf = g_strdup_printf("a[%s] c[%s] m[%s]", atime, ctime, mtime);
 604                 g_free(ctime);
 605                 g_free(mtime);
 606                 g_free(atime);
 607         }
 608         else if (filer_window->details_type == DETAILS_PERMISSIONS)
 609         {
 610                 if (!scanned)
 611                         return g_strdup("---,---,---/--"
 612 #ifdef S_ISVTX
 613                                         "-"
 614 #endif
 615                                         " 12345678 12345678");
 616
 617                 buf = g_strdup_printf("%s %-8.8s %-8.8s",
 618                                 pretty_permissions(m),
 619                                 user_name(item->uid),
 620                                 group_name(item->gid));
 621         }
 622         else
 623         {
 624                 if (!scanned)
 625                 {
 626                         if (filer_window->display_style == SMALL_ICONS)
 627                                 return g_strdup("1234M");
 628                         else
 629                                 return g_strdup("1234 bytes");
 630                 }
 631
 632                 if (item->base_type != TYPE_DIRECTORY)
 633                 {
 634                         if (filer_window->display_style == SMALL_ICONS)
 635                                 buf = g_strdup(format_size_aligned(item->size));
 636                         else
 637                                 buf = g_strdup(format_size(item->size));
 638                 }
 639                 else
 640                         buf = g_strdup("-");
 641         }
 642
 643         return buf;
 644 }
 645
 646 /* Note: Call style_changed after this */
 647 static void display_details_set(FilerWindow *filer_window, DetailsType details)
 648 {
 649         filer_window->details_type = details;
 650 }
 651
 652 /* Note: Call style_changed after this */
 653 static void display_style_set(FilerWindow *filer_window, DisplayStyle style)
 654 {
 655         filer_window->display_style_wanted = style;
 656         display_set_actual_size_real(filer_window);
 657 }
 658
 659 /* Each displayed item has a ViewData structure with some cached information
 660  * to help quickly draw the item (eg, the PangoLayout). This function updates
 661  * this information.
 662  */
 663 void display_update_view(FilerWindow *filer_window,
 664                          DirItem *item,
 665                          ViewData *view,
 666                          gboolean update_name_layout)
 667 {
 668         DisplayStyle    style = filer_window->display_style;
 669         int     w, h;
 670         int     wrap_width = -1;
 671         char    *str;
 672         static PangoFontDescription *monospace = NULL;
 673         PangoAttrList *list = NULL;
 674
 675         if (!monospace)
 676                 monospace = pango_font_description_from_string("monospace");
 677
 678         if (view->details)
 679         {
 680                 g_object_unref(G_OBJECT(view->details));
 681                 view->details = NULL;
 682         }
 683
 684         str = details(filer_window, item);
 685         if (str)
 686         {
 687                 PangoAttrList   *details_list;
 688                 int     perm_offset = -1;
 689
 690                 view->details = gtk_widget_create_pango_layout(
 691                                         filer_window->window, str);
 692                 g_free(str);
 693
 694                 pango_layout_set_font_description(view->details, monospace);
 695                 pango_layout_get_size(view->details, &w, &h);
 696                 view->details_width = w / PANGO_SCALE;
 697                 view->details_height = h / PANGO_SCALE;
 698
 699                 if (filer_window->details_type == DETAILS_PERMISSIONS)
 700                         perm_offset = 0;
 701                 if (perm_offset > -1)
 702                 {
 703                         PangoAttribute  *attr;
 704
 705                         attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
 706
 707                         perm_offset += 4 * applicable(item->uid, item->gid);
 708                         attr->start_index = perm_offset;
 709                         attr->end_index = perm_offset + 3;
 710
 711                         details_list = pango_attr_list_new();
 712                         pango_attr_list_insert(details_list, attr);
 713                         pango_layout_set_attributes(view->details,
 714                                                         details_list);
 715                 }
 716         }
 717
 718         if (view->image)
 719         {
 720                 g_object_unref(view->image);
 721                 view->image = NULL;
 722         }
 723
 724         if (filer_window->show_thumbs && item->base_type == TYPE_FILE /*&&
 725                                                                         strcmp(item->mime_type->media_type, "image") == 0*/)
 726         {
 727                 const guchar    *path;
 728
 729                 path = make_path(filer_window->real_path, item->leafname);
 730
 731                 view->image = g_fscache_lookup_full(pixmap_cache, path,
 732                                 FSCACHE_LOOKUP_ONLY_NEW, NULL);
 733         }
 734
 735         if (!view->image)
 736         {
 737                 view->image = di_image(item);
 738                 if (view->image)
 739                         g_object_ref(view->image);
 740         }
 741
 742         if (view->layout && update_name_layout)
 743         {
 744                 g_object_unref(G_OBJECT(view->layout));
 745                 view->layout = NULL;
 746         }
 747
 748         if (view->layout)
 749         {
 750                 /* Do nothing */
 751         }
 752         else if (g_utf8_validate(item->leafname, -1, NULL))
 753         {
 754                 view->layout = gtk_widget_create_pango_layout(
 755                                 filer_window->window, item->leafname);
 756         }
 757         else
 758         {
 759                 PangoAttribute  *attr;
 760                 gchar *utf8;
 761
 762                 utf8 = to_utf8(item->leafname);
 763                 view->layout = gtk_widget_create_pango_layout(
 764                                 filer_window->window, utf8);
 765                 g_free(utf8);
 766
 767                 attr = pango_attr_foreground_new(0xffff, 0, 0);
 768                 attr->start_index = 0;
 769                 attr->end_index = -1;
 770                 if (!list)
 771                         list = pango_attr_list_new();
 772                 pango_attr_list_insert(list, attr);
 773         }
 774
 775         if (item->flags & ITEM_FLAG_RECENT)
 776         {
 777                 PangoAttribute  *attr;
 778
 779                 attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
 780                 attr->start_index = 0;
 781                 attr->end_index = -1;
 782                 if (!list)
 783                         list = pango_attr_list_new();
 784                 pango_attr_list_insert(list, attr);
 785         }
 786
 787         if (list)
 788                 pango_layout_set_attributes(view->layout, list);
 789
 790         if (filer_window->details_type == DETAILS_NONE)
 791         {
 792                 if (style == HUGE_ICONS)
 793                         wrap_width = HUGE_WRAP * PANGO_SCALE;
 794                 else if (style == LARGE_ICONS)
 795                         wrap_width = o_large_width.int_value * PANGO_SCALE;
 796         }
 797
 798 #ifdef USE_PANGO_WRAP_WORD_CHAR
 799         pango_layout_set_wrap(view->layout, PANGO_WRAP_WORD_CHAR);
 800 #endif
 801         if (wrap_width != -1)
 802                 pango_layout_set_width(view->layout, wrap_width);
 803
 804         pango_layout_get_size(view->layout, &w, &h);
 805         view->name_width = w / PANGO_SCALE;
 806         view->name_height = h / PANGO_SCALE;
 807 }
 808
 809 /* Sets display_style from display_style_wanted.
 810  * See also display_set_actual_size().
 811  */
 812 static void display_set_actual_size_real(FilerWindow *filer_window)
 813 {
 814         DisplayStyle size = filer_window->display_style_wanted;
 815         int n;
 816
 817         g_return_if_fail(filer_window != NULL);
 818
 819         if (size == AUTO_SIZE_ICONS)
 820         {
 821                 n = view_count_items(filer_window->view);
 822
 823                 if (n >= o_filer_change_size_num.int_value)
 824                         size = SMALL_ICONS;
 825                 else
 826                         size = LARGE_ICONS;
 827         }
 828
 829         filer_window->display_style = size;
 830 }