apps/filetypes.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Jonathan Gordon
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <stdbool.h>
  26 #include "string.h"
  27 #include <ctype.h>
  28
  29 #include "settings.h"
  30 #include "debug.h"
  31 #include "lang.h"
  32 #include "kernel.h"
  33 #include "plugin.h"
  34 #include "filetypes.h"
  35 #include "screens.h"
  36 #include "dir.h"
  37 #include "file.h"
  38 #include "splash.h"
  39 #include "core_alloc.h"
  40 #include "icons.h"
  41 #include "logf.h"
  42
  43 /* max filetypes (plugins & icons stored here) */
  44 #if CONFIG_CODEC == SWCODEC
  45 #define MAX_FILETYPES 192
  46 #else
  47 #define MAX_FILETYPES 128
  48 #endif
  49 /* max viewer plugins */
  50 #ifdef HAVE_LCD_BITMAP
  51 #define MAX_VIEWERS 56
  52 #else
  53 #define MAX_VIEWERS 24
  54 #endif
  55
  56 /* a table for the known file types */
  57 static const struct filetype inbuilt_filetypes[] = {
  58     { "mp3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  59     { "mp2", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  60     { "mpa", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  61 #if CONFIG_CODEC == SWCODEC
  62     /* Temporary hack to allow playlist creation */
  63     { "mp1", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  64     { "ogg", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  65     { "oga", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  66     { "wma", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  67     { "wmv", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  68     { "asf", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  69     { "wav", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  70     { "flac",FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  71     { "ac3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  72     { "a52", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  73     { "mpc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  74     { "wv",  FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  75     { "m4a", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  76     { "m4b", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  77     { "mp4", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  78     { "mod", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  79     { "shn", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  80     { "aif", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  81     { "aiff",FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  82     { "spx" ,FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  83     { "opus",FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  84     { "sid", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  85     { "adx", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  86     { "nsf", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  87     { "nsfe",FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  88     { "spc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  89     { "ape", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  90     { "mac", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  91     { "sap" ,FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  92     { "rm",  FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  93     { "ra",  FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  94     { "rmvb",FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  95     { "cmc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  96     { "cm3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  97     { "cmr", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  98     { "cms", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  99     { "dmc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 100     { "dlt", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 101     { "mpt", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 102     { "mpd", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 103     { "rmt", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 104     { "tmc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 105     { "tm8", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 106     { "tm2", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 107     { "oma", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 108     { "aa3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 109     { "at3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 110     { "mmf", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 111     { "au",  FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 112     { "snd", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 113     { "vox", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 114     { "w64", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 115     { "tta", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 116     { "ay", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 117     { "gbs", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 118     { "hes", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 119     { "sgc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 120     { "vgm", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 121     { "vgz", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 122     { "kss", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 123 #endif
 124     { "m3u", FILE_ATTR_M3U, Icon_Playlist, LANG_PLAYLIST },
 125     { "m3u8",FILE_ATTR_M3U, Icon_Playlist, LANG_PLAYLIST },
 126     { "cfg", FILE_ATTR_CFG, Icon_Config,   VOICE_EXT_CFG },
 127     { "wps", FILE_ATTR_WPS, Icon_Wps,      VOICE_EXT_WPS },
 128 #ifdef HAVE_REMOTE_LCD
 129     { "rwps",FILE_ATTR_RWPS, Icon_Wps,     VOICE_EXT_RWPS },
 130 #endif
 131 #if CONFIG_TUNER
 132     { "fmr", FILE_ATTR_FMR, Icon_Preset, LANG_FMR },
 133     { "fms", FILE_ATTR_FMS, Icon_Wps, VOICE_EXT_FMS },
 134 #endif
 135     { "lng", FILE_ATTR_LNG, Icon_Language, LANG_LANGUAGE },
 136     { "rock",FILE_ATTR_ROCK,Icon_Plugin,   VOICE_EXT_ROCK },
 137     { "lua", FILE_ATTR_LUA, Icon_Plugin,   VOICE_EXT_ROCK },
 138 #ifdef HAVE_LCD_BITMAP
 139     { "fnt", FILE_ATTR_FONT,Icon_Font,     VOICE_EXT_FONT },
 140     { "kbd", FILE_ATTR_KBD, Icon_Keyboard, VOICE_EXT_KBD },
 141 #endif
 142     { "bmark",FILE_ATTR_BMARK, Icon_Bookmark,  VOICE_EXT_BMARK },
 143     { "cue",  FILE_ATTR_CUE,   Icon_Bookmark,  VOICE_EXT_CUESHEET },
 144 #ifdef HAVE_LCD_BITMAP
 145     { "sbs",  FILE_ATTR_SBS,  Icon_Wps,   VOICE_EXT_SBS },
 146 #endif
 147 #ifdef HAVE_REMOTE_LCD
 148     { "rsbs", FILE_ATTR_RSBS, Icon_Wps,   VOICE_EXT_RSBS },
 149 #if CONFIG_TUNER
 150     { "rfms", FILE_ATTR_RFMS, Icon_Wps, VOICE_EXT_RFMS },
 151 #endif
 152 #endif
 153 #ifdef BOOTFILE_EXT
 154     { BOOTFILE_EXT, FILE_ATTR_MOD, Icon_Firmware, VOICE_EXT_AJZ },
 155 #endif
 156 #ifdef BOOTFILE_EXT2
 157     { BOOTFILE_EXT2, FILE_ATTR_MOD, Icon_Firmware, VOICE_EXT_AJZ },
 158 #endif
 159 };
 160
 161 void tree_get_filetypes(const struct filetype** types, int* count)
 162 {
 163     *types = inbuilt_filetypes;
 164     *count = sizeof(inbuilt_filetypes) / sizeof(*inbuilt_filetypes);
 165 }
 166
 167 #define ROCK_EXTENSION "rock"
 168
 169 struct file_type {
 170     enum themable_icons icon; /* the icon which shall be used for it, NOICON if unknown */
 171     unsigned char  attr; /* FILE_ATTR_MASK >> 8 */
 172     char* plugin; /* Which plugin to use, NULL if unknown, or builtin */
 173     char* extension; /* NULL for none */
 174 };
 175 static struct file_type filetypes[MAX_FILETYPES];
 176 static int custom_filetype_icons[MAX_FILETYPES];
 177 static bool custom_icons_loaded = false;
 178 #ifdef HAVE_LCD_COLOR
 179 static int custom_colors[MAX_FILETYPES];
 180 #endif
 181 struct filetype_unknown {
 182     int icon;
 183 #ifdef HAVE_LCD_COLOR
 184     int color;
 185 #endif
 186 };
 187 static struct filetype_unknown unknown_file = {
 188     .icon = Icon_NOICON,
 189 #ifdef HAVE_LCD_COLOR
 190     .color = -1,
 191 #endif
 192 };
 193
 194 /* index array to filetypes used in open with list. */
 195 static int viewers[MAX_VIEWERS];
 196 static int filetype_count = 0;
 197 static unsigned char highest_attr = 0;
 198 static int viewer_count = 0;
 199
 200 static int strdup_handle, strdup_bufsize, strdup_cur_idx;
 201 static int move_callback(int handle, void* current, void* new)
 202 {
 203     /*could compare to strdup_handle, but ops is only used once */
 204     (void)handle;
 205     size_t diff = new - current;
 206 #define FIX_PTR(x) \
 207     { if ((void*)x >= current && (void*)x < (current+strdup_bufsize)) x+= diff; }
 208     for(int i = 0; i < filetype_count; i++)
 209     {
 210         FIX_PTR(filetypes[i].extension);
 211         FIX_PTR(filetypes[i].plugin);
 212     }
 213     return BUFLIB_CB_OK;
 214 }
 215
 216 static struct buflib_callbacks ops = {
 217     .move_callback = move_callback,
 218     .shrink_callback = NULL,
 219 };
 220
 221 static char *filetypes_strdup(char* string)
 222 {
 223     char *buffer = core_get_data(strdup_handle) + strdup_cur_idx;
 224     strdup_cur_idx += strlcpy(buffer, string, strdup_bufsize-strdup_cur_idx)+1;
 225     return buffer;
 226 }
 227
 228 static char *filetypes_store_plugin(char *plugin, int n)
 229 {
 230     int i;
 231     /* if the plugin is in the list already, use it. */
 232     for (i=0; i<viewer_count; i++)
 233     {
 234         if (!strcmp(filetypes[viewers[i]].plugin, plugin))
 235             return filetypes[viewers[i]].plugin;
 236     }
 237     /* otherwise, allocate buffer */
 238     if (viewer_count < MAX_VIEWERS)
 239         viewers[viewer_count++] = n;
 240     return filetypes_strdup(plugin);
 241 }
 242
 243 static int find_extension(const char* extension)
 244 {
 245     int i;
 246     if (!extension)
 247         return -1;
 248     for (i=1; i<filetype_count; i++)
 249     {
 250         if (filetypes[i].extension &&
 251             !strcasecmp(extension, filetypes[i].extension))
 252             return i;
 253     }
 254     return -1;
 255 }
 256
 257 static void read_builtin_types(void);
 258 static void read_config(int fd);
 259 #ifdef HAVE_LCD_COLOR
 260 /* Colors file format is similar to icons:
 261  * ext:hex_color
 262  * load a colors file from a theme with:
 263  * filetype colours: filename.colours */
 264 void read_color_theme_file(void) {
 265     char buffer[MAX_PATH];
 266     int fd;
 267     char *ext, *color;
 268     int i;
 269     for (i = 0; i < MAX_FILETYPES; i++) {
 270         custom_colors[i] = -1;
 271     }
 272     snprintf(buffer, MAX_PATH, THEME_DIR "/%s.colours",
 273              global_settings.colors_file);
 274     fd = open(buffer, O_RDONLY);
 275     if (fd < 0)
 276         return;
 277     while (read_line(fd, buffer, MAX_PATH) > 0)
 278     {
 279         if (!settings_parseline(buffer, &ext, &color))
 280             continue;
 281         if (!strcasecmp(ext, "folder"))
 282         {
 283             hex_to_rgb(color, &custom_colors[0]);
 284             continue;
 285         }
 286         if (!strcasecmp(ext, "???"))
 287         {
 288             hex_to_rgb(color, &unknown_file.color);
 289             continue;
 290         }
 291         i = find_extension(ext);
 292         if (i >= 0)
 293             hex_to_rgb(color, &custom_colors[i]);
 294     }
 295     close(fd);
 296 }
 297 #endif
 298 #ifdef HAVE_LCD_BITMAP
 299 void read_viewer_theme_file(void)
 300 {
 301     char buffer[MAX_PATH];
 302     int fd;
 303     char *ext, *icon;
 304     int i;
 305     int *icon_dest;
 306     global_status.viewer_icon_count = 0;
 307     custom_icons_loaded = false;
 308     custom_filetype_icons[0] = Icon_Folder;
 309     for (i=1; i<filetype_count; i++)
 310     {
 311         custom_filetype_icons[i] = filetypes[i].icon;
 312     }
 313
 314     snprintf(buffer, MAX_PATH, "%s/%s.icons", ICON_DIR,
 315              global_settings.viewers_icon_file);
 316     fd = open(buffer, O_RDONLY);
 317     if (fd < 0)
 318         return;
 319     while (read_line(fd, buffer, MAX_PATH) > 0)
 320     {
 321         if (!settings_parseline(buffer, &ext, &icon))
 322             continue;
 323         i = find_extension(ext);
 324         if (i >= 0)
 325             icon_dest = &custom_filetype_icons[i];
 326         else if (!strcmp(ext, "???"))
 327             icon_dest = &unknown_file.icon;
 328         else
 329             icon_dest = NULL;
 330
 331         if (icon_dest)
 332         {
 333             if (*icon == '*')
 334                 *icon_dest = atoi(icon+1);
 335             else if (*icon == '-')
 336                 *icon_dest = Icon_NOICON;
 337             else if (*icon >= '0' && *icon <= '9')
 338             {
 339                 int number = atoi(icon);
 340                 if (number > global_status.viewer_icon_count)
 341                     global_status.viewer_icon_count++;
 342                 *icon_dest = Icon_Last_Themeable + number;
 343             }
 344         }
 345     }
 346     close(fd);
 347     custom_icons_loaded = true;
 348 }
 349 #endif
 350
 351 void  filetype_init(void)
 352 {
 353     /* set the directory item first */
 354     filetypes[0].extension = NULL;
 355     filetypes[0].plugin = NULL;
 356     filetypes[0].attr   = 0;
 357     filetypes[0].icon   = Icon_Folder;
 358
 359     /* estimate bufsize with the filesize, will not be larger */
 360     viewer_count = 0;
 361     filetype_count = 1;
 362
 363     int fd = open(VIEWERS_CONFIG, O_RDONLY);
 364     if (fd < 0)
 365         return;
 366
 367     strdup_bufsize = filesize(fd);
 368     strdup_handle = core_alloc_ex("filetypes", strdup_bufsize, &ops);
 369     if (strdup_handle <= 0)
 370     {
 371         close(fd);
 372         return;
 373     }
 374     read_builtin_types();
 375     read_config(fd);
 376     close(fd);
 377 #ifdef HAVE_LCD_BITMAP
 378     read_viewer_theme_file();
 379 #endif
 380 #ifdef HAVE_LCD_COLOR
 381     read_color_theme_file();
 382 #endif
 383     core_shrink(strdup_handle, core_get_data(strdup_handle), strdup_cur_idx);
 384 }
 385
 386 /* remove all white spaces from string */
 387 static void rm_whitespaces(char* str)
 388 {
 389     char *s = str;
 390     while (*str)
 391     {
 392         if (!isspace(*str))
 393         {
 394             *s = *str;
 395             s++;
 396         }
 397         str++;
 398     }
 399     *s = '\0';
 400 }
 401
 402 static void read_builtin_types(void)
 403 {
 404     int count = sizeof(inbuilt_filetypes)/sizeof(*inbuilt_filetypes), i;
 405     for(i=0; i<count && (filetype_count < MAX_FILETYPES); i++)
 406     {
 407         filetypes[filetype_count].extension = inbuilt_filetypes[i].extension;
 408         filetypes[filetype_count].plugin = NULL;
 409         filetypes[filetype_count].attr   = inbuilt_filetypes[i].tree_attr>>8;
 410         if (filetypes[filetype_count].attr > highest_attr)
 411             highest_attr = filetypes[filetype_count].attr;
 412         filetypes[filetype_count].icon   = inbuilt_filetypes[i].icon;
 413         filetype_count++;
 414     }
 415 }
 416
 417 static void read_config(int fd)
 418 {
 419     char line[64], *s, *e;
 420     char *extension, *plugin;
 421     /* config file is in the format
 422        <extension>,<plugin>,<icon code>
 423        ignore line if either of the first two are missing */
 424     while (read_line(fd, line, sizeof line) > 0)
 425     {
 426         if (filetype_count >= MAX_FILETYPES)
 427         {
 428             splash(HZ, ID2P(LANG_FILETYPES_FULL));
 429             break;
 430         }
 431         rm_whitespaces(line);
 432         /* get the extension */
 433         s = line;
 434         e = strchr(s, ',');
 435         if (!e)
 436             continue;
 437         *e = '\0';
 438         extension = s;
 439
 440         /* get the plugin */
 441         s = e+1;
 442         e = strchr(s, ',');
 443         if (!e)
 444             continue;
 445         *e = '\0';
 446         plugin = s;
 447
 448         if (!strcmp("???", extension))
 449         {
 450             /* get the icon */
 451             s = e+1;
 452             if (*s == '*')
 453                 unknown_file.icon = atoi(s+1);
 454             else if (*s == '-')
 455                 unknown_file.icon = Icon_NOICON;
 456             else if (*s >= '0' && *s <= '9')
 457                 unknown_file.icon = Icon_Last_Themeable + atoi(s);
 458             continue;
 459         }
 460
 461         /* ok, store this plugin/extension, check icon after */
 462         struct file_type *file_type = &filetypes[filetype_count];
 463         file_type->extension = filetypes_strdup(extension);
 464         file_type->plugin = filetypes_store_plugin(plugin, filetype_count);
 465         file_type->attr = highest_attr +1;
 466         file_type->icon = Icon_Questionmark;
 467         highest_attr++;
 468         /* get the icon */
 469         s = e+1;
 470         if (*s == '*')
 471             file_type->icon = atoi(s+1);
 472         else if (*s == '-')
 473             file_type->icon = Icon_NOICON;
 474         else if (*s >= '0' && *s <= '9')
 475             file_type->icon = Icon_Last_Themeable + atoi(s);
 476         filetype_count++;
 477     }
 478 }
 479
 480 int filetype_get_attr(const char* file)
 481 {
 482     char *extension = strrchr(file, '.');
 483     int i;
 484     if (!extension)
 485         return 0;
 486     extension++;
 487
 488     i = find_extension(extension);
 489     if (i >= 0)
 490         return (filetypes[i].attr<<8)&FILE_ATTR_MASK;
 491     return 0;
 492 }
 493
 494 static int find_attr(int attr)
 495 {
 496     int i;
 497     /* skip the directory item */
 498     if ((attr & ATTR_DIRECTORY)==ATTR_DIRECTORY)
 499         return 0;
 500     for (i=1; i<filetype_count; i++)
 501     {
 502         if ((attr>>8) == filetypes[i].attr)
 503             return i;
 504     }
 505     return -1;
 506 }
 507
 508 #ifdef HAVE_LCD_COLOR
 509 int filetype_get_color(const char * name, int attr)
 510 {
 511     char *extension;
 512     int i;
 513     if ((attr & ATTR_DIRECTORY)==ATTR_DIRECTORY)
 514         return custom_colors[0];
 515     extension = strrchr(name, '.');
 516     if (!extension)
 517         return custom_colors[unknown_file.color];
 518     extension++;
 519
 520     i = find_extension(extension);
 521     if (i >= 0)
 522         return custom_colors[i];
 523     return unknown_file.color;
 524 }
 525 #endif
 526
 527 int filetype_get_icon(int attr)
 528 {
 529     int index = find_attr(attr);
 530     if (index < 0)
 531         return unknown_file.icon;
 532     if (custom_icons_loaded)
 533         return custom_filetype_icons[index];
 534     return filetypes[index].icon;
 535 }
 536
 537 char* filetype_get_plugin(const struct entry* file)
 538 {
 539     static char plugin_name[MAX_PATH];
 540     int index = find_attr(file->attr);
 541     if (index < 0)
 542         return NULL;
 543     if (filetypes[index].plugin == NULL)
 544         return NULL;
 545     snprintf(plugin_name, MAX_PATH, "%s/%s.%s",
 546              PLUGIN_DIR, filetypes[index].plugin, ROCK_EXTENSION);
 547     return plugin_name;
 548 }
 549
 550 bool filetype_supported(int attr)
 551 {
 552     return find_attr(attr) >= 0;
 553 }
 554
 555 /**** Open With Screen ****/
 556 struct cb_data {
 557     const char *current_file;
 558 };
 559
 560 static enum themable_icons openwith_get_icon(int selected_item, void * data)
 561 {
 562     (void)data;
 563     return filetypes[viewers[selected_item]].icon;
 564 }
 565
 566 static const char* openwith_get_name(int selected_item, void * data,
 567                                      char * buffer, size_t buffer_len)
 568 {
 569     (void)data; (void)buffer; (void)buffer_len;
 570     const char *s = strrchr(filetypes[viewers[selected_item]].plugin, '/');
 571     if (s)
 572         return s+1;
 573     else return filetypes[viewers[selected_item]].plugin;
 574 }
 575
 576 static int openwith_action_callback(int action, struct gui_synclist *lists)
 577 {
 578     struct cb_data *info = (struct cb_data *)lists->data;
 579     int i;
 580     if (action == ACTION_STD_OK)
 581     {
 582         char plugin[MAX_PATH];
 583         i = viewers[gui_synclist_get_sel_pos(lists)];
 584         snprintf(plugin, MAX_PATH, "%s/%s.%s",
 585                     PLUGIN_DIR, filetypes[i].plugin, ROCK_EXTENSION);
 586         plugin_load(plugin, info->current_file);
 587         return ACTION_STD_CANCEL;
 588     }
 589     return action;
 590 }
 591
 592 int filetype_list_viewers(const char* current_file)
 593 {
 594     struct simplelist_info info;
 595     struct cb_data data = { current_file };
 596 #ifndef HAVE_LCD_BITMAP
 597     if (viewer_count == 0)
 598     {
 599         /* FIX: translation! */
 600         splash(HZ*2, "No viewers found");
 601         return PLUGIN_OK;
 602     }
 603 #endif
 604     simplelist_info_init(&info, str(LANG_ONPLAY_OPEN_WITH), viewer_count, &data);
 605     info.action_callback = openwith_action_callback;
 606     info.get_name = openwith_get_name;
 607     info.get_icon = global_settings.show_icons?openwith_get_icon:NULL;
 608     return simplelist_show_list(&info);
 609 }
 610
 611 int filetype_load_plugin(const char* plugin, const char* file)
 612 {
 613     int i;
 614     char plugin_name[MAX_PATH];
 615     char *s;
 616
 617     for (i=0;i<filetype_count;i++)
 618     {
 619         if (filetypes[i].plugin)
 620         {
 621             s = strrchr(filetypes[i].plugin, '/');
 622             if (s)
 623             {
 624                 if (!strcmp(s+1, plugin))
 625                     break;
 626             }
 627             else if (!strcmp(filetypes[i].plugin, plugin))
 628                 break;
 629         }
 630     }
 631     if (i >= filetype_count)
 632         return PLUGIN_ERROR;
 633     snprintf(plugin_name, MAX_PATH, "%s/%s.%s",
 634              PLUGIN_DIR, filetypes[i].plugin, ROCK_EXTENSION);
 635     return plugin_load(plugin_name, file);
 636 }