minimenu/mmui.c

   1
   2 #include <stdio.h> /* for FILE etc */
   3 #include <stdlib.h> /* for malloc */
   4 #include <unistd.h> /* for unlink */
   5 #include <limits.h> /* for PATH_MAX */
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #define __USE_GNU /* for strcasestr */
   9 #include <string.h> /* for making ftw.h happy */
  10 #include <time.h>
  11 #include <ftw.h>
  12 #include <ctype.h>
  13
  14 #include "SDL.h"
  15 #include "SDL_audio.h"
  16 #include "SDL_image.h"
  17 #include "SDL_ttf.h"
  18 #include "SDL_gfxPrimitives.h"
  19 #include "SDL_rotozoom.h"
  20 #include "SDL_thread.h"
  21 #include <dirent.h>
  22
  23 #include "pnd_conf.h"
  24 #include "pnd_logger.h"
  25 #include "pnd_pxml.h"
  26 #include "pnd_container.h"
  27 #include "pnd_discovery.h"
  28 #include "pnd_apps.h"
  29 #include "pnd_device.h"
  30 #include "../lib/pnd_pathiter.h"
  31 #include "pnd_utility.h"
  32 #include "pnd_pndfiles.h"
  33 #include "pnd_notify.h"
  34 #include "pnd_dbusnotify.h"
  35
  36 #include "mmenu.h"
  37 #include "mmcat.h"
  38 #include "mmcache.h"
  39 #include "mmui.h"
  40 #include "mmwrapcmd.h"
  41 #include "mmconf.h"
  42 #include "mmui_context.h"
  43 #include "freedesktop_cats.h"
  44 #include "mmcustom_cats.h"
  45
  46 #define CHANGED_NOTHING     (0)
  47 #define CHANGED_CATEGORY    (1<<0)  /* changed to different category */
  48 #define CHANGED_SELECTION   (1<<1)  /* changed app selection */
  49 #define CHANGED_DATAUPDATE  (1<<2)  /* deferred preview pic or icon came in */
  50 #define CHANGED_APPRELOAD   (1<<3)  /* new set of applications entirely */
  51 #define CHANGED_EVERYTHING  (1<<4)  /* redraw it all! */
  52 unsigned int render_mask = CHANGED_EVERYTHING;
  53
  54 SDL_Thread *g_icon_thread = NULL;
  55 unsigned char g_icon_thread_stop = 0; /* if !0 means thread should stop and maim app may block until it goes back to 0.. */
  56 unsigned char g_icon_thread_busy = 0; /* if !0 means thread is running right now */
  57
  58 #define MIMETYPE_EXE "/usr/bin/file"     /* check for file type prior to invocation */
  59
  60 /* SDL
  61  */
  62 SDL_Surface *sdl_realscreen = NULL;
  63 unsigned int sdl_ticks = 0;
  64 SDL_Thread *g_preview_thread = NULL;
  65 SDL_Thread *g_timer_thread = NULL;
  66
  67 enum { sdl_user_ticker = 0,
  68        sdl_user_finishedpreview = 1,
  69        sdl_user_finishedicon = 2,
  70        sdl_user_checksd = 3,
  71 };
  72
  73 /* app state
  74  */
  75 unsigned short int g_scale = 1; // 1 == noscale
  76
  77 SDL_Surface *g_imgcache [ IMG_MAX ];
  78
  79 TTF_Font *g_big_font = NULL;
  80 TTF_Font *g_grid_font = NULL;
  81 TTF_Font *g_detailtext_font = NULL;
  82 TTF_Font *g_tab_font = NULL;
  83
  84 extern pnd_conf_handle g_conf;
  85
  86 /* current display state
  87  */
  88 int ui_rows_scrolled_down = 0;          // number of rows that should be missing from top of the display
  89 mm_appref_t *ui_selected = NULL;
  90 unsigned char ui_category = 0;          // current category
  91 unsigned char ui_catshift = 0;          // how many cats are offscreen to the left
  92 ui_context_t ui_display_context;        // display paramaters: see mmui_context.h
  93 unsigned char ui_detail_hidden = 0;     // if >0, detail panel is hidden
  94 // FUTURE: If multiple panels can be shown/hidden, convert ui_detail_hidden to a bitmask
  95
  96 static SDL_Surface *ui_scale_image ( SDL_Surface *s, unsigned int maxwidth, int maxheight ); // height -1 means ignore
  97 static int ui_selected_index ( void );
  98 static void ui_start_defered_icon_thread ( void );
  99 static void ui_stop_defered_icon_thread ( void );
 100
 101 unsigned char ui_setup ( void ) {
 102
 103   /* set up SDL
 104    */
 105
 106   SDL_Init ( SDL_INIT_EVERYTHING | SDL_INIT_NOPARACHUTE );
 107
 108   SDL_JoystickOpen ( 0 ); // turn on joy-0
 109
 110   SDL_WM_SetCaption ( "mmenu", "mmenu" );
 111
 112   // hide the mouse cursor if we can
 113   if ( SDL_ShowCursor ( -1 ) == 1 ) {
 114     SDL_ShowCursor ( 0 );
 115   }
 116
 117   atexit ( SDL_Quit );
 118
 119   // open up a surface
 120   unsigned int svm = SDL_SWSURFACE /*| SDL_FULLSCREEN*/ /* 0*/;
 121   if ( pnd_conf_get_as_int_d ( g_conf, "display.fullscreen", 0 ) > 0 ) {
 122     svm |= SDL_FULLSCREEN;
 123   }
 124
 125   sdl_realscreen =
 126     SDL_SetVideoMode ( 800 * g_scale, 480 * g_scale, 16 /*bpp*/, svm );
 127
 128   if ( ! sdl_realscreen ) {
 129     pnd_log ( pndn_error, "ERROR: Couldn't open SDL real screen; dieing." );
 130     return ( 0 );
 131   }
 132
 133   pnd_log ( pndn_debug, "Pixel format:" );
 134   pnd_log ( pndn_debug, "bpp b: %u\n", sdl_realscreen -> format -> BitsPerPixel );
 135   pnd_log ( pndn_debug, "bpp B: %u\n", sdl_realscreen -> format -> BytesPerPixel );
 136   pnd_log ( pndn_debug, "R mask: %08x\n", sdl_realscreen -> format -> Rmask );
 137   pnd_log ( pndn_debug, "G mask: %08x\n", sdl_realscreen -> format -> Gmask );
 138   pnd_log ( pndn_debug, "B mask: %08x\n", sdl_realscreen -> format -> Bmask );
 139
 140 #if 0 // audio
 141   {
 142     SDL_AudioSpec fmt;
 143
 144     /* Set 16-bit stereo audio at 22Khz */
 145     fmt.freq = 44100; //22050;
 146     fmt.format = AUDIO_S16; //AUDIO_S16;
 147     fmt.channels = 1;
 148     fmt.samples = 2048;        /* A good value for games */
 149     fmt.callback = mixaudio;
 150     fmt.userdata = NULL;
 151
 152     /* Open the audio device and start playing sound! */
 153     if ( SDL_OpenAudio ( &fmt, NULL ) < 0 ) {
 154       zotlog ( "Unable to open audio: %s\n", SDL_GetError() );
 155       exit ( 1 );
 156     }
 157
 158     SDL_PauseAudio ( 0 );
 159   }
 160 #endif
 161
 162   // key repeat
 163   SDL_EnableKeyRepeat ( 500, 125 /* 150 */ );
 164
 165   // images
 166   //IMG_Init ( IMG_INIT_JPG | IMG_INIT_PNG );
 167
 168   /* fonts
 169    */
 170
 171   // init
 172   if ( TTF_Init() == -1 ) {
 173     pnd_log ( pndn_error, "ERROR: Couldn't set up SDL TTF lib\n" );
 174     return ( 0 ); // couldn't set up SDL TTF
 175   }
 176
 177   char fullpath [ PATH_MAX ];
 178   // big font
 179   sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "minimenu.font" ) );
 180   g_big_font = TTF_OpenFont ( fullpath, pnd_conf_get_as_int_d ( g_conf, "minimenu.font_ptsize", 24 ) );
 181   if ( ! g_big_font ) {
 182     pnd_log ( pndn_error, "ERROR: Couldn't load font '%s' for size %u\n",
 183               pnd_conf_get_as_char ( g_conf, "minimenu.font" ), pnd_conf_get_as_int_d ( g_conf, "minimenu.font_ptsize", 24 ) );
 184     return ( 0 ); // couldn't set up SDL TTF
 185   }
 186
 187   // grid font
 188   sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "grid.font" ) );
 189   g_grid_font = TTF_OpenFont ( fullpath, pnd_conf_get_as_int_d ( g_conf, "grid.font_ptsize", 10 ) );
 190   if ( ! g_grid_font ) {
 191     pnd_log ( pndn_error, "ERROR: Couldn't load font '%s' for size %u\n",
 192               pnd_conf_get_as_char ( g_conf, "grid.font" ), pnd_conf_get_as_int_d ( g_conf, "grid.font_ptsize", 10 ) );
 193     return ( 0 ); // couldn't set up SDL TTF
 194   }
 195
 196   // detailtext font
 197   sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "detailtext.font" ) );
 198   g_detailtext_font = TTF_OpenFont ( fullpath, pnd_conf_get_as_int_d ( g_conf, "detailtext.font_ptsize", 10 ) );
 199   if ( ! g_detailtext_font ) {
 200     pnd_log ( pndn_error, "ERROR: Couldn't load font '%s' for size %u\n",
 201               pnd_conf_get_as_char ( g_conf, "detailtext.font" ), pnd_conf_get_as_int_d ( g_conf, "detailtext.font_ptsize", 10 ) );
 202     return ( 0 ); // couldn't set up SDL TTF
 203   }
 204
 205   // tab font
 206   sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "tabs.font" ) );
 207   g_tab_font = TTF_OpenFont ( fullpath, pnd_conf_get_as_int_d ( g_conf, "tabs.font_ptsize", 10 ) );
 208   if ( ! g_tab_font ) {
 209     pnd_log ( pndn_error, "ERROR: Couldn't load font '%s' for size %u\n",
 210               pnd_conf_get_as_char ( g_conf, "tabs.font" ), pnd_conf_get_as_int_d ( g_conf, "tabs.font_ptsize", 10 ) );
 211     return ( 0 ); // couldn't set up SDL TTF
 212   }
 213
 214   // determine display context
 215   if ( pnd_conf_get_as_int_d ( g_conf, "display.show_detail_pane", 1 ) > 0 ) {
 216     ui_detail_hidden = 0;
 217   } else {
 218     ui_detail_hidden = 1;
 219   }
 220   ui_recache_context ( &ui_display_context );
 221
 222   return ( 1 );
 223 }
 224
 225 mm_imgcache_t g_imagecache [ IMG_TRUEMAX ] = {
 226   { IMG_BACKGROUND_800480,    "graphics.IMG_BACKGROUND_800480" },
 227   { IMG_BACKGROUND_TABMASK,   "graphics.IMG_BACKGROUND_TABMASK" },
 228   { IMG_DETAIL_PANEL,         "graphics.IMG_DETAIL_PANEL" },
 229   { IMG_DETAIL_BG,            "graphics.IMG_DETAIL_BG" },
 230   { IMG_SELECTED_ALPHAMASK,   "graphics.IMG_SELECTED_ALPHAMASK" },
 231   { IMG_TAB_SEL,              "graphics.IMG_TAB_SEL" },
 232   { IMG_TAB_SEL_L,            "graphics.IMG_TAB_SEL_L" },
 233   { IMG_TAB_SEL_R,            "graphics.IMG_TAB_SEL_R" },
 234   { IMG_TAB_UNSEL,            "graphics.IMG_TAB_UNSEL" },
 235   { IMG_TAB_UNSEL_L,          "graphics.IMG_TAB_UNSEL_L" },
 236   { IMG_TAB_UNSEL_R,          "graphics.IMG_TAB_UNSEL_R" },
 237   { IMG_TAB_LINE,             "graphics.IMG_TAB_LINE" },
 238   { IMG_TAB_LINEL,            "graphics.IMG_TAB_LINEL" },
 239   { IMG_TAB_LINER,            "graphics.IMG_TAB_LINER" },
 240   { IMG_ICON_MISSING,         "graphics.IMG_ICON_MISSING" },
 241   { IMG_SELECTED_HILITE,      "graphics.IMG_SELECTED_HILITE" },
 242   { IMG_PREVIEW_MISSING,      "graphics.IMG_PREVIEW_MISSING" },
 243   { IMG_ARROW_UP,             "graphics.IMG_ARROW_UP", },
 244   { IMG_ARROW_DOWN,           "graphics.IMG_ARROW_DOWN", },
 245   { IMG_ARROW_SCROLLBAR,      "graphics.IMG_ARROW_SCROLLBAR", },
 246   { IMG_HOURGLASS,            "graphics.IMG_HOURGLASS", },
 247   { IMG_FOLDER,               "graphics.IMG_FOLDER", },
 248   { IMG_EXECBIN,              "graphics.IMG_EXECBIN", },
 249   { IMG_SUBCATFOLDER,         "graphics.IMG_SUBCATFOLDER", "graphics.IMG_FOLDER", },
 250   { IMG_DOTDOTFOLDER,         "graphics.IMG_DOTDOTFOLDER", "graphics.IMG_FOLDER", },
 251   { IMG_MAX,                  NULL },
 252 };
 253
 254 unsigned char ui_imagecache ( char *basepath ) {
 255   unsigned int i;
 256   char fullpath [ PATH_MAX ];
 257   unsigned char try;
 258
 259   // loaded
 260
 261   for ( i = 0; i < IMG_MAX; i++ ) {
 262
 263     if ( g_imagecache [ i ].id != i ) {
 264       pnd_log ( pndn_error, "ERROR: Internal table mismatch during caching [%u]\n", i );
 265       exit ( -1 );
 266     }
 267
 268     for ( try = 0; try < 2; try++ ) {
 269
 270       char *filename;
 271
 272       if ( try == 0 ) {
 273         filename = pnd_conf_get_as_char ( g_conf, g_imagecache [ i ].confname );
 274       } else {
 275         if ( g_imagecache [ i ].alt_confname ) {
 276           filename = pnd_conf_get_as_char ( g_conf, g_imagecache [ i ].alt_confname );
 277         } else {
 278           return ( 0 );
 279         }
 280       }
 281
 282       if ( ! filename ) {
 283         pnd_log ( pndn_error, "ERROR: (Try %u) Missing filename in conf for key: %s\n", try + 1, g_imagecache [ i ].confname );
 284         if ( try == 0 ) { continue; } else { return ( 0 ); }
 285       }
 286
 287       if ( filename [ 0 ] == '/' ) {
 288         strncpy ( fullpath, filename, PATH_MAX );
 289       } else {
 290         sprintf ( fullpath, "%s/%s", basepath, filename );
 291       }
 292
 293       if ( ( g_imagecache [ i ].i = IMG_Load ( fullpath ) ) ) {
 294         break; // no retry needed
 295       } else {
 296         pnd_log ( pndn_error, "ERROR: (Try %u) Couldn't load static cache image: %s\n", try + 1, fullpath );
 297         if ( try == 0 ) { continue; } else { return ( 0 ); }
 298       }
 299
 300     } // try twice
 301
 302   } // for
 303
 304   // generated
 305   //g_imagecache [ IMG_SELECTED_ALPHAMASK ].i = SDL_CreateRGBSurface ( SDL_SWSURFACE, 60, 60, 32, 0xFF0000, 0x00FF00, 0xFF, 0xFF000000 );
 306   //boxRGBA ( g_imagecache [ IMG_SELECTED_ALPHAMASK ].i, 0, 0, 60, 60, 100, 100, 100, 250 );
 307
 308   // post processing
 309   //
 310
 311   // scale icons
 312   g_imagecache [ IMG_ICON_MISSING ].i = ui_scale_image ( g_imagecache [ IMG_ICON_MISSING ].i, pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_width", 50 ), -1 );
 313   // scale text hilight
 314   g_imagecache [ IMG_SELECTED_HILITE ].i = ui_scale_image ( g_imagecache [ IMG_SELECTED_HILITE ].i, pnd_conf_get_as_int_d ( g_conf, "grid.text_width", 50 ), -1 );
 315   // scale preview no-pic
 316   g_imagecache [ IMG_PREVIEW_MISSING ].i = ui_scale_image ( g_imagecache [ IMG_PREVIEW_MISSING ].i,
 317                                                             pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 50 ),
 318                                                             pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 50 ) );
 319
 320   // set alpha on detail panel
 321   //SDL_SetAlpha ( g_imagecache [ IMG_DETAIL_BG ].i, SDL_SRCALPHA, pnd_conf_get_as_int_d ( g_conf, "display.detail_bg_alpha", 50 ) );
 322
 323   return ( 1 );
 324 } // ui_imagecache
 325
 326 void ui_render ( void ) {
 327
 328   // 800x480:
 329   // divide width: 550 / 250
 330   // divide left side: 5 columns == 110px width
 331   //   20px buffer either side == 70px wide icon + 20 + 20?
 332
 333   // what jobs to do during render?
 334   //
 335
 336 #define R_BG     (1<<0)
 337 #define R_TABS   (1<<1)
 338 #define R_DETAIL (1<<2)
 339 #define R_GRID   (1<<3)
 340
 341 #define R_ALL (R_BG|R_TABS|R_DETAIL|R_GRID)
 342
 343   unsigned int render_jobs_b = 0;
 344
 345   if ( render_mask & CHANGED_EVERYTHING ) {
 346     render_jobs_b |= R_ALL;
 347   }
 348
 349   if ( render_mask & CHANGED_SELECTION ) {
 350     render_jobs_b |= R_GRID;
 351     render_jobs_b |= R_DETAIL;
 352   }
 353
 354   if ( render_mask & CHANGED_CATEGORY ) {
 355     render_jobs_b |= R_ALL;
 356   }
 357
 358   render_mask = CHANGED_NOTHING;
 359
 360   // render everything
 361   //
 362   unsigned int icon_rows;
 363
 364 #define MAXRECTS 200
 365   SDL_Rect rects [ MAXRECTS ], src;
 366   SDL_Rect *dest = rects;
 367   bzero ( dest, sizeof(SDL_Rect)*MAXRECTS );
 368
 369   unsigned int row, displayrow, col;
 370   mm_appref_t *appiter;
 371
 372   ui_context_t *c = &ui_display_context; // for convenience and shorthand
 373
 374   // how many total rows do we need?
 375   if ( g_categorycount ) {
 376     icon_rows = g_categories [ ui_category ] -> refcount / c -> col_max;
 377     if ( g_categories [ ui_category ] -> refcount % c -> col_max > 0 ) {
 378       icon_rows++;
 379     }
 380   } else {
 381     icon_rows = 0;
 382   }
 383
 384 #if 1
 385   // if no selected app yet, select the first one
 386   if ( ! ui_selected && pnd_conf_get_as_int_d ( g_conf, "minimenu.start_selected", 0 ) ) {
 387
 388     // pick first visible app
 389     ui_selected = g_categories [ ui_category ] -> refs;
 390
 391     // change.. so we pick first visible if option is set .. but now we also try to restore
 392     // selection to the last app selected in previous session (if there is one.)
 393     char *previous_unique_id = pnd_conf_get_as_char ( g_conf, "minimenu.last_known_app_uid" );
 394
 395     if ( previous_unique_id ) {
 396
 397       // 1) we should already be in the right category, since its set in ui_post_scan to minimenu.last_known_catname
 398       // 2) so we just pick the app in question..
 399       mm_appref_t *previter = g_categories [ ui_category ] -> refs;
 400       while ( previter ) {
 401         if ( strcmp ( previter -> ref -> unique_id, previous_unique_id ) == 0 ) {
 402           break;
 403         }
 404         previter = previter -> next;
 405       }
 406
 407       if ( previter ) {
 408         ui_selected = previter;
 409       }
 410
 411     } // last known app?
 412
 413   }
 414 #endif
 415
 416   // reset touchscreen regions
 417   if ( render_jobs_b ) {
 418     ui_register_reset();
 419   }
 420
 421   // ensure selection is visible
 422   if ( ui_selected ) {
 423
 424     unsigned char autoscrolled = 1;
 425     while ( autoscrolled ) {
 426       autoscrolled = 0;
 427
 428       int index = ui_selected_index();
 429       int topleft = c -> col_max * ui_rows_scrolled_down;
 430       int botright = ( c -> col_max * ( ui_rows_scrolled_down + c -> row_max ) - 1 );
 431
 432       if ( index < topleft ) {
 433         ui_rows_scrolled_down -= pnd_conf_get_as_int_d ( g_conf, "grid.scroll_increment", 1 );
 434         render_jobs_b |= R_ALL;
 435         autoscrolled = 1;
 436       } else if ( index > botright ) {
 437         ui_rows_scrolled_down += pnd_conf_get_as_int_d ( g_conf, "grid.scroll_increment", 1 );
 438         render_jobs_b |= R_ALL;
 439         autoscrolled = 1;
 440       }
 441
 442     } // while autoscrolling
 443
 444     if ( ui_rows_scrolled_down < 0 ) {
 445       ui_rows_scrolled_down = 0;
 446     } else if ( ui_rows_scrolled_down > icon_rows ) {
 447       ui_rows_scrolled_down = icon_rows;
 448     }
 449
 450   } // ensire visible
 451
 452   // render background
 453   if ( render_jobs_b & R_BG ) {
 454
 455     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
 456       dest -> x = 0;
 457       dest -> y = 0;
 458       dest -> w = sdl_realscreen -> w;
 459       dest -> h = sdl_realscreen -> h;
 460       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, NULL /* whole image */, sdl_realscreen, dest /* 0,0 */ );
 461       dest++;
 462     }
 463
 464     // tabmask
 465     if ( g_imagecache [ IMG_BACKGROUND_TABMASK ].i ) {
 466       dest -> x = 0;
 467       dest -> y = 0;
 468       dest -> w = sdl_realscreen -> w;
 469       dest -> h = sdl_realscreen -> h;
 470       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_TABMASK ].i, NULL /* whole image */, sdl_realscreen, dest /* 0,0 */ );
 471       dest++;
 472     }
 473
 474   } // r_bg
 475
 476   // tabs
 477   if ( g_imagecache [ IMG_TAB_SEL ].i && g_imagecache [ IMG_TAB_UNSEL ].i ) {
 478     static unsigned int tab_width;
 479     static unsigned int tab_height;
 480     static unsigned int tab_offset_x;
 481     static unsigned int tab_offset_y;
 482     static unsigned int text_offset_x;
 483     static unsigned int text_offset_y;
 484     static unsigned int text_width;
 485
 486     static unsigned char tab_first_run = 1;
 487     if ( tab_first_run ) {
 488       tab_first_run = 0;
 489       tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
 490       tab_height = pnd_conf_get_as_int ( g_conf, "tabs.tab_height" );
 491       tab_offset_x = pnd_conf_get_as_int ( g_conf, "tabs.tab_offset_x" );
 492       tab_offset_y = pnd_conf_get_as_int ( g_conf, "tabs.tab_offset_y" );
 493       text_offset_x = pnd_conf_get_as_int ( g_conf, "tabs.text_offset_x" );
 494       text_offset_y = pnd_conf_get_as_int ( g_conf, "tabs.text_offset_y" );
 495       text_width = pnd_conf_get_as_int ( g_conf, "tabs.text_width" );
 496     }
 497
 498     unsigned int maxtab = ( c -> screen_width / tab_width ) < g_categorycount ? ( c -> screen_width / tab_width ) + ui_catshift : g_categorycount + ui_catshift;
 499     unsigned int maxtabspot = ( c -> screen_width / tab_width );
 500
 501     if ( g_categorycount > 0 ) {
 502
 503       // draw tabs with categories
 504       for ( col = ui_catshift;
 505             col < maxtab;
 506             col++ )
 507       {
 508
 509         SDL_Surface *s;
 510
 511         // if this is the first (leftmost) tab, we use different artwork
 512         // than if the other tabs (so skinner can link lines up nicely.)
 513         if ( col == ui_catshift ) {
 514           // leftmost tab, special case
 515
 516           if ( col == ui_category ) {
 517             s = g_imagecache [ IMG_TAB_SEL_L ].i;
 518           } else {
 519             s = g_imagecache [ IMG_TAB_UNSEL_L ].i;
 520           }
 521
 522         } else if ( col == maxtab - 1 ) {
 523           // rightmost tab, special case
 524
 525           if ( col == ui_category ) {
 526             s = g_imagecache [ IMG_TAB_SEL_R ].i;
 527           } else {
 528             s = g_imagecache [ IMG_TAB_UNSEL_R ].i;
 529           }
 530
 531         } else {
 532           // normal (not leftmost) tab
 533
 534           if ( col == ui_category ) {
 535             s = g_imagecache [ IMG_TAB_SEL ].i;
 536           } else {
 537             s = g_imagecache [ IMG_TAB_UNSEL ].i;
 538           }
 539
 540         } // first col, or not first col?
 541
 542         // draw tab
 543         src.x = 0;
 544         src.y = 0;
 545 #if 0
 546         src.w = tab_width;
 547         if ( col == ui_category ) {
 548           src.h = tab_selheight;
 549         } else {
 550           src.h = tab_height;
 551         }
 552 #else
 553         src.w = s -> w;
 554         src.h = s -> h;
 555 #endif
 556         dest -> x = tab_offset_x + ( (col-ui_catshift) * tab_width );
 557         dest -> y = tab_offset_y;
 558
 559         // store touch info
 560         ui_register_tab ( col, dest -> x, dest -> y, tab_width, tab_height );
 561
 562         if ( render_jobs_b & R_TABS ) {
 563           //pnd_log ( pndn_debug, "tab %u at %ux%u\n", col, dest.x, dest.y );
 564           SDL_BlitSurface ( s, &src, sdl_realscreen, dest );
 565           dest++;
 566
 567           // draw tab line
 568           if ( col == ui_category ) {
 569             // no line for selected tab
 570           } else {
 571             if ( col - ui_catshift == 0 ) {
 572               s = g_imagecache [ IMG_TAB_LINEL ].i;
 573             } else if ( col - ui_catshift == maxtabspot - 1 ) {
 574               s = g_imagecache [ IMG_TAB_LINER ].i;
 575             } else {
 576               s = g_imagecache [ IMG_TAB_LINE ].i;
 577             }
 578             dest -> x = tab_offset_x + ( (col-ui_catshift) * tab_width );
 579             dest -> y = tab_offset_y + tab_height;
 580             SDL_BlitSurface ( s, NULL /* whole image */, sdl_realscreen, dest );
 581             dest++;
 582           }
 583
 584           // draw text
 585           SDL_Surface *rtext;
 586           rtext = TTF_RenderText_Blended ( g_tab_font, g_categories [ col ] -> catname, c -> fontcolor );
 587           src.x = 0;
 588           src.y = 0;
 589           src.w = rtext -> w < text_width ? rtext -> w : text_width;
 590           src.h = rtext -> h;
 591           dest -> x = tab_offset_x + ( (col-ui_catshift) * tab_width ) + text_offset_x;
 592           dest -> y = tab_offset_y + text_offset_y;
 593           SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
 594           SDL_FreeSurface ( rtext );
 595           dest++;
 596
 597         } // r_tabs
 598
 599       } // for
 600
 601     } // if we got categories
 602
 603     if ( render_jobs_b & R_TABS ) {
 604
 605       // draw tab lines under where tabs would be if we had categories
 606       for ( /* foo */; col < maxtabspot; col++ ) {
 607         SDL_Surface *s;
 608
 609         if ( col - ui_catshift == 0 ) {
 610           s = g_imagecache [ IMG_TAB_LINEL ].i;
 611         } else if ( col - ui_catshift == maxtabspot - 1 ) {
 612           s = g_imagecache [ IMG_TAB_LINER ].i;
 613         } else {
 614           s = g_imagecache [ IMG_TAB_LINE ].i;
 615         }
 616         dest -> x = tab_offset_x + ( (col-ui_catshift) * tab_width );
 617         dest -> y = tab_offset_y + tab_height;
 618         SDL_BlitSurface ( s, NULL /* whole image */, sdl_realscreen, dest );
 619         dest++;
 620
 621       } // for
 622
 623     } // r_tabs
 624
 625   } // tabs
 626
 627   // scroll bars and arrows
 628   if ( render_jobs_b & R_BG ) {
 629     unsigned char show_bar = 0;
 630
 631     // up?
 632     if ( ui_rows_scrolled_down && g_imagecache [ IMG_ARROW_UP ].i ) {
 633       dest -> x = c -> arrow_up_x;
 634       dest -> y = c -> arrow_up_y;
 635       SDL_BlitSurface ( g_imagecache [ IMG_ARROW_UP ].i, NULL /* whole image */, sdl_realscreen, dest );
 636       dest++;
 637
 638       show_bar = 1;
 639     }
 640
 641     // down?
 642     if ( ui_rows_scrolled_down + c -> row_max < icon_rows && g_imagecache [ IMG_ARROW_DOWN ].i ) {
 643       dest -> x = c -> arrow_down_x;
 644       dest -> y = c -> arrow_down_y;
 645       SDL_BlitSurface ( g_imagecache [ IMG_ARROW_DOWN ].i, NULL /* whole image */, sdl_realscreen, dest );
 646       dest++;
 647
 648       show_bar = 1;
 649     }
 650
 651     if ( show_bar ) {
 652       // show scrollbar as well
 653       src.x = 0;
 654       src.y = 0;
 655       src.w = c -> arrow_bar_clip_w;
 656       src.h = c -> arrow_bar_clip_h;
 657       dest -> x = c -> arrow_bar_x;
 658       dest -> y = c -> arrow_bar_y;
 659       SDL_BlitSurface ( g_imagecache [ IMG_ARROW_SCROLLBAR ].i, &src /* whole image */, sdl_realscreen, dest );
 660       dest++;
 661     } // bar
 662
 663   } // r_bg, scroll bars
 664
 665   // render detail pane bg
 666   if ( render_jobs_b & R_DETAIL && ui_detail_hidden == 0 ) {
 667
 668     if ( pnd_conf_get_as_int_d ( g_conf, "detailpane.show", 1 ) ) {
 669
 670       // render detail bg
 671       if ( g_imagecache [ IMG_DETAIL_BG ].i ) {
 672         src.x = 0; // pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
 673         src.y = 0; // pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
 674         src.w = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_PANEL ].i)) -> w;
 675         src.h = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_PANEL ].i)) -> h;
 676         dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
 677         dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
 678         SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
 679         dest++;
 680       }
 681
 682       // render detail pane
 683       if ( g_imagecache [ IMG_DETAIL_PANEL ].i ) {
 684         dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
 685         dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
 686         SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_PANEL ].i, NULL /* whole image */, sdl_realscreen, dest );
 687         dest++;
 688       }
 689
 690     } // detailpane frame/bg
 691
 692   } // r_details
 693
 694   // anything to render?
 695   if ( render_jobs_b & R_GRID && g_categorycount ) {
 696
 697     // if just rendering grid, and nothing else, better clear it first
 698     if ( ! ( render_jobs_b & R_BG ) ) {
 699       if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
 700         src.x = c -> grid_offset_x;
 701         src.y = c -> grid_offset_y + c -> sel_icon_offset_y;
 702         src.w = c -> col_max * c -> cell_width;
 703         src.h = c -> row_max * c -> cell_height;
 704
 705         dest -> x = c -> grid_offset_x;
 706         dest -> y = c -> grid_offset_y + c -> sel_icon_offset_y;
 707
 708         SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, &src, sdl_realscreen, dest );
 709         dest++;
 710
 711       }
 712     }
 713
 714     if ( g_categories [ ui_category ] -> refs ) {
 715
 716       appiter = g_categories [ ui_category ] -> refs;
 717       row = 0;
 718       displayrow = 0;
 719
 720       // until we run out of apps, or run out of space
 721       while ( appiter != NULL ) {
 722
 723         for ( col = 0; col < c -> col_max && appiter != NULL; col++ ) {
 724
 725           // do we even need to render it? or are we suppressing it due to rows scrolled off the top?
 726           if ( row >= ui_rows_scrolled_down ) {
 727
 728             // selected? show hilights
 729             if ( appiter == ui_selected ) {
 730               SDL_Surface *s = g_imagecache [ IMG_SELECTED_ALPHAMASK ].i;
 731               // icon
 732               //dest -> x = grid_offset_x + ( col * cell_width ) + icon_offset_x + ( ( icon_max_width - s -> w ) / 2 );
 733               dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> icon_offset_x + c -> sel_icon_offset_x;
 734               //dest -> y = grid_offset_y + ( displayrow * cell_height ) + icon_offset_y + ( ( icon_max_height - s -> h ) / 2 );
 735               dest -> y = c -> grid_offset_y + ( displayrow * c -> cell_height ) + c -> icon_offset_y + c -> sel_icon_offset_y;
 736               SDL_BlitSurface ( s, NULL /* all */, sdl_realscreen, dest );
 737               dest++;
 738               // text
 739               dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> text_clip_x;
 740               dest -> y = c -> grid_offset_y + ( displayrow * c -> cell_height ) + c -> text_hilite_offset_y;
 741               SDL_BlitSurface ( g_imagecache [ IMG_SELECTED_HILITE ].i, NULL /* all */, sdl_realscreen, dest );
 742               dest++;
 743             } // selected?
 744
 745             // show icon
 746             mm_cache_t *ic = cache_query_icon ( appiter -> ref -> unique_id );
 747             SDL_Surface *iconsurface;
 748             if ( ic ) {
 749               iconsurface = ic -> i;
 750             } else {
 751               //pnd_log ( pndn_warning, "WARNING: TBD: Need Missin-icon icon for '%s'\n", IFNULL(appiter -> ref -> title_en,"No Name") );
 752
 753               // no icon override; was this a pnd-file (show the unknown icon then), or was this generated from
 754               // filesystem (file or directory icon)
 755               if ( appiter -> ref -> object_flags & PND_DISCO_GENERATED ) {
 756                 if ( appiter -> ref -> object_type == pnd_object_type_directory ) {
 757
 758                   // is this a subcat, a .., or a filesystem folder?
 759                   //iconsurface = g_imagecache [ IMG_FOLDER ].i;
 760                   if ( g_categories [ ui_category ] -> fspath ) {
 761                     iconsurface = g_imagecache [ IMG_FOLDER ].i;
 762                   } else if ( strcmp ( appiter -> ref -> title_en, ".." ) == 0 ) {
 763                     iconsurface = g_imagecache [ IMG_DOTDOTFOLDER ].i;
 764                   } else {
 765                     iconsurface = g_imagecache [ IMG_SUBCATFOLDER ].i;
 766                   }
 767
 768                 } else {
 769                   iconsurface = g_imagecache [ IMG_EXECBIN ].i;
 770                 }
 771               } else {
 772                 iconsurface = g_imagecache [ IMG_ICON_MISSING ].i;
 773               }
 774
 775             }
 776
 777             // got an icon I hope?
 778             if ( iconsurface ) {
 779               //pnd_log ( pndn_debug, "Got an icon for '%s'\n", IFNULL(appiter -> ref -> title_en,"No Name") );
 780
 781               src.x = 0;
 782               src.y = 0;
 783               src.w = 60;
 784               src.h = 60;
 785               dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> icon_offset_x + (( c -> icon_max_width - iconsurface -> w ) / 2);
 786               dest -> y = c -> grid_offset_y + ( displayrow * c -> cell_height ) + c -> icon_offset_y + (( c -> icon_max_height - iconsurface -> h ) / 2);
 787
 788               SDL_BlitSurface ( iconsurface, &src, sdl_realscreen, dest );
 789
 790               // store touch info
 791               ui_register_app ( appiter, dest -> x, dest -> y, src.w, src.h );
 792
 793               dest++;
 794
 795             }
 796
 797             // show text
 798             if ( appiter -> ref -> title_en ) {
 799               SDL_Surface *rtext;
 800               rtext = TTF_RenderText_Blended ( g_grid_font, appiter -> ref -> title_en, c -> fontcolor );
 801               src.x = 0;
 802               src.y = 0;
 803               src.w = c -> text_width < rtext -> w ? c -> text_width : rtext -> w;
 804               src.h = rtext -> h;
 805               if ( rtext -> w > c -> text_width ) {
 806                 dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> text_clip_x;
 807               } else {
 808                 dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> text_offset_x - ( rtext -> w / 2 );
 809               }
 810               dest -> y = c -> grid_offset_y + ( displayrow * c -> cell_height ) + c -> text_offset_y;
 811               SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
 812               SDL_FreeSurface ( rtext );
 813               dest++;
 814             }
 815
 816           } // display now? or scrolled away..
 817
 818           // next
 819           appiter = appiter -> next;
 820
 821         } // for column 1...X
 822
 823         if ( row >= ui_rows_scrolled_down ) {
 824           displayrow++;
 825         }
 826
 827         row ++;
 828
 829         // are we done displaying rows?
 830         if ( displayrow >= c -> row_max ) {
 831           break;
 832         }
 833
 834       } // while
 835
 836     } else {
 837       // no apps to render?
 838       pnd_log ( pndn_rem, "No applications to render?\n" );
 839     } // apps to renser?
 840
 841   } // r_grid
 842
 843   // detail panel - show app details or blank-message
 844   if ( render_jobs_b & R_DETAIL && ui_detail_hidden == 0 ) {
 845
 846     unsigned int cell_offset_x = pnd_conf_get_as_int ( g_conf, "detailtext.cell_offset_x" );
 847     unsigned int cell_offset_y = pnd_conf_get_as_int ( g_conf, "detailtext.cell_offset_y" );
 848     unsigned int cell_width = pnd_conf_get_as_int ( g_conf, "detailtext.cell_width" );
 849
 850     unsigned int desty = cell_offset_y;
 851
 852     if ( ui_selected ) {
 853
 854       char buffer [ 256 ];
 855
 856       // full name
 857       if ( ui_selected -> ref -> title_en ) {
 858         SDL_Surface *rtext;
 859         rtext = TTF_RenderText_Blended ( g_detailtext_font, ui_selected -> ref -> title_en, c -> fontcolor );
 860         src.x = 0;
 861         src.y = 0;
 862         src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
 863         src.h = rtext -> h;
 864         dest -> x = cell_offset_x;
 865         dest -> y = desty;
 866         SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
 867         SDL_FreeSurface ( rtext );
 868         dest++;
 869         desty += src.h;
 870       }
 871
 872       // category
 873 #if 0
 874       if ( ui_selected -> ref -> main_category ) {
 875
 876         sprintf ( buffer, "Category: %s", ui_selected -> ref -> main_category );
 877
 878         SDL_Surface *rtext;
 879         rtext = TTF_RenderText_Blended ( g_detailtext_font, buffer, c -> fontcolor );
 880         src.x = 0;
 881         src.y = 0;
 882         src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
 883         src.h = rtext -> h;
 884         dest -> x = cell_offset_x;
 885         dest -> y = desty;
 886         SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
 887         SDL_FreeSurface ( rtext );
 888         dest++;
 889         desty += src.h;
 890       }
 891 #endif
 892
 893       // clock
 894       if ( ui_selected -> ref -> clockspeed ) {
 895
 896         sprintf ( buffer, "CPU Clock: %s", ui_selected -> ref -> clockspeed );
 897
 898         SDL_Surface *rtext;
 899         rtext = TTF_RenderText_Blended ( g_detailtext_font, buffer, c -> fontcolor );
 900         src.x = 0;
 901         src.y = 0;
 902         src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
 903         src.h = rtext -> h;
 904         dest -> x = cell_offset_x;
 905         dest -> y = desty;
 906         SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
 907         SDL_FreeSurface ( rtext );
 908         dest++;
 909         desty += src.h;
 910       }
 911
 912       // show sub-app# on right side of cpu clock?
 913       //if ( ui_selected -> ref -> subapp_number )
 914       {
 915         sprintf ( buffer, "(app#%u)", ui_selected -> ref -> subapp_number );
 916
 917         SDL_Surface *rtext;
 918         rtext = TTF_RenderText_Blended ( g_grid_font, buffer, c -> fontcolor );
 919         dest -> x = cell_offset_x + cell_width - rtext -> w;
 920         dest -> y = desty - src.h;
 921         SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
 922         SDL_FreeSurface ( rtext );
 923         dest++;
 924       }
 925
 926       // info hint
 927 #if 0 // merged into hint-line
 928       if ( ui_selected -> ref -> info_filename ) {
 929
 930         sprintf ( buffer, "Documentation - hit Y" );
 931
 932         SDL_Surface *rtext;
 933         rtext = TTF_RenderText_Blended ( g_detailtext_font, buffer, c -> fontcolor );
 934         src.x = 0;
 935         src.y = 0;
 936         src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
 937         src.h = rtext -> h;
 938         dest -> x = cell_offset_x;
 939         dest -> y = desty;
 940         SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
 941         SDL_FreeSurface ( rtext );
 942         dest++;
 943         desty += src.h;
 944       }
 945 #endif
 946
 947       // notes
 948       if ( ui_selected -> ovrh ) {
 949         char *n;
 950         unsigned char i;
 951         char buffer [ 50 ];
 952
 953         desty += 5; // a touch of spacing can't hurt
 954
 955         for ( i = 1; i < 4; i++ ) {
 956           sprintf ( buffer, "Application-%u.note-%u", ui_selected -> ref -> subapp_number, i );
 957           n = pnd_conf_get_as_char ( ui_selected -> ovrh, buffer );
 958
 959           if ( n ) {
 960             SDL_Surface *rtext;
 961             rtext = TTF_RenderText_Blended ( g_detailtext_font, n, c -> fontcolor );
 962             src.x = 0;
 963             src.y = 0;
 964             src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
 965             src.h = rtext -> h;
 966             dest -> x = cell_offset_x;
 967             dest -> y = desty;
 968             SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
 969             SDL_FreeSurface ( rtext );
 970             dest++;
 971             desty += rtext -> h;
 972           }
 973         } // for
 974
 975       } // r_detail -> notes
 976
 977       // preview pic
 978       mm_cache_t *ic = cache_query_preview ( ui_selected -> ref -> unique_id );
 979       SDL_Surface *previewpic;
 980
 981       if ( ic ) {
 982         previewpic = ic -> i;
 983       } else {
 984         previewpic = g_imagecache [ IMG_PREVIEW_MISSING ].i;
 985       }
 986
 987       if ( previewpic ) {
 988         dest -> x = pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_offset_x", 50 ) +
 989           ( ( pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 50 ) - previewpic -> w ) / 2 );
 990         dest -> y = pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_offset_y", 50 );
 991         SDL_BlitSurface ( previewpic, NULL /* whole image */, sdl_realscreen, dest );
 992         dest++;
 993       }
 994
 995     } else {
 996
 997       char *empty_message = "Press SELECT for menu";
 998
 999       SDL_Surface *rtext;
1000
1001       rtext = TTF_RenderText_Blended ( g_detailtext_font, empty_message, c -> fontcolor );
1002
1003       src.x = 0;
1004       src.y = 0;
1005       src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
1006       src.h = rtext -> h;
1007       dest -> x = cell_offset_x;
1008       dest -> y = desty;
1009       SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1010       SDL_FreeSurface ( rtext );
1011       dest++;
1012
1013       desty += src.h;
1014
1015       rtext = TTF_RenderText_Blended ( g_detailtext_font, "START or B to run app", c -> fontcolor );
1016       dest -> x = cell_offset_x;
1017       dest -> y = desty;
1018       SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1019       SDL_FreeSurface ( rtext );
1020       dest++;
1021       desty += src.h;
1022
1023       rtext = TTF_RenderText_Blended ( g_detailtext_font, "SPACE for app menu", c -> fontcolor );
1024       dest -> x = cell_offset_x;
1025       dest -> y = desty;
1026       SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1027       SDL_FreeSurface ( rtext );
1028       dest++;
1029       desty += src.h;
1030
1031       rtext = TTF_RenderText_Blended ( g_detailtext_font, "A to toggle details", c -> fontcolor );
1032       dest -> x = cell_offset_x;
1033       dest -> y = desty;
1034       SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1035       SDL_FreeSurface ( rtext );
1036       dest++;
1037       desty += src.h;
1038
1039     } // r_detail && selected?
1040
1041   } // r_detail
1042
1043   // extras
1044   //
1045
1046   // battery
1047   if ( render_jobs_b & R_BG ) {
1048     static int last_battlevel = 0;
1049     static unsigned char batterylevel = 0;
1050     char buffer [ 100 ];
1051
1052     if ( time ( NULL ) - last_battlevel > 60 ) {
1053       batterylevel = pnd_device_get_battery_gauge_perc();
1054       last_battlevel = time ( NULL );
1055     }
1056
1057     sprintf ( buffer, "Battery: %u%%", batterylevel );
1058
1059     SDL_Surface *rtext;
1060     rtext = TTF_RenderText_Blended ( g_grid_font, buffer, c -> fontcolor );
1061     dest -> x = pnd_conf_get_as_int_d ( g_conf, "display.battery_x", 20 );
1062     dest -> y = pnd_conf_get_as_int_d ( g_conf, "display.battery_y", 450 );
1063     SDL_BlitSurface ( rtext, NULL /* all */, sdl_realscreen, dest );
1064     SDL_FreeSurface ( rtext );
1065     dest++;
1066   }
1067
1068   // hints
1069   if ( pnd_conf_get_as_char ( g_conf, "display.hintline" ) ) {
1070     char *buffer;
1071     unsigned int hintx, hinty;
1072     hintx = pnd_conf_get_as_int_d ( g_conf, "display.hint_x", 40 );
1073     hinty = pnd_conf_get_as_int_d ( g_conf, "display.hint_y", 450 );
1074     static unsigned int lastwidth = 3000;
1075
1076     if ( ui_selected && ui_selected -> ref -> info_filename ) {
1077       buffer = "Documentation - hit Y";
1078     } else {
1079       buffer = pnd_conf_get_as_char ( g_conf, "display.hintline" );
1080     }
1081
1082     SDL_Surface *rtext;
1083     rtext = TTF_RenderText_Blended ( g_grid_font, buffer, c -> fontcolor );
1084
1085     // clear bg
1086     if ( ! ( render_jobs_b & R_BG ) ) {
1087       src.x = hintx;
1088       src.y = hinty;
1089       src.w = lastwidth;
1090       src.h = rtext -> h;
1091       dest -> x = hintx;
1092       dest -> y = hinty;
1093       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_TABMASK ].i, &src, sdl_realscreen, dest );
1094       dest++;
1095       lastwidth = rtext -> w;
1096     }
1097
1098     // now render text
1099     dest -> x = hintx;
1100     dest -> y = hinty;
1101     SDL_BlitSurface ( rtext, NULL /* all */, sdl_realscreen, dest );
1102     SDL_FreeSurface ( rtext );
1103     dest++;
1104   }
1105
1106   // clock time
1107   if ( render_jobs_b & R_BG &&
1108        pnd_conf_get_as_int_d ( g_conf, "display.clock_x", -1 ) != -1 )
1109   {
1110     char buffer [ 50 ];
1111
1112     time_t t = time ( NULL );
1113     struct tm *tm = localtime ( &t );
1114     strftime ( buffer, 50, "%a %H:%M %F", tm );
1115
1116     SDL_Surface *rtext;
1117     rtext = TTF_RenderText_Blended ( g_grid_font, buffer, c -> fontcolor );
1118     dest -> x = pnd_conf_get_as_int_d ( g_conf, "display.clock_x", 700 );
1119     dest -> y = pnd_conf_get_as_int_d ( g_conf, "display.clock_y", 450 );
1120     SDL_BlitSurface ( rtext, NULL /* all */, sdl_realscreen, dest );
1121     SDL_FreeSurface ( rtext );
1122     dest++;
1123   }
1124
1125   // update all the rects and send it all to sdl
1126   // - at this point, we could probably just do 1 rect, of the
1127   //   whole screen, and be faster :/
1128   SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
1129
1130 } // ui_render
1131
1132 void ui_process_input ( pnd_dbusnotify_handle dbh, pnd_notify_handle nh ) {
1133   SDL_Event event;
1134
1135   unsigned char ui_event = 0; // if we get a ui event, flip to 1 and break
1136   //static ui_sdl_button_e ui_mask = uisb_none; // current buttons down
1137
1138   while ( ( ! ui_event ) &&
1139           /*block_p ?*/ SDL_WaitEvent ( &event ) /*: SDL_PollEvent ( &event )*/ )
1140   {
1141
1142     switch ( event.type ) {
1143
1144     case SDL_USEREVENT:
1145       // update something
1146
1147       // the user-defined SDL events are all for threaded/delayed previews (and icons, which
1148       // generally are not used); if we're in wide mode, we can skip previews
1149       // to avoid slowing things down when they're not shown.
1150
1151       if ( event.user.code == sdl_user_ticker ) {
1152
1153         if ( ui_detail_hidden ) {
1154           break; // skip building previews when not showing them
1155         }
1156
1157         // timer went off, time to load something
1158         if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_previews_later", 0 ) ) {
1159
1160           if ( ! ui_selected ) {
1161             break;
1162           }
1163
1164           // load the preview pics now!
1165           pnd_disco_t *iter = ui_selected -> ref;
1166
1167           if ( iter -> preview_pic1 ) {
1168
1169             if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.threaded_preview", 0 ) ) {
1170               // load in bg thread, make user experience chuggy
1171
1172               g_preview_thread = SDL_CreateThread ( (void*)ui_threaded_defered_preview, iter );
1173
1174               if ( ! g_preview_thread ) {
1175                 pnd_log ( pndn_error, "ERROR: Couldn't create preview thread\n" );
1176               }
1177
1178             } else {
1179               // load it now, make user wait
1180
1181               if ( ! cache_preview ( iter, pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 200 ),
1182                                      pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 180 ) )
1183                  )
1184               {
1185                 pnd_log ( pndn_debug, "  Couldn't load preview pic: '%s' -> '%s'\n",
1186                           IFNULL(iter->title_en,"No Name"), iter -> preview_pic1 );
1187               }
1188
1189             } // threaded?
1190
1191           } // got a preview at all?
1192
1193           ui_event++;
1194         }
1195
1196       } else if ( event.user.code == sdl_user_finishedpreview ) {
1197
1198         // if we just finished the one we happen to be looking at, better redraw now; otherwise, if
1199         // we finished another, no big woop
1200         if ( ui_selected && event.user.data1 == ui_selected -> ref ) {
1201           ui_event++;
1202         }
1203
1204       } else if ( event.user.code == sdl_user_finishedicon ) {
1205         // redraw, so we can show the newly loaded icon
1206         ui_event++;
1207
1208       } else if ( event.user.code == sdl_user_checksd ) {
1209         // check if any inotify-type events occured, forcing us to rescan/re-disco the SDs
1210
1211         unsigned char watch_dbus = 0;
1212         unsigned char watch_inotify = 0;
1213
1214         if ( dbh ) {
1215           watch_dbus = pnd_dbusnotify_rediscover_p ( dbh );
1216         }
1217
1218         if ( nh ) {
1219           watch_inotify = pnd_notify_rediscover_p ( nh );
1220         }
1221
1222         if ( watch_dbus || watch_inotify ) {
1223           pnd_log ( pndn_debug, "dbusnotify detected SD event\n" );
1224           applications_free();
1225           applications_scan();
1226
1227           ui_event++;
1228         }
1229
1230       } // SDL user event
1231
1232       render_mask |= CHANGED_EVERYTHING;
1233
1234       break;
1235
1236 #if 0 // joystick motion
1237     case SDL_JOYAXISMOTION:
1238
1239       pnd_log ( PND_LOG_DEFAULT, "joystick axis\n" );
1240
1241         if ( event.jaxis.axis == 0 ) {
1242           // horiz
1243           if ( event.jaxis.value < 0 ) {
1244             ui_push_left ( 0 );
1245             pnd_log ( PND_LOG_DEFAULT, "joystick axis - LEFT\n" );
1246           } else if ( event.jaxis.value > 0 ) {
1247             ui_push_right ( 0 );
1248             pnd_log ( PND_LOG_DEFAULT, "joystick axis - RIGHT\n" );
1249           }
1250         } else if ( event.jaxis.axis == 1 ) {
1251           // vert
1252           if ( event.jaxis.value < 0 ) {
1253             ui_push_up();
1254           } else if ( event.jaxis.value > 0 ) {
1255             ui_push_down();
1256           }
1257         }
1258
1259         ui_event++;
1260
1261         break;
1262 #endif
1263
1264 #if 0 // joystick buttons
1265     case SDL_JOYBUTTONDOWN:
1266
1267       pnd_log ( PND_LOG_DEFAULT, "joystick button down %u\n", event.jbutton.button );
1268
1269       if ( event.jbutton.button == 0 ) { // B
1270         ui_mask |= uisb_b;
1271       } else if ( event.jbutton.button == 1 ) { // Y
1272         ui_mask |= uisb_y;
1273       } else if ( event.jbutton.button == 2 ) { // X
1274         ui_mask |= uisb_x;
1275       } else if ( event.jbutton.button == 3 ) { // A
1276         ui_mask |= uisb_a;
1277
1278       } else if ( event.jbutton.button == 4 ) { // Select
1279         ui_mask |= uisb_select;
1280       } else if ( event.jbutton.button == 5 ) { // Start
1281         ui_mask |= uisb_start;
1282
1283       } else if ( event.jbutton.button == 7 ) { // L
1284         ui_mask |= uisb_l;
1285       } else if ( event.jbutton.button == 8 ) { // R
1286         ui_mask |= uisb_r;
1287
1288       }
1289
1290       ui_event++;
1291
1292       break;
1293
1294     case SDL_JOYBUTTONUP:
1295
1296       pnd_log ( PND_LOG_DEFAULT, "joystick button up %u\n", event.jbutton.button );
1297
1298       if ( event.jbutton.button == 0 ) { // B
1299         ui_mask &= ~uisb_b;
1300         ui_push_exec();
1301       } else if ( event.jbutton.button == 1 ) { // Y
1302         ui_mask &= ~uisb_y;
1303       } else if ( event.jbutton.button == 2 ) { // X
1304         ui_mask &= ~uisb_x;
1305       } else if ( event.jbutton.button == 3 ) { // A
1306         ui_mask &= ~uisb_a;
1307
1308       } else if ( event.jbutton.button == 4 ) { // Select
1309         ui_mask &= ~uisb_select;
1310       } else if ( event.jbutton.button == 5 ) { // Start
1311         ui_mask &= ~uisb_start;
1312
1313       } else if ( event.jbutton.button == 7 ) { // L
1314         ui_mask &= ~uisb_l;
1315         ui_push_ltrigger();
1316       } else if ( event.jbutton.button == 8 ) { // R
1317         ui_mask &= ~uisb_r;
1318         ui_push_rtrigger();
1319
1320       }
1321
1322       ui_event++;
1323
1324       break;
1325 #endif
1326
1327 #if 1 // keyboard events
1328     //case SDL_KEYUP:
1329     case SDL_KEYDOWN:
1330
1331       //pnd_log ( pndn_debug, "key up %u\n", event.key.keysym.sym );
1332
1333       // SDLK_LALT -> Start
1334       // page up/down for y/x
1335       // home/end for a and b
1336
1337       // directional
1338       if ( event.key.keysym.sym == SDLK_RIGHT ) {
1339         ui_push_right ( 0 );
1340         ui_event++;
1341       } else if ( event.key.keysym.sym == SDLK_LEFT ) {
1342         ui_push_left ( 0 );
1343         ui_event++;
1344       } else if ( event.key.keysym.sym == SDLK_UP ) {
1345         ui_push_up();
1346         ui_event++;
1347       } else if ( event.key.keysym.sym == SDLK_DOWN ) {
1348         ui_push_down();
1349         ui_event++;
1350       } else if ( event.key.keysym.sym == SDLK_END ) { // B
1351         ui_push_exec();
1352         ui_event++;
1353       } else if ( event.key.keysym.sym == SDLK_SPACE ) { // space
1354         if ( ui_selected ) {
1355           ui_menu_context ( ui_selected );
1356         } else {
1357           // TBD: post an error?
1358         }
1359         render_mask |= CHANGED_EVERYTHING;
1360         ui_event++;
1361       } else if ( event.key.keysym.sym == SDLK_TAB || event.key.keysym.sym == SDLK_HOME ) { // tab or A
1362         // if detail panel is togglable, then toggle it
1363         // if not, make sure its ruddy well shown!
1364         if ( ui_is_detail_hideable() ) {
1365           ui_toggle_detail_pane();
1366         } else {
1367           ui_detail_hidden = 0;
1368         }
1369         ui_event++;
1370       } else if ( event.key.keysym.sym == SDLK_RSHIFT || event.key.keysym.sym == SDLK_COMMA ) { // left trigger or comma
1371         ui_push_ltrigger();
1372         ui_event++;
1373       } else if ( event.key.keysym.sym == SDLK_RCTRL || event.key.keysym.sym == SDLK_PERIOD ) { // right trigger or period
1374         ui_push_rtrigger();
1375         ui_event++;
1376
1377       } else if ( event.key.keysym.sym == SDLK_PAGEUP ) { // Y
1378         // info
1379         if ( ui_selected ) {
1380           ui_show_info ( pnd_run_script, ui_selected -> ref );
1381           ui_event++;
1382         }
1383       } else if ( event.key.keysym.sym == SDLK_PAGEDOWN ) { // X
1384         ui_push_backup();
1385
1386         // forget the selection, nolonger applies
1387         ui_selected = NULL;
1388         ui_set_selected ( ui_selected );
1389         // rescan the dir
1390         if ( g_categories [ ui_category ] -> fspath ) {
1391           category_fs_restock ( g_categories [ ui_category ] );
1392         }
1393         // redraw the grid
1394         render_mask |= CHANGED_EVERYTHING;
1395         ui_event++;
1396
1397       } else if ( event.key.keysym.sym == SDLK_LALT ) { // start button
1398         ui_push_exec();
1399         ui_event++;
1400
1401       } else if ( event.key.keysym.sym == SDLK_LCTRL /*LALT*/ ) { // select button
1402         char *opts [ 20 ] = {
1403           "Reveal hidden category",
1404           "Shutdown Pandora",
1405           "Configure Minimenu",
1406           "Manage custom app categories",
1407           "Rescan for applications",
1408           "Cache previews to SD now",
1409           "Run a terminal/console",
1410           "Run another GUI (xfce, etc)",
1411           "Quit (<- beware)",
1412           "Select a Minimenu skin",
1413           "About Minimenu"
1414         };
1415         int sel = ui_modal_single_menu ( opts, 11, "Minimenu", "Enter to select; other to return." );
1416
1417         char buffer [ 100 ];
1418         if ( sel == 0 ) {
1419           // do nothing
1420           ui_revealscreen();
1421         } else if ( sel == 1 ) {
1422           // shutdown
1423           sprintf ( buffer, "sudo poweroff" );
1424           system ( buffer );
1425         } else if ( sel == 2 ) {
1426           // configure mm
1427           unsigned char restart = conf_run_menu ( NULL );
1428           conf_write ( g_conf, conf_determine_location ( g_conf ) );
1429           conf_write ( g_conf, CONF_PREF_TEMPPATH );
1430           if ( restart ) {
1431             emit_and_quit ( MM_RESTART );
1432           }
1433         } else if ( sel == 3 ) {
1434           // manage custom categories
1435           ui_manage_categories();
1436         } else if ( sel == 4 ) {
1437           // rescan apps
1438           pnd_log ( pndn_debug, "Freeing up applications\n" );
1439           applications_free();
1440           pnd_log ( pndn_debug, "Rescanning applications\n" );
1441           applications_scan();
1442         } else if ( sel == 5 ) {
1443           // cache preview to SD now
1444           extern pnd_box_handle g_active_apps;
1445           pnd_box_handle h = g_active_apps;
1446
1447           unsigned int maxwidth, maxheight;
1448           maxwidth = pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 200 );
1449           maxheight = pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 180 );
1450
1451           pnd_disco_t *iter = pnd_box_get_head ( h );
1452
1453           while ( iter ) {
1454
1455             // cache it
1456             if ( ! cache_preview ( iter, maxwidth, maxheight ) ) {
1457               pnd_log ( pndn_debug, "Force cache: Couldn't load preview pic: '%s' -> '%s'\n",
1458                         IFNULL(iter->title_en,"No Name"), iter -> preview_pic1 );
1459             }
1460
1461             // next
1462             iter = pnd_box_get_next ( iter );
1463           } // while
1464
1465         } else if ( sel == 6 ) {
1466           // run terminal
1467           char *argv[5];
1468           argv [ 0 ] = pnd_conf_get_as_char ( g_conf, "utility.terminal" );
1469           argv [ 1 ] = NULL;
1470
1471           if ( argv [ 0 ] ) {
1472             ui_forkexec ( argv );
1473           }
1474
1475         } else if ( sel == 7 ) {
1476           char buffer [ PATH_MAX ];
1477           sprintf ( buffer, "%s %s\n", MM_RUN, "/usr/pandora/scripts/op_switchgui.sh" );
1478           emit_and_quit ( buffer );
1479         } else if ( sel == 8 ) {
1480           emit_and_quit ( MM_QUIT );
1481         } else if ( sel == 9 ) {
1482           // select skin
1483           if ( ui_pick_skin() ) {
1484             emit_and_quit ( MM_RESTART );
1485           }
1486         } else if ( sel == 10 ) {
1487           // about
1488           char buffer [ PATH_MAX ];
1489           sprintf ( buffer, "%s/about.txt", g_skinpath );
1490           ui_aboutscreen ( buffer );
1491         }
1492
1493         ui_event++;
1494         render_mask |= CHANGED_EVERYTHING;
1495
1496       } else {
1497         // unknown SDLK_ keycode?
1498
1499         // many SDLK_keycodes map to ASCII ("a" is ascii(a)), so try to jump to a filename of that name, in this category?
1500         // and if already there, try to jump to next, maybe?
1501         // future: look for sequence typing? ie: user types 'm' then 'a', look for 'ma*' instead of 'm' then 'a' matching
1502         if ( isalpha ( event.key.keysym.sym ) && g_categories [ ui_category ] -> refcount > 0 ) {
1503           mm_appref_t *app = g_categories [ ui_category ] -> refs;
1504
1505           //fprintf ( stderr, "sel %s next %s\n", ui_selected -> ref -> title_en, ui_selected -> next -> ref -> title_en );
1506
1507           // are we already matching the same char? and next item is also same char?
1508           if ( app && ui_selected && ui_selected -> next &&
1509                ui_selected -> ref -> title_en && ui_selected -> next -> ref -> title_en &&
1510                toupper ( ui_selected -> ref -> title_en [ 0 ] ) == toupper ( ui_selected -> next -> ref -> title_en [ 0 ] ) &&
1511                toupper ( ui_selected -> ref -> title_en [ 0 ] ) == toupper ( event.key.keysym.sym )
1512              )
1513           {
1514             // just skip down one
1515             app = ui_selected -> next;
1516           } else {
1517
1518             // walk the category, looking for a first-char match
1519             while ( app ) {
1520               if ( app -> ref -> title_en && toupper ( app -> ref -> title_en [ 0 ] ) == toupper ( event.key.keysym.sym ) ) {
1521                 break;
1522               }
1523               app = app -> next;
1524             }
1525
1526           } // same start letter, or new run?
1527
1528           // found something, or no?
1529           if ( app ) {
1530             // looks like we found a potential match; try switching it to visible selection
1531             ui_selected = app;
1532             ui_set_selected ( ui_selected );
1533             ui_event++;
1534           }
1535
1536
1537         } // SDLK_alphanumeric?
1538
1539       } // SDLK_....
1540
1541       // extras
1542 #if 1
1543       if ( event.key.keysym.sym == SDLK_ESCAPE ) {
1544         emit_and_quit ( MM_QUIT );
1545       }
1546 #endif
1547
1548       break;
1549 #endif
1550
1551 #if 1 // mouse / touchscreen
1552 #if 0
1553     case SDL_MOUSEBUTTONDOWN:
1554       if ( event.button.button == SDL_BUTTON_LEFT ) {
1555         cb_pointer_press ( gc, event.button.x / g_scale, event.button.y / g_scale );
1556         ui_event++;
1557       }
1558       break;
1559 #endif
1560
1561     case SDL_MOUSEBUTTONUP:
1562       if ( event.button.button == SDL_BUTTON_LEFT ) {
1563         ui_touch_act ( event.button.x, event.button.y );
1564         ui_event++;
1565       }
1566       break;
1567 #endif
1568
1569     case SDL_QUIT:
1570       exit ( 0 );
1571       break;
1572
1573     default:
1574       break;
1575
1576     } // switch event type
1577
1578   } // while poll
1579
1580   return;
1581 }
1582
1583 void ui_push_left ( unsigned char forcecoil ) {
1584
1585   if ( ! ui_selected ) {
1586     ui_push_right ( 0 );
1587     return;
1588   }
1589
1590   // what column we in?
1591   unsigned int col = ui_determine_screen_col ( ui_selected );
1592
1593   // are we already at first item?
1594   if ( forcecoil == 0 &&
1595        pnd_conf_get_as_int_d ( g_conf, "grid.wrap_horiz_samerow", 0 ) &&
1596        col == 0 )
1597   {
1598     unsigned int i = ui_display_context.col_max - 1;
1599     while ( i && ui_selected -> next ) {
1600       ui_push_right ( 0 );
1601       i--;
1602     }
1603
1604   } else if ( g_categories [ ui_category ] -> refs == ui_selected ) {
1605     // can't go any more left, we're at the head
1606
1607   } else {
1608     // figure out the previous item; yay for singly linked list :/
1609     mm_appref_t *i = g_categories [ ui_category ] -> refs;
1610     while ( i ) {
1611       if ( i -> next == ui_selected ) {
1612         ui_selected = i;
1613         break;
1614       }
1615       i = i -> next;
1616     }
1617   }
1618
1619   ui_set_selected ( ui_selected );
1620
1621   return;
1622 }
1623
1624 void ui_push_right ( unsigned char forcecoil ) {
1625
1626   if ( ui_selected ) {
1627
1628     // what column we in?
1629     unsigned int col = ui_determine_screen_col ( ui_selected );
1630
1631     // wrap same or no?
1632     if ( forcecoil == 0 &&
1633          pnd_conf_get_as_int_d ( g_conf, "grid.wrap_horiz_samerow", 0 ) &&
1634          // and selected is far-right, or last icon in category (might not be far right)
1635          ( ( col == ui_display_context.col_max - 1 ) ||
1636            ( ui_selected -> next == NULL ) )
1637        )
1638     {
1639       // same wrap
1640       //unsigned int i = pnd_conf_get_as_int_d ( g_conf, "grid.col_max", 5 ) - 1;
1641       while ( col /*i*/ ) {
1642         ui_push_left ( 0 );
1643         col--; //i--;
1644       }
1645
1646     } else {
1647       // just go to the next
1648
1649       if ( ui_selected -> next ) {
1650         ui_selected = ui_selected -> next;
1651       }
1652
1653     }
1654
1655   } else {
1656     ui_selected = g_categories [ ui_category ] -> refs;
1657   }
1658
1659   ui_set_selected ( ui_selected );
1660
1661   return;
1662 }
1663
1664 void ui_push_up ( void ) {
1665   unsigned char col_max = ui_display_context.col_max;
1666
1667   if ( ! ui_selected ) {
1668     return;
1669   }
1670
1671   // what row we in?
1672   unsigned int row = ui_determine_row ( ui_selected );
1673
1674   if ( row == 0 &&
1675        pnd_conf_get_as_int_d ( g_conf, "grid.wrap_vert_stop", 0 ) == 0 )
1676   {
1677     // wrap around instead
1678
1679     unsigned int col = ui_determine_screen_col ( ui_selected );
1680
1681     // go to end
1682     ui_selected = g_categories [ ui_category ] -> refs;
1683     while ( ui_selected -> next ) {
1684       ui_selected = ui_selected -> next;
1685     }
1686
1687     // try to move to same column
1688     unsigned int newcol = ui_determine_screen_col ( ui_selected );
1689     if ( newcol > col ) {
1690       col = newcol - col;
1691       while ( col ) {
1692         ui_push_left ( 0 );
1693         col--;
1694       }
1695     }
1696
1697     // scroll down to show it
1698     int r = ui_determine_row ( ui_selected ) - 1;
1699     if ( r - ui_display_context.row_max > 0 ) {
1700       ui_rows_scrolled_down = (unsigned int) r;
1701     }
1702
1703   } else {
1704     // stop at top/bottom
1705
1706     while ( col_max ) {
1707       ui_push_left ( 1 );
1708       col_max--;
1709     }
1710
1711   }
1712
1713   return;
1714 }
1715
1716 void ui_push_down ( void ) {
1717   unsigned char col_max = ui_display_context.col_max;
1718
1719   if ( ui_selected ) {
1720
1721     // what row we in?
1722     unsigned int row = ui_determine_row ( ui_selected );
1723
1724     // max rows?
1725     unsigned int icon_rows = g_categories [ ui_category ] -> refcount / col_max;
1726     if ( g_categories [ ui_category ] -> refcount % col_max > 0 ) {
1727       icon_rows++;
1728     }
1729
1730     // we at the end?
1731     if ( row == ( icon_rows - 1 ) &&
1732          pnd_conf_get_as_int_d ( g_conf, "grid.wrap_vert_stop", 0 ) == 0 )
1733     {
1734
1735       unsigned char col = ui_determine_screen_col ( ui_selected );
1736
1737       ui_selected = g_categories [ ui_category ] -> refs;
1738
1739       while ( col ) {
1740         ui_selected = ui_selected -> next;
1741         col--;
1742       }
1743
1744       ui_rows_scrolled_down = 0;
1745
1746       render_mask |= CHANGED_EVERYTHING;
1747
1748     } else {
1749
1750       while ( col_max ) {
1751         ui_push_right ( 1 );
1752         col_max--;
1753       }
1754
1755     }
1756
1757   } else {
1758     ui_push_right ( 0 );
1759   }
1760
1761   return;
1762 }
1763
1764 // 'backup' is currently 'X', for going back up in a folder/subcat without having to hit exec on the '..' entry
1765 void ui_push_backup ( void ) {
1766
1767   // a subcat-as-dir, or a dir browser?
1768   if ( g_categories [ ui_category] -> fspath ) {
1769     // dir browser, just climb our way back up
1770
1771     // go up
1772     char *c;
1773
1774     // lop off last word; if the thing ends with /, lop that one, then the next word.
1775     while ( ( c = strrchr ( g_categories [ ui_category] -> fspath, '/' ) ) ) {
1776       *c = '\0'; // lop off the last hunk
1777       if ( *(c+1) != '\0' ) {
1778         break;
1779       }
1780     } // while
1781
1782     // nothing left?
1783     if ( g_categories [ ui_category] -> fspath [ 0 ] == '\0' ) {
1784       free ( g_categories [ ui_category] -> fspath );
1785       g_categories [ ui_category] -> fspath = strdup ( "/" );
1786     }
1787
1788   } else {
1789     // a pnd subcat .. are we in one, or at the 'top'?
1790     char *pcatname = g_categories [ ui_category ] -> parent_catname;
1791
1792     if ( ! pcatname ) {
1793       return; // we're at the 'top' already
1794     }
1795
1796     // set to first cat!
1797     ui_category = 0;
1798
1799     // republish cats .. shoudl just be the one
1800     category_publish ( CFNORMAL, NULL );
1801
1802     if ( pcatname ) {
1803       ui_category = category_index ( pcatname );
1804
1805       // ensure tab visible?
1806       unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
1807       if ( ui_category > ui_catshift + ( ui_display_context.screen_width / tab_width ) - 1 ) {
1808         ui_catshift = ui_category - ( ui_display_context.screen_width / tab_width ) + 1;
1809       }
1810
1811     }
1812
1813   } // dir or subcat?
1814
1815   return;
1816 }
1817
1818 void ui_push_exec ( void ) {
1819
1820   if ( ! ui_selected ) {
1821     return;
1822   }
1823
1824   // cache the category/app so we can come back to it another time
1825   if ( ui_selected ) {
1826     pnd_conf_set_char ( g_conf, "minimenu.last_known_app_uid", ui_selected -> ref -> unique_id );
1827   }
1828   if ( g_categories [ 0 ] ) {
1829     pnd_conf_set_char ( g_conf, "minimenu.last_known_catname", g_categories [ ui_category ] -> catname );
1830
1831     // and also the parent cat..
1832     if ( g_categories [ ui_category ] -> parent_catname ) {
1833       pnd_conf_set_char ( g_conf, "minimenu.last_known_parentcatname", g_categories [ ui_category ] -> parent_catname );
1834     } else {
1835       char *kv = pnd_box_find_by_key ( g_conf, "minimenu.last_known_parentcatname" );
1836       if ( kv ) {
1837         pnd_box_delete_node ( g_conf, kv );
1838       }
1839
1840     }
1841   }
1842
1843   // cache last known cat/app to /tmp, so we can use it again later
1844   conf_write ( g_conf, CONF_PREF_TEMPPATH );
1845
1846   // was this icon generated from filesystem, or from pnd-file?
1847   if ( ui_selected -> ref -> object_flags & PND_DISCO_GENERATED ) {
1848
1849     if ( ! ui_selected -> ref -> title_en ) {
1850       return; // no filename
1851     }
1852
1853     if ( ui_selected -> ref -> object_type == pnd_object_type_directory ) {
1854
1855       // check if this guy is a dir-browser tab, or is a directory on a pnd tab
1856       if ( ! g_categories [ ui_category] -> fspath ) {
1857         // pnd subcat as dir
1858
1859         // are we already in a subcat? if so, go back to parent; there is no grandparenting or deeper
1860         if ( g_categories [ ui_category ] -> parent_catname ) {
1861           // go back up
1862           ui_push_backup();
1863
1864         } else {
1865           // delve into subcat
1866
1867           // set to first cat!
1868           ui_category = 0;
1869           ui_catshift = 0;
1870
1871           // republish cats .. shoudl just be the one
1872           category_publish ( CFBYNAME, ui_selected -> ref -> object_path );
1873
1874         }
1875
1876         // forget the selection, nolonger applies
1877         ui_selected = NULL;
1878         ui_set_selected ( ui_selected );
1879         // redraw the grid
1880         render_mask |= CHANGED_EVERYTHING;
1881
1882       } else {
1883
1884         // delve up/down the dir tree
1885         if ( strcmp ( ui_selected -> ref -> title_en, ".." ) == 0 ) {
1886           ui_push_backup();
1887
1888         } else {
1889           // go down
1890           char *temp = malloc ( strlen ( g_categories [ ui_category] -> fspath ) + strlen ( ui_selected -> ref -> title_en ) + 1 + 1 );
1891           sprintf ( temp, "%s/%s", g_categories [ ui_category] -> fspath, ui_selected -> ref -> title_en );
1892           free ( g_categories [ ui_category] -> fspath );
1893           g_categories [ ui_category] -> fspath = temp;
1894         }
1895
1896         pnd_log ( pndn_debug, "Cat %s is now in path %s\n", g_categories [ ui_category ] -> catname, g_categories [ ui_category ]-> fspath );
1897
1898         // forget the selection, nolonger applies
1899         ui_selected = NULL;
1900         ui_set_selected ( ui_selected );
1901         // rescan the dir
1902         category_fs_restock ( g_categories [ ui_category ] );
1903         // redraw the grid
1904         render_mask |= CHANGED_SELECTION;
1905
1906       } // directory browser or pnd subcat?
1907
1908     } else {
1909       // just run it arbitrarily?
1910
1911       // if this a pnd-file, or just some executable?
1912       if ( strcasestr ( ui_selected -> ref -> object_filename, PND_PACKAGE_FILEEXT ) ) {
1913         // looks like a pnd, now what do we do..
1914         pnd_box_handle h = pnd_disco_file ( ui_selected -> ref -> object_path, ui_selected -> ref -> object_filename );
1915
1916         if ( h ) {
1917           pnd_disco_t *d = pnd_box_get_head ( h );
1918           pnd_apps_exec_disco ( pnd_run_script, d, PND_EXEC_OPTION_NORUN, NULL );
1919           char buffer [ PATH_MAX ];
1920           sprintf ( buffer, "%s %s\n", MM_RUN, pnd_apps_exec_runline() );
1921           if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.live_on_run", 0 ) == 0 ) {
1922             emit_and_quit ( buffer );
1923           } else {
1924             emit_and_run ( buffer );
1925           }
1926         }
1927
1928       } else {
1929         // random bin file
1930
1931         // is it even executable? if we don't have handlers for non-executables yet (Jan 2011 we don't),
1932         // then don't even try to run things not-flagged as executable.. but wait most people are on
1933         // FAT filesystems, what a drag, we can't tell at the fs level.
1934         // ... but we can still invoke 'file' and grep out the good bits, at least.
1935         //
1936         // open a stream reading 'file /path/to/file' and check output for 'executable'
1937         // -- not checking for "ARM" so it can pick up x86 (or whatever native) executables in build environment
1938         unsigned char is_executable = 0;
1939
1940         // popen test
1941         {
1942           char popenbuf [ FILENAME_MAX ];
1943           snprintf ( popenbuf, FILENAME_MAX, "%s %s/%s", MIMETYPE_EXE, g_categories [ ui_category ] -> fspath, ui_selected -> ref -> title_en );
1944
1945           FILE *marceau;
1946           if ( ! ( marceau = popen ( popenbuf, "r" ) ) ) {
1947             return; // error, we need some useful error handling and dialog boxes here
1948           }
1949
1950           if ( fgets ( popenbuf, FILENAME_MAX, marceau ) ) {
1951             //printf ( "File test returns: %s\n", popenbuf );
1952             if ( strstr ( popenbuf, "executable" ) != NULL ) {
1953               is_executable = 1;
1954             }
1955           }
1956
1957           pclose ( marceau );
1958
1959         } // popen test
1960
1961         if ( ! is_executable ) {
1962           fprintf ( stderr, "ERROR: File to invoke is not executable, skipping. (%s)\n", ui_selected -> ref -> title_en );
1963           return; // need some error handling here
1964         }
1965
1966 #if 0 // eat up any pending SDL events and toss 'em?
1967         {
1968           SDL_PumpEvents();
1969           SDL_Event e;
1970           while ( SDL_PeepEvents ( &e, 1, SDL_GETEVENT, SDL_ALLEVENTS ) > 0 ) {
1971             // spin
1972           }
1973         }
1974 #endif
1975
1976 #if 1
1977         // just exec it
1978         //
1979
1980         // get CWD so we can restore it on return
1981         char cwd [ PATH_MAX ];
1982         getcwd ( cwd, PATH_MAX );
1983
1984         // full path to executable so we don't rely on implicit "./"
1985         char execbuf [ FILENAME_MAX ];
1986         snprintf ( execbuf, FILENAME_MAX, "%s/%s", g_categories [ ui_category ] -> fspath, ui_selected -> ref -> title_en );
1987
1988         // do it!
1989         chdir ( g_categories [ ui_category ] -> fspath );
1990         exec_raw_binary ( execbuf /*ui_selected -> ref -> title_en*/ );
1991         chdir ( cwd );
1992 #else
1993         // DEPRECATED / NOT TESTED
1994         // get mmwrapper to run it
1995         char buffer [ PATH_MAX ];
1996         sprintf ( buffer, "%s %s/%s\n", MM_RUN, g_categories [ ui_category ] -> fspath, ui_selected -> ref -> title_en );
1997         if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.live_on_run", 0 ) == 0 ) {
1998           emit_and_quit ( buffer );
1999         } else {
2000           emit_and_run ( buffer );
2001         }
2002 #endif
2003       } // pnd or bin?
2004
2005     } // dir or file?
2006
2007   } else {
2008
2009     // set app-run speed
2010     int use_run_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.use_run_speed", 0 );
2011     if ( use_run_speed > 0 ) {
2012       int mm_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.run_speed", -1 );
2013       if ( mm_speed > -1 ) {
2014         char buffer [ 512 ];
2015         snprintf ( buffer, 500, "sudo /usr/pandora/scripts/op_cpuspeed.sh %d", mm_speed );
2016         system ( buffer );
2017       }
2018     } // do speed change?
2019
2020     // request app to run and quit mmenu
2021     pnd_apps_exec_disco ( pnd_run_script, ui_selected -> ref, PND_EXEC_OPTION_NORUN, NULL );
2022     char buffer [ PATH_MAX ];
2023     sprintf ( buffer, "%s %s\n", MM_RUN, pnd_apps_exec_runline() );
2024     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.live_on_run", 0 ) == 0 ) {
2025       emit_and_quit ( buffer );
2026     } else {
2027       emit_and_run ( buffer );
2028     }
2029   }
2030
2031   return;
2032 }
2033
2034 void ui_push_ltrigger ( void ) {
2035   unsigned char oldcat = ui_category;
2036   unsigned int screen_width = ui_display_context.screen_width;
2037   unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
2038
2039   if ( g_categorycount == 0 ) {
2040     return;
2041   }
2042
2043   if ( g_icon_thread_busy ) {
2044     ui_stop_defered_icon_thread();
2045   }
2046
2047   if ( ui_category > 0 ) {
2048     ui_category--;
2049     category_fs_restock ( g_categories [ ui_category ] );
2050   } else {
2051     if ( pnd_conf_get_as_int_d ( g_conf, "tabs.wraparound", 0 ) > 0 ) {
2052       ui_category = g_categorycount - 1;
2053       ui_catshift = 0;
2054       if ( ui_category >= ( screen_width / tab_width ) ) {
2055         ui_catshift = ui_category - ( screen_width / tab_width ) + 1;
2056       }
2057       category_fs_restock ( g_categories [ ui_category ] );
2058     }
2059   }
2060
2061   if ( oldcat != ui_category ) {
2062     ui_selected = NULL;
2063     ui_set_selected ( ui_selected );
2064   }
2065
2066   // make tab visible?
2067   if ( ui_catshift > 0 && ui_category == ui_catshift - 1 ) {
2068     ui_catshift--;
2069   }
2070
2071   // unscroll
2072   ui_rows_scrolled_down = 0;
2073
2074   render_mask |= CHANGED_CATEGORY;
2075   ui_start_defered_icon_thread();
2076
2077   return;
2078 }
2079
2080 void ui_push_rtrigger ( void ) {
2081   unsigned char oldcat = ui_category;
2082
2083   if ( g_categorycount == 0 ) {
2084     return;
2085   }
2086
2087   if ( g_icon_thread_busy ) {
2088     ui_stop_defered_icon_thread();
2089   }
2090
2091   unsigned int screen_width = ui_display_context.screen_width;
2092   unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
2093
2094   if ( ui_category < ( g_categorycount - 1 ) ) {
2095     ui_category++;
2096     category_fs_restock ( g_categories [ ui_category ] );
2097   } else {
2098     if ( pnd_conf_get_as_int_d ( g_conf, "tabs.wraparound", 0 ) > 0 ) {
2099       ui_category = 0;
2100       ui_catshift = 0;
2101       category_fs_restock ( g_categories [ ui_category ] );
2102     }
2103   }
2104
2105   if ( oldcat != ui_category ) {
2106     ui_selected = NULL;
2107     ui_set_selected ( ui_selected );
2108   }
2109
2110   // make tab visible?
2111   if ( ui_category > ui_catshift + ( screen_width / tab_width ) - 1 ) {
2112     ui_catshift++;
2113   }
2114
2115   // unscroll
2116   ui_rows_scrolled_down = 0;
2117
2118   render_mask |= CHANGED_CATEGORY;
2119   ui_start_defered_icon_thread();
2120
2121   return;
2122 }
2123
2124 SDL_Surface *ui_scale_image ( SDL_Surface *s, unsigned int maxwidth, int maxheight ) {
2125   double scale = 1000000.0;
2126   double scalex = 1000000.0;
2127   double scaley = 1000000.0;
2128   SDL_Surface *scaled;
2129
2130   scalex = (double)maxwidth / (double)s -> w;
2131
2132   if ( maxheight == -1 ) {
2133     scale = scalex;
2134   } else {
2135     scaley = (double)maxheight / (double)s -> h;
2136
2137     if ( scaley < scalex ) {
2138       scale = scaley;
2139     } else {
2140       scale = scalex;
2141     }
2142
2143   }
2144
2145   scaled = rotozoomSurface ( s, 0 /* angle*/, scale /* scale */, 1 /* smooth==1*/ );
2146   SDL_FreeSurface ( s );
2147   s = scaled;
2148
2149   return ( s );
2150 }
2151
2152 void ui_loadscreen ( void ) {
2153
2154   SDL_Rect dest;
2155
2156   // clear the screen
2157   SDL_FillRect( SDL_GetVideoSurface(), NULL, 0 );
2158
2159   // render text
2160   SDL_Surface *rtext;
2161   rtext = TTF_RenderText_Blended ( g_big_font, "Setting up menu...", ui_display_context.fontcolor );
2162   dest.x = 20;
2163   dest.y = 20;
2164   SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, &dest );
2165   SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2166   SDL_FreeSurface ( rtext );
2167
2168   return;
2169 }
2170
2171 void ui_discoverscreen ( unsigned char clearscreen ) {
2172
2173   SDL_Rect dest;
2174
2175   // clear the screen
2176   if ( clearscreen ) {
2177     SDL_FillRect( SDL_GetVideoSurface(), NULL, 0 );
2178
2179     // render background
2180     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
2181       dest.x = 0;
2182       dest.y = 0;
2183       dest.w = sdl_realscreen -> w;
2184       dest.h = sdl_realscreen -> h;
2185       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, NULL /* whole image */, sdl_realscreen, NULL /* 0,0 */ );
2186       SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2187     }
2188
2189   }
2190
2191   // render text
2192   SDL_Surface *rtext;
2193   rtext = TTF_RenderText_Blended ( g_big_font, "Looking for applications...", ui_display_context.fontcolor );
2194   if ( clearscreen ) {
2195     dest.x = 20;
2196     dest.y = 20;
2197   } else {
2198     dest.x = 20;
2199     dest.y = 40;
2200   }
2201   SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, &dest );
2202   SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2203   SDL_FreeSurface ( rtext );
2204
2205   // render icon
2206   if ( g_imagecache [ IMG_ICON_MISSING ].i ) {
2207     dest.x = rtext -> w + 30;
2208     dest.y = 20;
2209     SDL_BlitSurface ( g_imagecache [ IMG_ICON_MISSING ].i, NULL, sdl_realscreen, &dest );
2210     SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2211   }
2212
2213   return;
2214 }
2215
2216 void ui_cachescreen ( unsigned char clearscreen, char *filename ) {
2217
2218   SDL_Rect rects [ 4 ];
2219   SDL_Rect *dest = rects;
2220   SDL_Rect src;
2221   bzero ( dest, sizeof(SDL_Rect)* 4 );
2222
2223   unsigned int font_rgba_r = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_r", 200 );
2224   unsigned int font_rgba_g = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_g", 200 );
2225   unsigned int font_rgba_b = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_b", 200 );
2226   unsigned int font_rgba_a = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_a", 100 );
2227
2228   static unsigned int stepx = 0;
2229
2230   // clear the screen
2231   if ( clearscreen ) {
2232     SDL_FillRect( SDL_GetVideoSurface(), NULL, 0 );
2233
2234     // render background
2235     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
2236       dest -> x = 0;
2237       dest -> y = 0;
2238       dest -> w = sdl_realscreen -> w;
2239       dest -> h = sdl_realscreen -> h;
2240       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, NULL /* whole image */, sdl_realscreen, NULL /* 0,0 */ );
2241       dest++;
2242     }
2243
2244   } else {
2245
2246     // render background
2247     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
2248       src.x = 0;
2249       src.y = 0;
2250       src.w = sdl_realscreen -> w;
2251       src.h = 100;
2252       dest -> x = 0;
2253       dest -> y = 0;
2254       dest -> w = sdl_realscreen -> w;
2255       dest -> h = sdl_realscreen -> h;
2256       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, &src, sdl_realscreen, dest );
2257       dest++;
2258     }
2259
2260   } // clear it
2261
2262   // render text
2263   SDL_Surface *rtext;
2264   SDL_Color tmpfontcolor = { font_rgba_r, font_rgba_g, font_rgba_b, font_rgba_a };
2265   rtext = TTF_RenderText_Blended ( g_big_font, "Caching applications artwork...", tmpfontcolor );
2266   dest -> x = 20;
2267   dest -> y = 20;
2268   SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2269   SDL_FreeSurface ( rtext );
2270   dest++;
2271
2272   // render icon
2273   if ( g_imagecache [ IMG_ICON_MISSING ].i ) {
2274     dest -> x = rtext -> w + 30 + stepx;
2275     dest -> y = 20;
2276     SDL_BlitSurface ( g_imagecache [ IMG_ICON_MISSING ].i, NULL, sdl_realscreen, dest );
2277     dest++;
2278   }
2279
2280   // filename
2281   if ( filename ) {
2282     rtext = TTF_RenderText_Blended ( g_tab_font, filename, tmpfontcolor );
2283     dest -> x = 20;
2284     dest -> y = 50;
2285     SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2286     SDL_FreeSurface ( rtext );
2287     dest++;
2288   }
2289
2290   // move across
2291   stepx += 20;
2292
2293   if ( stepx > 350 ) {
2294     stepx = 0;
2295   }
2296
2297   SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
2298
2299   return;
2300 }
2301
2302 int ui_selected_index ( void ) {
2303
2304   if ( ! ui_selected ) {
2305     return ( -1 ); // no index
2306   }
2307
2308   mm_appref_t *r = g_categories [ ui_category ] -> refs;
2309   int counter = 0;
2310   while ( r ) {
2311     if ( r == ui_selected ) {
2312       return ( counter );
2313     }
2314     r = r -> next;
2315     counter++;
2316   }
2317
2318   return ( -1 );
2319 }
2320
2321 static mm_appref_t *timer_ref = NULL;
2322 void ui_set_selected ( mm_appref_t *r ) {
2323
2324   render_mask |= CHANGED_SELECTION;
2325
2326   // preview pic stuff
2327   //
2328
2329   if ( ! pnd_conf_get_as_int_d ( g_conf, "minimenu.load_previews_later", 0 ) ) {
2330     return; // no desire to defer anything
2331   }
2332
2333   if ( ! r ) {
2334     // cancel timer
2335     SDL_SetTimer ( 0, NULL );
2336     timer_ref = NULL;
2337     return;
2338   }
2339
2340   SDL_SetTimer ( pnd_conf_get_as_int_d ( g_conf, "previewpic.defer_timer_ms", 1000 ), ui_callback_f );
2341   timer_ref = r;
2342
2343   return;
2344 }
2345
2346 unsigned int ui_callback_f ( unsigned int t ) {
2347
2348   if ( ui_selected != timer_ref ) {
2349     return ( 0 ); // user has moved it, who cares
2350   }
2351
2352   SDL_Event e;
2353   bzero ( &e, sizeof(SDL_Event) );
2354   e.type = SDL_USEREVENT;
2355   e.user.code = sdl_user_ticker;
2356   SDL_PushEvent ( &e );
2357
2358   return ( 0 );
2359 }
2360
2361 int ui_modal_single_menu ( char *argv[], unsigned int argc, char *title, char *footer ) {
2362   SDL_Rect rects [ 40 ];
2363   SDL_Rect *dest = rects;
2364   SDL_Rect src;
2365   SDL_Surface *rtext;
2366   unsigned char max_visible = pnd_conf_get_as_int_d ( g_conf, "detailtext.max_visible" , 11 );
2367   unsigned char first_visible = 0;
2368
2369   bzero ( rects, sizeof(SDL_Rect) * 40 );
2370
2371   unsigned int sel = 0;
2372
2373   SDL_Color selfontcolor = { 0/*font_rgba_r*/, ui_display_context.font_rgba_g, ui_display_context.font_rgba_b, ui_display_context.font_rgba_a };
2374
2375   unsigned int i;
2376   SDL_Event event;
2377
2378   while ( 1 ) {
2379
2380     // clear
2381     dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
2382     dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
2383     dest -> w = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> w;
2384     dest -> h = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h;
2385     SDL_FillRect( sdl_realscreen, dest, 0 );
2386
2387     // show dialog background
2388     if ( g_imagecache [ IMG_DETAIL_BG ].i ) {
2389       src.x = 0;
2390       src.y = 0;
2391       src.w = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> w;
2392       src.h = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> h;
2393       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
2394       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
2395       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
2396       // repeat for darken?
2397       //SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
2398       //SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
2399       //SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2400       dest++;
2401     }
2402
2403     // show dialog frame
2404     if ( g_imagecache [ IMG_DETAIL_PANEL ].i ) {
2405       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
2406       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
2407       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_PANEL ].i, NULL /* whole image */, sdl_realscreen, dest );
2408       //SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2409       dest++;
2410     }
2411
2412     // show header
2413     if ( title ) {
2414       rtext = TTF_RenderText_Blended ( g_tab_font, title, ui_display_context.fontcolor );
2415       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
2416       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 20;
2417       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2418       SDL_FreeSurface ( rtext );
2419       dest++;
2420     }
2421
2422     // show footer
2423     if ( footer ) {
2424       rtext = TTF_RenderText_Blended ( g_tab_font, footer, ui_display_context.fontcolor );
2425       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
2426       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) +
2427         ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h
2428         - 60;
2429       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2430       SDL_FreeSurface ( rtext );
2431       dest++;
2432     }
2433
2434     // show options
2435     for ( i = first_visible; i < first_visible + max_visible && i < argc; i++ ) {
2436
2437       // show options
2438       if ( sel == i ) {
2439         rtext = TTF_RenderText_Blended ( g_tab_font, argv [ i ], selfontcolor );
2440       } else {
2441         rtext = TTF_RenderText_Blended ( g_tab_font, argv [ i ], ui_display_context.fontcolor );
2442       }
2443       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
2444       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 40 + ( 20 * ( i + 1 - first_visible ) );
2445       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2446       SDL_FreeSurface ( rtext );
2447       dest++;
2448
2449     } // for
2450
2451     // update all the rects and send it all to sdl
2452     SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
2453     dest = rects;
2454
2455     // check for input
2456     while ( SDL_WaitEvent ( &event ) ) {
2457
2458       switch ( event.type ) {
2459
2460       //case SDL_KEYUP:
2461       case SDL_KEYDOWN:
2462
2463         if ( event.key.keysym.sym == SDLK_UP ) {
2464           if ( sel ) {
2465             sel--;
2466
2467             if ( sel < first_visible ) {
2468               first_visible--;
2469             }
2470
2471           }
2472         } else if ( event.key.keysym.sym == SDLK_DOWN ) {
2473
2474           if ( sel < argc - 1 ) {
2475             sel++;
2476
2477             // ensure visibility
2478             if ( sel >= first_visible + max_visible ) {
2479               first_visible++;
2480             }
2481
2482           }
2483
2484         } else if ( event.key.keysym.sym == SDLK_RETURN || event.key.keysym.sym == SDLK_END ) { // return, or "B"
2485           return ( sel );
2486
2487 #if 0
2488         } else if ( event.key.keysym.sym == SDLK_q ) {
2489           exit ( 0 );
2490 #endif
2491
2492         } else {
2493           return ( -1 ); // nada
2494         }
2495
2496         break;
2497
2498       } // switch
2499
2500       break;
2501     } // while
2502
2503   } // while
2504
2505   return ( -1 );
2506 }
2507
2508 unsigned char ui_determine_row ( mm_appref_t *a ) {
2509   unsigned int row = 0;
2510
2511   mm_appref_t *i = g_categories [ ui_category ] -> refs;
2512   while ( i != a ) {
2513     i = i -> next;
2514     row++;
2515   } // while
2516   row /= ui_display_context.col_max;
2517
2518   return ( row );
2519 }
2520
2521 unsigned char ui_determine_screen_row ( mm_appref_t *a ) {
2522   return ( ui_determine_row ( a ) % ui_display_context.row_max );
2523 }
2524
2525 unsigned char ui_determine_screen_col ( mm_appref_t *a ) {
2526   unsigned int col = 0;
2527
2528   mm_appref_t *i = g_categories [ ui_category ] -> refs;
2529   while ( i != a ) {
2530     i = i -> next;
2531     col++;
2532   } // while
2533   col %= ui_display_context.col_max;
2534
2535   return ( col );
2536 }
2537
2538 unsigned char ui_show_info ( char *pndrun, pnd_disco_t *p ) {
2539   char *viewer, *searchpath;
2540   pnd_conf_handle desktoph;
2541
2542   // viewer
2543   searchpath = pnd_conf_query_searchpath();
2544
2545   desktoph = pnd_conf_fetch_by_id ( pnd_conf_desktop, searchpath );
2546
2547   if ( ! desktoph ) {
2548     return ( 0 );
2549   }
2550
2551   viewer = pnd_conf_get_as_char ( desktoph, "info.viewer" );
2552
2553   if ( ! viewer ) {
2554     return ( 0 ); // no way to view the file
2555   }
2556
2557   // etc
2558   if ( ! p -> unique_id ) {
2559     return ( 0 );
2560   }
2561
2562   if ( ! p -> info_filename ) {
2563     return ( 0 );
2564   }
2565
2566   if ( ! p -> info_name ) {
2567     return ( 0 );
2568   }
2569
2570   if ( ! pndrun ) {
2571     return ( 0 );
2572   }
2573
2574   // exec line
2575   char args [ 1001 ];
2576   char *pargs = args;
2577   if ( pnd_conf_get_as_char ( desktoph, "info.viewer_args" ) ) {
2578     snprintf ( pargs, 1001, "%s %s",
2579                pnd_conf_get_as_char ( desktoph, "info.viewer_args" ), p -> info_filename );
2580   } else {
2581     pargs = NULL;
2582   }
2583
2584   char pndfile [ 1024 ];
2585   if ( p -> object_type == pnd_object_type_directory ) {
2586     // for PXML-app-dir, pnd_run.sh doesn't want the PXML.xml.. it just wants the dir-name
2587     strncpy ( pndfile, p -> object_path, 1000 );
2588   } else if ( p -> object_type == pnd_object_type_pnd ) {
2589     // pnd_run.sh wants the full path and filename for the .pnd file
2590     snprintf ( pndfile, 1020, "%s/%s", p -> object_path, p -> object_filename );
2591   }
2592
2593   if ( ! pnd_apps_exec ( pndrun, pndfile, p -> unique_id, viewer, p -> startdir, pargs,
2594                          p -> clockspeed ? atoi ( p -> clockspeed ) : 0, PND_EXEC_OPTION_NORUN ) )
2595   {
2596     return ( 0 );
2597   }
2598
2599   pnd_log ( pndn_debug, "Info Exec=%s\n", pnd_apps_exec_runline() );
2600
2601   // try running it
2602   int x;
2603   if ( ( x = fork() ) < 0 ) {
2604     pnd_log ( pndn_error, "ERROR: Couldn't fork()\n" );
2605     return ( 0 );
2606   }
2607
2608   if ( x == 0 ) {
2609     execl ( "/bin/sh", "/bin/sh", "-c", pnd_apps_exec_runline(), (char*)NULL );
2610     pnd_log ( pndn_error, "ERROR: Couldn't exec(%s)\n", pnd_apps_exec_runline() );
2611     return ( 0 );
2612   }
2613
2614   return ( 1 );
2615 }
2616
2617 typedef struct {
2618   SDL_Rect r;
2619   int catnum;
2620   mm_appref_t *ref;
2621 } ui_touch_t;
2622 #define MAXTOUCH 100
2623 ui_touch_t ui_touchrects [ MAXTOUCH ];
2624 unsigned char ui_touchrect_count = 0;
2625
2626 void ui_register_reset ( void ) {
2627   bzero ( ui_touchrects, sizeof(ui_touch_t)*MAXTOUCH );
2628   ui_touchrect_count = 0;
2629   return;
2630 }
2631
2632 void ui_register_tab ( unsigned char catnum, unsigned int x, unsigned int y, unsigned int w, unsigned int h ) {
2633
2634   if ( ui_touchrect_count == MAXTOUCH ) {
2635     return;
2636   }
2637
2638   ui_touchrects [ ui_touchrect_count ].r.x = x;
2639   ui_touchrects [ ui_touchrect_count ].r.y = y;
2640   ui_touchrects [ ui_touchrect_count ].r.w = w;
2641   ui_touchrects [ ui_touchrect_count ].r.h = h;
2642   ui_touchrects [ ui_touchrect_count ].catnum = catnum;
2643   ui_touchrect_count++;
2644
2645   return;
2646 }
2647
2648 void ui_register_app ( mm_appref_t *app, unsigned int x, unsigned int y, unsigned int w, unsigned int h ) {
2649
2650   if ( ui_touchrect_count == MAXTOUCH ) {
2651     return;
2652   }
2653
2654   ui_touchrects [ ui_touchrect_count ].r.x = x;
2655   ui_touchrects [ ui_touchrect_count ].r.y = y;
2656   ui_touchrects [ ui_touchrect_count ].r.w = w;
2657   ui_touchrects [ ui_touchrect_count ].r.h = h;
2658   ui_touchrects [ ui_touchrect_count ].ref = app;
2659   ui_touchrect_count++;
2660
2661   return;
2662 }
2663
2664 void ui_touch_act ( unsigned int x, unsigned int y ) {
2665
2666   unsigned char i;
2667   ui_touch_t *t;
2668
2669   for ( i = 0; i < ui_touchrect_count; i++ ) {
2670     t = &(ui_touchrects [ i ]);
2671
2672     if ( x >= t -> r.x &&
2673          x <= t -> r.x + t -> r.w &&
2674          y >= t -> r.y &&
2675          y <= t -> r.y + t -> r.h
2676        )
2677     {
2678
2679       if ( t -> ref ) {
2680         ui_selected = t -> ref;
2681         ui_push_exec();
2682       } else {
2683         if ( ui_category != t -> catnum ) {
2684           ui_selected = NULL;
2685         }
2686         ui_category = t -> catnum;
2687         render_mask |= CHANGED_CATEGORY;
2688         // rescan the dir
2689         category_fs_restock ( g_categories [ ui_category ] );
2690         ui_start_defered_icon_thread();
2691       }
2692
2693       break;
2694     }
2695
2696   } // for
2697
2698   return;
2699 }
2700
2701 unsigned char ui_forkexec ( char *argv[] ) {
2702   char *fooby = argv[0];
2703   int x;
2704
2705   if ( ( x = fork() ) < 0 ) {
2706     pnd_log ( pndn_error, "ERROR: Couldn't fork() for '%s'\n", fooby );
2707     return ( 0 );
2708   }
2709
2710   if ( x == 0 ) { // child
2711     execv ( fooby, argv );
2712     pnd_log ( pndn_error, "ERROR: Couldn't exec(%s)\n", fooby );
2713     return ( 0 );
2714   }
2715
2716   // parent, success
2717   return ( 1 );
2718 }
2719
2720 unsigned char ui_threaded_timer_create ( void ) {
2721
2722   g_timer_thread = SDL_CreateThread ( (void*)ui_threaded_timer, NULL );
2723
2724   if ( ! g_timer_thread ) {
2725     pnd_log ( pndn_error, "ERROR: Couldn't create timer thread\n" );
2726     return ( 0 );
2727   }
2728
2729   return ( 1 );
2730 }
2731
2732 int ui_threaded_timer ( pnd_disco_t *p ) {
2733
2734   // this timer's job is to ..
2735   // - do nothing for quite awhile
2736   // - on wake, post event to SDL event queue, so that main thread will check if SD insert/eject occurred
2737   // - goto 10
2738
2739   unsigned int delay_s = 2; // seconds
2740
2741   while ( 1 ) {
2742
2743     // pause...
2744     //sleep ( delay_s );
2745     SDL_Delay ( delay_s * 1000 );
2746
2747     // .. trigger SD check
2748     SDL_Event e;
2749     bzero ( &e, sizeof(SDL_Event) );
2750     e.type = SDL_USEREVENT;
2751     e.user.code = sdl_user_checksd;
2752     SDL_PushEvent ( &e );
2753
2754   } // while
2755
2756   return ( 0 );
2757 }
2758
2759 unsigned char ui_threaded_defered_preview ( pnd_disco_t *p ) {
2760
2761   if ( ! cache_preview ( p, pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 200 ),
2762                          pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 180 ) )
2763      )
2764   {
2765     pnd_log ( pndn_debug, "THREAD: Couldn't load preview pic: '%s' -> '%s'\n",
2766               IFNULL(p->title_en,"No Name"), p -> preview_pic1 );
2767   }
2768
2769   // trigger that we completed
2770   SDL_Event e;
2771   bzero ( &e, sizeof(SDL_Event) );
2772   e.type = SDL_USEREVENT;
2773   e.user.code = sdl_user_finishedpreview;
2774   e.user.data1 = p;
2775   SDL_PushEvent ( &e );
2776
2777   return ( 0 );
2778 }
2779
2780 void ui_post_scan ( void ) {
2781
2782   // reset view
2783   ui_selected = NULL;
2784   ui_rows_scrolled_down = 0;
2785   // set back to first tab, to be safe
2786   ui_category = 0;
2787   ui_catshift = 0;
2788
2789   // do we have a preferred category to jump to? or a last known one?
2790   char *dc = pnd_conf_get_as_char ( g_conf, "categories.default_cat" );
2791   char *lastcat = pnd_conf_get_as_char ( g_conf, "minimenu.last_known_catname" );
2792   if ( ( dc ) ||
2793        ( pnd_conf_get_as_int_d ( g_conf, "minimenu.start_selected", 0 ) && lastcat ) )
2794   {
2795     char *catpick = NULL;
2796
2797     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.start_selected", 0 ) && lastcat ) {
2798       catpick = lastcat;
2799
2800       // if this is a subcat, we have some doctoring to do :/ the hackishness is really
2801       // starting to show..
2802       if ( pnd_conf_get_as_char ( g_conf, "minimenu.last_known_parentcatname" ) ) {
2803         // in subcat view, we only have one cat
2804         ui_category = 0;
2805         ui_catshift = 0;
2806         // the cat name to search for is Child*Parent
2807         char key [ 512 ];
2808         sprintf ( key, "%s*%s",
2809                   pnd_conf_get_as_char ( g_conf, "minimenu.last_known_catname" )
2810                   , pnd_conf_get_as_char ( g_conf, "minimenu.last_known_parentcatname" ) );
2811         category_publish ( CFBYNAME, key );
2812         // since we forced it by hand, no need to do a cat-scan below
2813         catpick = NULL;
2814       }
2815
2816     } else if ( dc ) {
2817       catpick = dc;
2818     }
2819
2820     // attempt to find default cat; if we do find it, select it; otherwise
2821     // default behaviour will pick first cat (ie: usually All)
2822     if ( catpick ) {
2823       unsigned int i;
2824
2825       for ( i = 0; i < g_categorycount; i++ ) {
2826         if ( strcasecmp ( g_categories [ i ] -> catname, catpick ) == 0 ) {
2827           ui_category = i;
2828           // ensure visibility
2829           unsigned int screen_width = ui_display_context.screen_width;
2830           unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
2831           if ( ui_category > ui_catshift + ( screen_width / tab_width ) - 1 ) {
2832             ui_catshift = ui_category - ( screen_width / tab_width ) + 1;
2833           }
2834           break;
2835         }
2836       }
2837
2838       if ( i == g_categorycount ) {
2839         pnd_log ( pndn_warning, "  User defined default category or last known cat '%s' but not found, so using default behaviour\n", catpick );
2840       }
2841
2842     } // cat change?
2843
2844   } // default cat
2845
2846   // if we're sent right to a dirbrowser tab, restock it now (normally we restock on entry)
2847   if ( g_categories [ ui_category ] -> fspath ) {
2848     printf ( "Restock on start: '%s'\n", g_categories [ ui_category ] -> fspath );
2849     category_fs_restock ( g_categories [ ui_category ] );
2850   }
2851
2852   // redraw all
2853   render_mask |= CHANGED_EVERYTHING;
2854
2855   // if deferred icon load, kick off the thread now
2856   if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_icons_later", 0 ) == 1 ) {
2857     ui_start_defered_icon_thread();
2858   } // deferred icon load
2859
2860   return;
2861 }
2862
2863 unsigned char ui_threaded_defered_icon ( void *p ) {
2864   extern pnd_box_handle g_active_apps;
2865
2866   unsigned char maxwidth, maxheight;
2867   maxwidth = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_width", 50 );
2868   maxheight = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_height", 50 );
2869
2870   pnd_disco_t *iter;
2871
2872   g_icon_thread_busy = 1;
2873
2874   // work at it in order within current category
2875
2876   mm_appref_t *refiter = g_categories [ ui_category ] -> refs;
2877   while ( refiter && ! g_icon_thread_stop ) {
2878     iter = refiter -> ref;
2879
2880     // has an icon that is not already cached?
2881     if ( ( iter -> pnd_icon_pos ) ||
2882          ( iter -> icon && iter -> object_flags & PND_DISCO_CUSTOM1 )
2883        )
2884     {
2885
2886       // try to cache it?
2887       if ( ! cache_icon ( iter, maxwidth, maxheight ) ) {
2888         //pnd_log ( pndn_warning, "  Couldn't load icon: '%s'\n", IFNULL(iter->title_en,"No Name") );
2889
2890       } else {
2891
2892         // trigger that we completed
2893         SDL_Event e;
2894         bzero ( &e, sizeof(SDL_Event) );
2895         e.type = SDL_USEREVENT;
2896         e.user.code = sdl_user_finishedicon;
2897         SDL_PushEvent ( &e );
2898
2899         //pnd_log ( pndn_warning, "  Finished deferred load icon: '%s'\n", IFNULL(iter->title_en,"No Name") );
2900         //usleep ( pnd_conf_get_as_int_d ( g_conf, "minimenu.defer_icon_us", 50000 ) );
2901
2902       }
2903
2904       // avoid churn
2905       iter -> pnd_icon_pos = 0;
2906       if ( iter -> icon ) {
2907         free ( iter -> icon );
2908         iter -> icon = NULL;
2909       }
2910
2911       // let user do something..
2912       SDL_Delay ( 200 );
2913
2914     } // has icon
2915
2916     refiter = refiter -> next;
2917   }
2918
2919   // mark as done
2920   g_icon_thread_busy = 0;
2921
2922   return ( 0 );
2923 }
2924
2925 void ui_show_hourglass ( unsigned char updaterect ) {
2926
2927   SDL_Rect dest;
2928   SDL_Surface *s = g_imagecache [ IMG_HOURGLASS ].i;
2929
2930   dest.x = ( 800 - s -> w ) / 2;
2931   dest.y = ( 480 - s -> h ) / 2;
2932
2933   SDL_BlitSurface ( s, NULL /* whole image */, sdl_realscreen, &dest );
2934
2935   if ( updaterect ) {
2936     SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2937   }
2938
2939   return;
2940 }
2941
2942 unsigned char ui_pick_skin ( void ) {
2943 #define MAXSKINS 10
2944   char *skins [ MAXSKINS ];
2945   unsigned char iter;
2946
2947   char *searchpath = pnd_conf_get_as_char ( g_conf, "minimenu.skin_searchpath" );
2948   char tempname [ 100 ];
2949
2950   iter = 0;
2951
2952   skins [ iter++ ] = "No skin change";
2953
2954   SEARCHPATH_PRE
2955   {
2956     DIR *d = opendir ( buffer );
2957
2958     if ( d ) {
2959       struct dirent *dd;
2960
2961       while ( ( dd = readdir ( d ) ) ) {
2962
2963         if ( dd -> d_name [ 0 ] == '.' ) {
2964           // ignore
2965         } else if ( ( dd -> d_type == DT_DIR || dd -> d_type == DT_UNKNOWN ) &&
2966                     iter < MAXSKINS )
2967         {
2968           snprintf ( tempname, 100, "Skin: %s", dd -> d_name );
2969           skins [ iter++ ] = strdup ( tempname );
2970         }
2971
2972       }
2973
2974       closedir ( d );
2975     }
2976
2977   }
2978   SEARCHPATH_POST
2979
2980   int sel = ui_modal_single_menu ( skins, iter, "Skins", "Enter to select; other to return." );
2981
2982   // did they pick one?
2983   if ( sel > 0 ) {
2984     FILE *f;
2985
2986     char *s = strdup ( pnd_conf_get_as_char ( g_conf, "minimenu.skin_selected" ) );
2987     s = pnd_expand_tilde ( s );
2988
2989     f = fopen ( s, "w" );
2990
2991     free ( s );
2992
2993     if ( f ) {
2994       fprintf ( f, "%s\n", skins [ sel ] + 6 );
2995       fclose ( f );
2996     }
2997
2998     return ( 1 );
2999   }
3000
3001   return ( 0 );
3002 }
3003
3004 void ui_aboutscreen ( char *textpath ) {
3005 #define PIXELW 7
3006 #define PIXELH 7
3007 #define MARGINW 3
3008 #define MARGINH 3
3009 #define SCRW 800
3010 #define SCRH 480
3011 #define ROWS SCRH / ( PIXELH + MARGINH )
3012 #define COLS SCRW / ( PIXELW + MARGINW )
3013
3014   unsigned char pixelboard [ ROWS * COLS ]; // pixel heat
3015   bzero ( pixelboard, ROWS * COLS );
3016
3017   SDL_Surface *rtext;
3018   SDL_Rect r;
3019
3020   SDL_Color rtextc = { 200, 200, 200, 100 };
3021
3022   // pixel scroller
3023   char *textloop [ 500 ];
3024   unsigned int textmax = 0;
3025   bzero ( textloop, 500 * sizeof(char*) );
3026
3027   // cursor scroller
3028   char cbuffer [ 50000 ];
3029   bzero ( cbuffer, 50000 );
3030   unsigned int crevealed = 0;
3031
3032   FILE *f = fopen ( textpath, "r" );
3033
3034   if ( ! f ) {
3035     pnd_log ( pndn_error, "ERROR: Couldn't open about text: %s\n", textpath );
3036     return;
3037   }
3038
3039   char textbuf [ 100 ];
3040   while ( fgets ( textbuf, 100, f ) ) {
3041
3042     // add to full buffer
3043     strncat ( cbuffer, textbuf, 50000 );
3044
3045     // chomp
3046     if ( strchr ( textbuf, '\n' ) ) {
3047       * strchr ( textbuf, '\n' ) = '\0';
3048     }
3049
3050     // add to pixel loop
3051     if ( 1||textbuf [ 0 ] ) {
3052       textloop [ textmax ] = strdup ( textbuf );
3053       textmax++;
3054     }
3055
3056   } // while fgets
3057
3058   fclose ( f );
3059
3060   unsigned int textiter = 0;
3061   while ( textiter < textmax ) {
3062     char *text = textloop [ textiter ];
3063
3064     rtext = NULL;
3065     if ( text [ 0 ] ) {
3066       // render to surface
3067       rtext = TTF_RenderText_Blended ( g_grid_font, text, rtextc );
3068
3069       // render font to pixelboard
3070       unsigned int px, py;
3071       unsigned char *ph;
3072       unsigned int *pixels = rtext -> pixels;
3073       unsigned char cr, cg, cb, ca;
3074       for ( py = 0; py < rtext -> h; py ++ ) {
3075         for ( px = 0; px < ( rtext -> w > COLS ? COLS : rtext -> w ); px++ ) {
3076
3077           SDL_GetRGBA ( pixels [ ( py * rtext -> pitch / 4 ) + px ],
3078                         rtext -> format, &cr, &cg, &cb, &ca );
3079
3080           if ( ca != 0 ) {
3081
3082             ph = pixelboard + ( /*y offset */ 30 * COLS ) + ( py * COLS ) + px /* / 2 */;
3083
3084             if ( *ph < 100 ) {
3085               *ph = 100;
3086             }
3087
3088             ca /= 5;
3089             if ( *ph + ca < 250 ) {
3090               *ph += ca;
3091             }
3092
3093           } // got a pixel?
3094
3095         } // x
3096       } // y
3097
3098     } // got text?
3099
3100     unsigned int runcount = 10;
3101     while ( runcount-- ) {
3102
3103       // clear display
3104       SDL_FillRect( sdl_realscreen, NULL /* whole */, 0 );
3105
3106       // render pixelboard
3107       unsigned int x, y;
3108       unsigned int c;
3109       for ( y = 0; y < ROWS; y++ ) {
3110         for ( x = 0; x < COLS; x++ ) {
3111
3112           if ( 1||pixelboard [ ( y * COLS ) + x ] ) {
3113
3114             // position
3115             r.x = x * ( PIXELW + MARGINW );
3116             r.y = y * ( PIXELH + MARGINH );
3117             r.w = PIXELW;
3118             r.h = PIXELH;
3119             // heat -> colour
3120             c = SDL_MapRGB ( sdl_realscreen -> format, 100 /* r */, 0 /* g */, pixelboard [ ( y * COLS ) + x ] );
3121             // render
3122             SDL_FillRect( sdl_realscreen, &r /* whole */, c );
3123
3124           }
3125
3126         } // x
3127       } // y
3128
3129       // cool pixels
3130       unsigned char *pc = pixelboard;
3131       for ( y = 0; y < ROWS; y++ ) {
3132         for ( x = 0; x < COLS; x++ ) {
3133
3134           if ( *pc > 10 ) {
3135             (*pc) -= 3;
3136           }
3137
3138           pc++;
3139         } // x
3140       } // y
3141
3142       // slide pixels upwards
3143       memmove ( pixelboard, pixelboard + COLS, ( COLS * ROWS ) - COLS );
3144
3145       // render actual readable text
3146       {
3147
3148         // display up to cursor
3149         SDL_Rect dest;
3150         unsigned int cdraw = 0;
3151         SDL_Surface *cs;
3152         char ctb [ 2 ];
3153
3154         if ( crevealed > 200 ) {
3155           cdraw = crevealed - 200;
3156         }
3157
3158         dest.x = 400;
3159         dest.y = 20;
3160
3161         for ( ; cdraw < crevealed; cdraw++ ) {
3162           ctb [ 0 ] = cbuffer [ cdraw ];
3163           ctb [ 1 ] = '\0';
3164           // move over or down
3165           if ( cbuffer [ cdraw ] == '\n' ) {
3166             // EOL
3167             dest.x = 400;
3168             dest.y += 14;
3169
3170             if ( dest.y > 450 ) {
3171               dest.y = 450;
3172             }
3173
3174           } else {
3175             // draw the char
3176             cs = TTF_RenderText_Blended ( g_tab_font, ctb, rtextc );
3177             if ( cs ) {
3178               SDL_BlitSurface ( cs, NULL /* all */, sdl_realscreen, &dest );
3179               SDL_FreeSurface ( cs );
3180               // over
3181               dest.x += cs -> w;
3182             }
3183           }
3184
3185         }
3186
3187         dest.w = 10;
3188         dest.h = 20;
3189         SDL_FillRect ( sdl_realscreen, &dest /* whole */, 220 );
3190
3191         // increment cursor to next character
3192         if ( cbuffer [ crevealed ] != '\0' ) {
3193           crevealed++;
3194         }
3195
3196       } // draw cursor text
3197
3198       // reveal
3199       //
3200       SDL_UpdateRect ( sdl_realscreen, 0, 0, 0, 0 ); // whole screen
3201
3202       usleep ( 50000 );
3203
3204       // any button? if so, about
3205       {
3206         SDL_PumpEvents();
3207
3208         SDL_Event e;
3209
3210         if ( SDL_PeepEvents ( &e, 1, SDL_GETEVENT, SDL_EVENTMASK(/*SDL_KEYUP|*/SDL_KEYDOWN) ) > 0 ) {
3211           return;
3212         }
3213
3214       }
3215
3216     } // while cooling
3217
3218     if ( rtext ) {
3219       SDL_FreeSurface ( rtext );
3220     }
3221
3222     textiter++;
3223   } // while more text
3224
3225   // free up
3226   unsigned int i;
3227   for ( i = 0; i < textmax; i++ ) {
3228     if ( textloop [ i ] ) {
3229       free ( textloop [ i ] );
3230       textloop [ i ] = 0;
3231     }
3232   }
3233
3234   return;
3235 }
3236
3237 void ui_revealscreen ( void ) {
3238   char *labels [ 500 ];
3239   unsigned int labelmax = 0;
3240   unsigned int i;
3241   char fulllabel [ 200 ];
3242
3243   if ( ! category_count ( CFHIDDEN ) ) {
3244     return; // nothing to do
3245   }
3246
3247   // switch to hidden categories
3248   category_publish ( CFHIDDEN, NULL );
3249
3250   // build up labels to show in menu
3251   for ( i = 0; i < g_categorycount; i++ ) {
3252
3253     if ( g_categories [ i ] -> parent_catname ) {
3254       sprintf ( fulllabel, "%s [%s]", g_categories [ i ] -> catname, g_categories [ i ] -> parent_catname );
3255     } else {
3256       sprintf ( fulllabel, "%s", g_categories [ i ] -> catname );
3257     }
3258
3259     labels [ labelmax++ ] = strdup ( fulllabel );
3260   }
3261
3262   // show menu
3263   int sel = ui_modal_single_menu ( labels, labelmax, "Temporary Category Reveal",
3264                                    "Enter to select; other to return." );
3265
3266   // if selected, try to set this guy to visible
3267   if ( sel >= 0 ) {
3268
3269     // fix up category name, if its been hacked
3270 #if 0 // prepending and .. wtf crap is this
3271     if ( strchr ( g_categories [ sel ] -> catname, '.' ) ) {
3272       char *t = g_categories [ sel ] -> catname;
3273       g_categories [ sel ] -> catname = strdup ( strchr ( g_categories [ sel ] -> catname, '.' ) + 1 );
3274       free ( t );
3275     }
3276 #endif
3277
3278     // reflag this guy to be visible
3279     g_categories [ sel ] -> catflags = CFNORMAL;
3280
3281     // switch to the new category.. cache name.
3282     char *switch_to_name = g_categories [ sel ] -> catname;
3283
3284     // republish categories
3285     category_publish ( CFNORMAL, NULL );
3286
3287     // switch to the new category.. with the cached name!
3288     ui_category = category_index ( switch_to_name );
3289
3290     // ensure visibility
3291     unsigned int screen_width = ui_display_context.screen_width;
3292     unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
3293     if ( ui_category > ui_catshift + ( screen_width / tab_width ) - 1 ) {
3294       ui_catshift = ui_category - ( screen_width / tab_width ) + 1;
3295     }
3296
3297   }
3298
3299   // republish categories
3300   category_publish ( CFNORMAL, NULL );
3301
3302   // redraw tabs
3303   render_mask |= CHANGED_CATEGORY;
3304   ui_start_defered_icon_thread();
3305
3306   return;
3307 }
3308
3309 void ui_recache_context ( ui_context_t *c ) {
3310
3311   c -> screen_width = pnd_conf_get_as_int_d ( g_conf, "display.screen_width", 800 );
3312
3313   c -> font_rgba_r = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_r", 200 );
3314   c -> font_rgba_g = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_g", 200 );
3315   c -> font_rgba_b = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_b", 200 );
3316   c -> font_rgba_a = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_a", 100 );
3317
3318   c -> grid_offset_x = pnd_conf_get_as_int ( g_conf, "grid.grid_offset_x" );
3319   c -> grid_offset_y = pnd_conf_get_as_int ( g_conf, "grid.grid_offset_y" );
3320
3321   c -> icon_offset_x = pnd_conf_get_as_int ( g_conf, "grid.icon_offset_x" );
3322   c -> icon_offset_y = pnd_conf_get_as_int ( g_conf, "grid.icon_offset_y" );
3323   c -> icon_max_width = pnd_conf_get_as_int ( g_conf, "grid.icon_max_width" );
3324   c -> icon_max_height = pnd_conf_get_as_int ( g_conf, "grid.icon_max_height" );
3325   c -> sel_icon_offset_x = pnd_conf_get_as_int_d ( g_conf, "grid.sel_offoffset_x", 0 );
3326   c -> sel_icon_offset_y = pnd_conf_get_as_int_d ( g_conf, "grid.sel_offoffset_y", 0 );
3327
3328   c -> text_width = pnd_conf_get_as_int ( g_conf, "grid.text_width" );
3329   c -> text_clip_x = pnd_conf_get_as_int ( g_conf, "grid.text_clip_x" );
3330   c -> text_offset_x = pnd_conf_get_as_int ( g_conf, "grid.text_offset_x" );
3331   c -> text_offset_y = pnd_conf_get_as_int ( g_conf, "grid.text_offset_y" );
3332   c -> text_hilite_offset_y = pnd_conf_get_as_int ( g_conf, "grid.text_hilite_offset_y" );
3333
3334   c -> row_max = pnd_conf_get_as_int_d ( g_conf, "grid.row_max", 4 );
3335   c -> col_max = pnd_conf_get_as_int_d ( g_conf, "grid.col_max", 5 );
3336
3337   c -> cell_width = pnd_conf_get_as_int ( g_conf, "grid.cell_width" );
3338   c -> cell_height = pnd_conf_get_as_int ( g_conf, "grid.cell_height" );
3339
3340   c -> arrow_bar_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_x", 450 );
3341   c -> arrow_bar_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_y", 100 );
3342   c -> arrow_bar_clip_w = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_clip_w", 10 );
3343   c -> arrow_bar_clip_h = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_clip_h", 100 );
3344   c -> arrow_up_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_up_x", 450 );
3345   c -> arrow_up_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_up_y", 80 );
3346   c -> arrow_down_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_down_x", 450 );
3347   c -> arrow_down_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_down_y", 80 );
3348
3349   // font colour
3350   SDL_Color tmp = { c -> font_rgba_r, c -> font_rgba_g, c -> font_rgba_b, c -> font_rgba_a };
3351   c -> fontcolor = tmp;
3352
3353   // now that we've got 'normal' (detail pane shown) param's, lets check if detail pane
3354   // is hidden; if so, override some values with those alternate skin values where possible.
3355   if ( ui_detail_hidden ) {
3356     // if detail panel is hidden, and theme cannot support it, unhide the bloody thing. (This may help
3357     // when someone is amid theme hacking or changing.)
3358     if ( ! ui_is_detail_hideable() ) {
3359       ui_detail_hidden = 0;
3360     }
3361
3362     // still hidden?
3363     if ( ui_detail_hidden ) {
3364
3365       c -> row_max = pnd_conf_get_as_int_d ( g_conf, "grid.row_max_w", c -> row_max );
3366       c -> col_max = pnd_conf_get_as_int_d ( g_conf, "grid.col_max_w", c -> col_max );
3367
3368       c -> cell_width = pnd_conf_get_as_int_d ( g_conf, "grid.cell_width_w", c -> cell_width );
3369       c -> cell_height = pnd_conf_get_as_int_d ( g_conf, "grid.cell_height_w", c -> cell_height );
3370
3371       c -> arrow_bar_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_x_w", 450 );
3372       c -> arrow_bar_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_y_w", 100 );
3373       c -> arrow_up_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_up_x_w", 450 );
3374       c -> arrow_up_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_up_y_w", 80 );
3375       c -> arrow_down_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_down_x_w", 450 );
3376       c -> arrow_down_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_down_y_w", 80 );
3377
3378     } // if detail hidden.. still.
3379
3380   } // if detail hidden
3381
3382   return;
3383 }
3384
3385 unsigned char ui_is_detail_hideable ( void ) {
3386
3387   // if skin has a bit of info for wide-mode, we assume wide-mode is available
3388   if ( pnd_conf_get_as_char ( g_conf, "grid.row_max_w" ) != NULL ) {
3389     return ( 1 );
3390   }
3391
3392   // else not!
3393   return ( 0 );
3394 }
3395
3396 void ui_toggle_detail_pane ( void ) {
3397
3398   // no bitmask trickery here; I like it to be stand-out obvious at 3am.
3399
3400   if ( ui_detail_hidden ) {
3401     ui_detail_hidden = 0;
3402   } else {
3403     ui_detail_hidden = 1;
3404   }
3405
3406   // repull skin config
3407   ui_recache_context ( &ui_display_context );
3408
3409   // redraw
3410   render_mask |= CHANGED_EVERYTHING;
3411
3412   return;
3413 }
3414
3415 void ui_menu_context ( mm_appref_t *a ) {
3416
3417   unsigned char rescan_apps = 0;
3418   unsigned char context_alive = 1;
3419
3420   enum {
3421     context_done = 0,
3422     context_file_info,
3423     context_file_delete,
3424     context_app_info,
3425     context_app_hide,
3426     context_app_recategorize,
3427     context_app_recategorize_sub,
3428     context_app_rename,
3429     context_app_cpuspeed,
3430     context_app_run,
3431     context_app_notes1,
3432     context_app_notes2,
3433     context_app_notes3,
3434     context_menu_max
3435   };
3436
3437   char *verbiage[] = {
3438     "Done (return to grid)",      // context_done
3439     "Get info about file/dir",    // context_file_info
3440     "Delete file/dir",            // context_file_delete
3441     "Get info",                   // context_app_info
3442     "Hide application",           //             hide
3443     "Recategorize",               //             recategorize
3444     "Recategorize subcategory",   //             recategorize
3445     "Change displayed title",     //             rename
3446     "Set CPU speed for launch",   //             cpuspeed
3447     "Run application",            //             run
3448     "Edit notes line 1",          //             notes1
3449     "Edit notes line 2",          //             notes2
3450     "Edit notes line 3",          //             notes3
3451   };
3452
3453   unsigned short int menu [ context_menu_max ];
3454   char *menustring [ context_menu_max ];
3455   unsigned char menumax = 0;
3456
3457   // ++ done
3458   menu [ menumax ] = context_done; menustring [ menumax++ ] = verbiage [ context_done ];
3459
3460   // hook up appropriate menu options based on tab-type and object-type
3461   if ( g_categories [ ui_category ] -> fspath ) {
3462     return; // TBD
3463     menu [ menumax ] = context_file_info; menustring [ menumax++ ] = verbiage [ context_file_info ];
3464     menu [ menumax ] = context_file_delete; menustring [ menumax++ ] = verbiage [ context_file_delete ];
3465   } else {
3466
3467     if ( a -> ref -> object_type == pnd_object_type_directory ) {
3468       return; // don't do anything if the guy is a subcat-as-folder
3469     }
3470
3471     //menu [ menumax ] = context_app_info; menustring [ menumax++ ] = verbiage [ context_app_info ];
3472     menu [ menumax ] = context_app_run; menustring [ menumax++ ] = verbiage [ context_app_run ];
3473     menu [ menumax ] = context_app_hide; menustring [ menumax++ ] = verbiage [ context_app_hide ];
3474     menu [ menumax ] = context_app_recategorize; menustring [ menumax++ ] = verbiage [ context_app_recategorize ];
3475     menu [ menumax ] = context_app_recategorize_sub; menustring [ menumax++ ] = verbiage [ context_app_recategorize_sub ];
3476     menu [ menumax ] = context_app_rename; menustring [ menumax++ ] = verbiage [ context_app_rename ];
3477     menu [ menumax ] = context_app_cpuspeed; menustring [ menumax++ ] = verbiage [ context_app_cpuspeed ];
3478     menu [ menumax ] = context_app_notes1; menustring [ menumax++ ] = verbiage [ context_app_notes1 ];
3479     menu [ menumax ] = context_app_notes2; menustring [ menumax++ ] = verbiage [ context_app_notes2 ];
3480     menu [ menumax ] = context_app_notes3; menustring [ menumax++ ] = verbiage [ context_app_notes3 ];
3481   }
3482
3483   // operate the menu
3484   while ( context_alive ) {
3485
3486     int sel = ui_modal_single_menu ( menustring, menumax, a -> ref -> title_en ? a -> ref -> title_en : "Quickpick Menu" /* title */, "B or Enter; other to cancel." /* footer */ );
3487
3488     if ( sel < 0 ) {
3489       context_alive = 0;
3490
3491     } else {
3492
3493       switch ( menu [ sel ] ) {
3494
3495       case context_done:
3496         context_alive = 0;
3497         break;
3498
3499       case context_file_info:
3500         break;
3501
3502       case context_file_delete:
3503         //ui_menu_twoby ( "Delete - Are you sure?", "B/enter; other to cancel", "Delete", "Do not delete" );
3504         break;
3505
3506       case context_app_info:
3507         break;
3508
3509       case context_app_hide:
3510         {
3511           // determine key
3512           char confkey [ 1000 ];
3513           snprintf ( confkey, 999, "%s.%s", "appshow", a -> ref -> unique_id );
3514
3515           // turn app 'off'
3516           pnd_conf_set_char ( g_conf, confkey, "0" );
3517
3518           // write conf, so it will take next time
3519           conf_write ( g_conf, conf_determine_location ( g_conf ) );
3520           conf_write ( g_conf, CONF_PREF_TEMPPATH );
3521
3522           // can we just 'hide' this guy without reloading all apps? (this is for you, EvilDragon)
3523           if ( 0 ) {
3524             //
3525             // DOESN'T WORK YET; other parts of app are still hanging onto some values and blow up
3526             //
3527             char *uid = strdup ( a -> ref -> unique_id );
3528             unsigned int i;
3529             for ( i = 0; i < g_categorycount; i++ ) {
3530               mm_appref_t *p = g_categories [ i ] -> refs;
3531               mm_appref_t *n;
3532               while ( p ) {
3533                 n = p -> next;
3534
3535                 if ( strcmp ( p -> ref -> unique_id, uid ) == 0 ) {
3536                   free ( p );
3537                   if ( g_categories [ i ] -> refcount ) {
3538                     g_categories [ i ] -> refcount--;
3539                   }
3540                 }
3541
3542                 p = n;
3543               } // while for each appref
3544             } // for each cat/tab
3545
3546             free ( uid );
3547
3548           } else {
3549             // request rescan and wrap up
3550             rescan_apps++;
3551           }
3552
3553           context_alive = 0; // nolonger visible, so lets just get out
3554
3555         }
3556
3557         break;
3558
3559       case context_app_recategorize:
3560         {
3561           char *opts [ 250 ];
3562           unsigned char optmax = 0;
3563           unsigned char i;
3564
3565           // show custom categories
3566           if ( mmcustom_setup() ) {
3567
3568             for ( i = 0; i < mmcustom_count; i++ ) {
3569               if ( mmcustom_complete [ i ].parent_cat == NULL ) {
3570                 opts [ optmax++ ] = mmcustom_complete [ i ].cat;
3571               }
3572             }
3573
3574           }
3575
3576           // show FD categories
3577           i = 2; // skip first two - Other and NoParentCategory
3578           while ( 1 ) {
3579
3580             if ( ! freedesktop_complete [ i ].cat ) {
3581               break;
3582             }
3583
3584             if ( ! freedesktop_complete [ i ].parent_cat ) {
3585               opts [ optmax++ ] = freedesktop_complete [ i ].cat;
3586             }
3587
3588             i++;
3589           } // while
3590
3591           // picker
3592           char prompt [ 101 ];
3593           snprintf ( prompt, 100, "Pick category [%s]", a -> ref -> main_category ? a -> ref -> main_category : "NoParentCategory" );
3594
3595           int sel = ui_modal_single_menu ( opts, optmax, prompt /*"Select parent category"*/, "Enter to select; other to skip." );
3596
3597           if ( sel >= 0 ) {
3598             char confirm [ 1001 ];
3599             snprintf ( confirm, 1000, "Confirm: %s", opts [ sel ] );
3600
3601             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm categorization", "Do not set category" ) == 1 ) {
3602               ovr_replace_or_add ( a, "maincategory", opts [ sel ] );
3603               rescan_apps++;
3604               // when changing main cat, reset subcat, otherwise you go from Game/Emu to Network/Emu and get sent to Other right away
3605               ovr_replace_or_add ( a, "maincategorysub1", freedesktop_complete [ 2 ].cat );
3606             }
3607
3608           }
3609
3610           if ( mmcustom_is_ready() ) {
3611             mmcustom_shutdown();
3612           }
3613
3614         }
3615         break;
3616
3617       case context_app_recategorize_sub:
3618         {
3619           char *opts [ 250 ];
3620           unsigned char optmax = 0;
3621           unsigned char i = 0;
3622
3623           char *whichparentarewe;
3624           if ( g_categories [ ui_category ] -> parent_catname ) {
3625             whichparentarewe = g_categories [ ui_category ] -> parent_catname;
3626           } else {
3627             whichparentarewe = g_categories [ ui_category ] -> catname;
3628           }
3629
3630           // add NoSubcategory magic one
3631           opts [ optmax++ ] = freedesktop_complete [ 2 ].cat;
3632
3633           // add custom categories
3634           if ( mmcustom_setup() ) {
3635
3636             for ( i = 0; i < mmcustom_count; i++ ) {
3637               if ( mmcustom_complete [ i ].parent_cat && strcmp ( mmcustom_complete [ i ].parent_cat, whichparentarewe ) == 0  ) {
3638                 opts [ optmax++ ] = mmcustom_complete [ i ].cat;
3639               }
3640             }
3641
3642           }
3643
3644           // add FD categories
3645           while ( 1 ) {
3646
3647             if ( ! freedesktop_complete [ i ].cat ) {
3648               break;
3649             }
3650
3651             if ( ( freedesktop_complete [ i ].parent_cat ) &&
3652                  ( strcasecmp ( freedesktop_complete [ i ].parent_cat, whichparentarewe ) == 0 )
3653                )
3654             {
3655               opts [ optmax++ ] = freedesktop_complete [ i ].cat;
3656             }
3657
3658             i++;
3659           } // while
3660
3661           char prompt [ 101 ];
3662           //snprintf ( prompt, 100, "Currently: %s", a -> ref -> main_category1 ? a -> ref -> main_category1 : "NoSubcategory" );
3663           snprintf ( prompt, 100, "%s [%s]", a -> ref -> main_category1 ? a -> ref -> main_category1 : "NoSubcategory", whichparentarewe );
3664
3665           int sel = ui_modal_single_menu ( opts, optmax, prompt /*"Select subcategory"*/, "Enter to select; other to skip." );
3666
3667           if ( sel >= 0 ) {
3668             char confirm [ 1001 ];
3669             snprintf ( confirm, 1000, "Confirm: %s", opts [ sel ] );
3670
3671             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm sub-categorization", "Do not set sub-category" ) == 1 ) {
3672               ovr_replace_or_add ( a, "maincategorysub1", opts [ sel ] );
3673               rescan_apps++;
3674             }
3675
3676           }
3677
3678           if ( mmcustom_is_ready() ) {
3679             mmcustom_shutdown();
3680           }
3681
3682         }
3683         break;
3684
3685       case context_app_rename:
3686         {
3687           char namebuf [ 101 ];
3688           unsigned char changed;
3689
3690           changed = ui_menu_get_text_line ( "Rename application", "Use keyboard; Enter when done.",
3691                                             a -> ref -> title_en ? a -> ref -> title_en : "blank", namebuf, 30, 0 /* alphanumeric */ );
3692
3693           if ( changed ) {
3694             char confirm [ 1001 ];
3695             snprintf ( confirm, 1000, "Confirm: %s", namebuf );
3696
3697             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm rename", "Do not rename" ) == 1 ) {
3698               ovr_replace_or_add ( a, "title", namebuf );
3699               rescan_apps++;
3700             }
3701
3702           }
3703
3704         }
3705
3706         break;
3707
3708       case context_app_cpuspeed:
3709         {
3710           char namebuf [ 101 ];
3711           unsigned char changed;
3712
3713           changed = ui_menu_get_text_line ( "Specify runspeed", "Use keyboard; Enter when done.",
3714                                             a -> ref -> clockspeed ? a -> ref -> clockspeed : "500", namebuf, 6, 1 /* numeric */ );
3715
3716           if ( changed ) {
3717             char confirm [ 1001 ];
3718             snprintf ( confirm, 1000, "Confirm: %s", namebuf );
3719
3720             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm clockspeed", "Do not set" ) == 1 ) {
3721               ovr_replace_or_add ( a, "clockspeed", namebuf );
3722               rescan_apps++;
3723             }
3724
3725           }
3726
3727         }
3728
3729         break;
3730
3731       case context_app_run:
3732         ui_push_exec();
3733         break;
3734
3735       case context_app_notes1:
3736       case context_app_notes2:
3737       case context_app_notes3:
3738         {
3739           char namebuf [ 101 ] = "";
3740
3741           char key [ 501 ];
3742           unsigned char notenum;
3743
3744           // which note line?
3745           if ( menu [ sel ] == context_app_notes1 ) {
3746             notenum = 1;
3747           } else if ( menu [ sel ] == context_app_notes2 ) {
3748             notenum = 2;
3749           } else if ( menu [ sel ] == context_app_notes3 ) {
3750             notenum = 3;
3751           }
3752
3753           // figure out key for looking up existing, and for storing replacement
3754           snprintf ( key, 500, "Application-%u.note-%u", a -> ref -> subapp_number, notenum );
3755
3756           // do we have existing value?
3757           if ( a -> ovrh ) {
3758             char *existing = pnd_conf_get_as_char ( a -> ovrh, key );
3759             if ( existing ) {
3760               strncpy ( namebuf, existing, 100 );
3761             }
3762           }
3763
3764           unsigned char changed;
3765
3766           changed = ui_menu_get_text_line ( "Enter replacement note", "Use keyboard; Enter when done.",
3767                                             namebuf, namebuf, 30, 0 /* not-numeric-forced */ );
3768
3769           if ( changed ) {
3770             ovr_replace_or_add ( a, strchr ( key, '.' ) + 1, namebuf );
3771             rescan_apps++;
3772           }
3773
3774         }
3775         break;
3776
3777       default:
3778         return;
3779
3780       } // switch
3781
3782     } // if useful return
3783
3784   } // menu is alive?
3785
3786   // rescan apps?
3787   if ( rescan_apps ) {
3788     applications_free();
3789     applications_scan();
3790   }
3791
3792   return;
3793 }
3794
3795 unsigned char ui_menu_oneby ( char *title, char *footer, char *one ) {
3796   char *opts [ 2 ];
3797   opts [ 0 ] = one;
3798   int sel = ui_modal_single_menu ( opts, 1, title, footer );
3799   if ( sel < 0 ) {
3800     return ( 0 );
3801   }
3802   return ( sel + 1 );
3803 }
3804
3805 unsigned char ui_menu_twoby ( char *title, char *footer, char *one, char *two ) {
3806   char *opts [ 3 ];
3807   opts [ 0 ] = one;
3808   opts [ 1 ] = two;
3809   int sel = ui_modal_single_menu ( opts, 2, title, footer );
3810   if ( sel < 0 ) {
3811     return ( 0 );
3812   }
3813   return ( sel + 1 );
3814 }
3815
3816 unsigned char ui_menu_get_text_line ( char *title, char *footer, char *initialvalue,
3817                                       char *r_buffer, unsigned char maxlen, unsigned char numbersonlyp )
3818 {
3819   SDL_Rect rects [ 40 ];
3820   SDL_Rect *dest = rects;
3821   SDL_Rect src;
3822   SDL_Surface *rtext;
3823
3824   char hacktext [ 1024 ];
3825   unsigned char shifted = 0;
3826
3827   bzero ( rects, sizeof(SDL_Rect) * 40 );
3828
3829   if ( initialvalue ) {
3830     if ( initialvalue == r_buffer ) {
3831       // already good to go
3832     } else {
3833       strncpy ( r_buffer, initialvalue, maxlen );
3834     }
3835   } else {
3836     bzero ( r_buffer, maxlen );
3837   }
3838
3839   while ( 1 ) {
3840
3841     // clear
3842     dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
3843     dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
3844     dest -> w = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> w;
3845     dest -> h = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h;
3846     SDL_FillRect( sdl_realscreen, dest, 0 );
3847
3848     // show dialog background
3849     if ( g_imagecache [ IMG_DETAIL_BG ].i ) {
3850       src.x = 0;
3851       src.y = 0;
3852       src.w = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> w;
3853       src.h = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> h;
3854       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
3855       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
3856       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
3857       dest++;
3858     }
3859
3860     // show dialog frame
3861     if ( g_imagecache [ IMG_DETAIL_PANEL ].i ) {
3862       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
3863       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
3864       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_PANEL ].i, NULL /* whole image */, sdl_realscreen, dest );
3865       dest++;
3866     }
3867
3868     // show header
3869     if ( title ) {
3870       rtext = TTF_RenderText_Blended ( g_tab_font, title, ui_display_context.fontcolor );
3871       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
3872       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 20;
3873       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
3874       SDL_FreeSurface ( rtext );
3875       dest++;
3876     }
3877
3878     // show footer
3879     if ( footer ) {
3880       rtext = TTF_RenderText_Blended ( g_tab_font, footer, ui_display_context.fontcolor );
3881       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
3882       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) +
3883         ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h
3884         - 60;
3885       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
3886       SDL_FreeSurface ( rtext );
3887       dest++;
3888     }
3889
3890     // show text line - and embed cursor
3891     dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
3892     dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 40 + ( 20 * ( 0/*i*/ + 1 - 0/*first_visible*/ ) );
3893
3894     strncpy ( hacktext, r_buffer, 1000 );
3895     strncat ( hacktext, "\n", 1000 ); // add [] in most fonts
3896
3897     rtext = TTF_RenderText_Blended ( g_tab_font, hacktext, ui_display_context.fontcolor );
3898     SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
3899     SDL_FreeSurface ( rtext );
3900     dest++;
3901
3902     // update all the rects and send it all to sdl
3903     SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
3904     dest = rects;
3905
3906     // check for input
3907     SDL_Event event;
3908     while ( SDL_WaitEvent ( &event ) ) {
3909
3910       switch ( event.type ) {
3911
3912       case SDL_KEYUP:
3913         if ( event.key.keysym.sym == SDLK_LSHIFT || event.key.keysym.sym == SDLK_RSHIFT ) {
3914           shifted = 0;
3915         }
3916         break;
3917
3918       case SDL_KEYDOWN:
3919
3920         if ( event.key.keysym.sym == SDLK_LEFT || event.key.keysym.sym == SDLK_BACKSPACE ) {
3921           if ( strlen ( r_buffer ) > 0 ) {
3922             char *eol = strchr ( r_buffer, '\0' );
3923             *( eol - 1 ) = '\0';
3924           }
3925
3926         } else if ( event.key.keysym.sym == SDLK_UP ) {
3927           r_buffer [ 0 ] = '\0'; // truncate!
3928
3929         } else if ( event.key.keysym.sym == SDLK_RETURN || event.key.keysym.sym == SDLK_END ) { // return, or "B"
3930           // on Enter/Return or B, if the buffer has 1 or more chars, we return it as valid.. otherwise, invalid.
3931           if ( strlen ( r_buffer ) > 0 ) {
3932             return ( 1 );
3933           }
3934           return ( 0 );
3935
3936         } else if ( event.key.keysym.sym == SDLK_LSHIFT || event.key.keysym.sym == SDLK_RSHIFT ) {
3937           shifted = 1;
3938
3939         } else if ( event.key.keysym.sym == SDLK_ESCAPE ||
3940                     event.key.keysym.sym == SDLK_PAGEUP ||
3941                     event.key.keysym.sym == SDLK_PAGEDOWN ||
3942                     event.key.keysym.sym == SDLK_HOME
3943                   )
3944         {
3945           return ( 0 );
3946
3947         } else {
3948
3949           if ( isprint(event.key.keysym.sym) ) {
3950
3951             unsigned char good = 1;
3952
3953             if ( numbersonlyp && ( ! isdigit(event.key.keysym.sym) ) ) {
3954               good = 0;
3955             }
3956
3957             if ( maxlen && strlen(r_buffer) >= maxlen ) {
3958               good = 0;
3959             }
3960
3961             if ( good ) {
3962               char b [ 2 ] = { '\0', '\0' };
3963               if ( shifted ) {
3964                 b [ 0 ] = toupper ( event.key.keysym.sym );
3965               } else {
3966                 b [ 0 ] = event.key.keysym.sym;
3967               }
3968               strncat ( r_buffer, b, maxlen );
3969             } // good?
3970
3971           } // printable?
3972
3973         }
3974
3975         break;
3976
3977       } // switch
3978
3979       break;
3980
3981     } // while waiting for input
3982
3983   } // while
3984
3985   return ( 0 );
3986 }
3987
3988 unsigned char ovr_replace_or_add ( mm_appref_t *a, char *keybase, char *newvalue ) {
3989   //printf ( "setting %s:%u - '%s' to '%s' - %s/%s\n", a -> ref -> title_en, a -> ref -> subapp_number, keybase, newvalue, a -> ref -> object_path, a -> ref -> object_filename );
3990
3991   char fullpath [ PATH_MAX ];
3992
3993   sprintf ( fullpath, "%s/%s", a -> ref -> object_path, a -> ref -> object_filename );
3994   char *dot = strrchr ( fullpath, '.' );
3995   if ( dot ) {
3996     sprintf ( dot, PXML_SAMEPATH_OVERRIDE_FILEEXT );
3997   } else {
3998     pnd_log ( pndn_error, "ERROR: Bad pnd-path in disco_t! %s\n", fullpath );
3999     return ( 0 );
4000   }
4001
4002   struct stat statbuf;
4003
4004   if ( stat ( fullpath, &statbuf ) == 0 ) {
4005     // file exists
4006     pnd_conf_handle h;
4007
4008     h = pnd_conf_fetch_by_path ( fullpath );
4009
4010     if ( ! h ) {
4011       return ( 0 ); // fail!
4012     }
4013
4014     char key [ 101 ];
4015     snprintf ( key, 100, "Application-%u.%s", a -> ref -> subapp_number, keybase );
4016
4017     pnd_conf_set_char ( h, key, newvalue );
4018
4019     return ( pnd_conf_write ( h, fullpath ) );
4020
4021   } else {
4022     // file needs to be created - easy!
4023
4024     FILE *f = fopen ( fullpath, "w" );
4025
4026     if ( f ) {
4027       fprintf ( f, "Application-%u.%s\t%s\n", a -> ref -> subapp_number, keybase, newvalue );
4028       fclose ( f );
4029
4030     } else {
4031       return ( 0 ); // fail!
4032     }
4033
4034   } // new or used?
4035
4036   return ( 1 );
4037 }
4038
4039 void ui_manage_categories ( void ) {
4040   unsigned char require_app_scan = 0;
4041
4042   if ( ! mmcustom_setup() ) {
4043     return; // error
4044   }
4045
4046   char *opts [ 20 ] = {
4047     "List custom categories",
4048     "List custom subcategories",
4049     "Register custom category",
4050     "Register custom subcategory",
4051     "Unregister custom category",
4052     "Unregister custom subcategory",
4053     "Done"
4054   };
4055
4056   while ( 1 ) {
4057
4058     int sel = ui_modal_single_menu ( opts, 7, "Custom Categories", "B to select; other to cancel." );
4059
4060     switch ( sel ) {
4061
4062     case 0: // list custom
4063       ui_pick_custom_category ( 0 );
4064       break;
4065
4066     case 1: // list custom sub
4067       if ( mmcustom_count ) {
4068
4069         char *maincat = ui_pick_custom_category ( 2 );
4070
4071         if ( maincat ) {
4072           unsigned int subcount = mmcustom_count_subcats ( maincat );
4073           char titlebuf [ 201 ];
4074
4075           snprintf ( titlebuf, 200, "Category: %s", maincat );
4076
4077           if ( subcount == 0 ) {
4078             ui_menu_oneby ( titlebuf, "B/Enter to accept", "Category has no subcategories." );
4079           } else {
4080
4081             char **list = malloc ( subcount * sizeof(char*) );
4082             int i;
4083             unsigned int counter = 0;
4084
4085             for ( i = 0; i < mmcustom_count; i++ ) {
4086               if ( mmcustom_complete [ i ].parent_cat && strcasecmp ( mmcustom_complete [ i ].parent_cat, maincat ) == 0 ) {
4087                 list [ counter++ ] = mmcustom_complete [ i ].cat;
4088               }
4089             }
4090
4091             ui_modal_single_menu ( list, counter, titlebuf, "Any button to exit." );
4092
4093             free ( list );
4094
4095           } // more than 0 subcats?
4096
4097         } // user picked a main cat?
4098
4099       } else {
4100         ui_menu_oneby ( "Warning", "B/Enter to accept", "There are none registered." );
4101       }
4102       break;
4103
4104     case 2: // register custom
4105       {
4106         unsigned char changed;
4107         char namebuf [ 101 ] = "";
4108
4109         changed = ui_menu_get_text_line ( "Enter unique category name", "Use keyboard; Enter when done.",
4110                                           "Pandora", namebuf, 30, 0 /* alphanumeric */ );
4111
4112         // did the user enter something?
4113         if ( changed ) {
4114
4115           // and if so, is it existant already or not?
4116           if ( mmcustom_query ( namebuf, NULL ) ) {
4117             ui_menu_oneby ( "Warning", "B/Enter to accept", "Already a registered category." );
4118           } else if ( freedesktop_category_query ( namebuf, NULL ) ) {
4119             ui_menu_oneby ( "Warning", "B/Enter to accept", "Already a Standard category." );
4120           } else {
4121
4122             char confirm [ 1001 ];
4123             snprintf ( confirm, 1000, "Confirm: %s", namebuf );
4124
4125             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm new category", "Do not register" ) == 1 ) {
4126               // register, save, recycle the current list
4127               mmcustom_register ( namebuf, NULL );
4128               mmcustom_write ( NULL );
4129               mmcustom_shutdown();
4130               mmcustom_setup();
4131             }
4132
4133           } // dupe?
4134
4135         } // entered something?
4136
4137       }
4138       break;
4139
4140     case 3: // register custom sub
4141       if ( 1 /*mmcustom_count -- we allow FD cats now, so this isn't applicable error */ ) {
4142
4143         char *maincat = ui_pick_custom_category ( 1 /* include FD */ );
4144
4145         if ( maincat ) {
4146           char titlebuf [ 201 ];
4147
4148           snprintf ( titlebuf, 200, "Subcat of: %s", maincat );
4149
4150           unsigned char changed;
4151           char namebuf [ 101 ] = "";
4152
4153           changed = ui_menu_get_text_line ( titlebuf, "Use keyboard; Enter when done.", "Submarine", namebuf, 30, 0 /* alphanumeric */ );
4154
4155           // did the user enter something?
4156           if ( changed ) {
4157
4158             // and if so, is it existant already or not?
4159             if ( mmcustom_query ( namebuf, maincat ) ) {
4160               ui_menu_oneby ( "Warning", "B/Enter to accept", "Already a subcategory." );
4161             } else if ( freedesktop_category_query ( namebuf, maincat ) ) {
4162               ui_menu_oneby ( "Warning", "B/Enter to accept", "Already a Standard subcategory." );
4163             } else {
4164
4165               char confirm [ 1001 ];
4166               snprintf ( confirm, 1000, "Confirm: %s [%s]", namebuf, maincat );
4167
4168               if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm new category", "Do not register" ) == 1 ) {
4169                 // register, save, recycle the current list
4170                 mmcustom_register ( namebuf, maincat );
4171                 mmcustom_write ( NULL );
4172                 mmcustom_shutdown();
4173                 mmcustom_setup();
4174               }
4175
4176             } // dupe?
4177
4178           } // entered something?
4179
4180         } // selected parent cat?
4181
4182       } else {
4183         ui_menu_oneby ( "Warning", "B/Enter to accept", "No categories registered." );
4184       }
4185       break;
4186
4187     case 4: // unreg custom
4188       if ( mmcustom_count ) {
4189         char *maincat = ui_pick_custom_category ( 0 );
4190
4191         if ( maincat ) {
4192           char confirm [ 1001 ];
4193           snprintf ( confirm, 1000, "Confirm remove: %s", maincat );
4194
4195           if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm unregister", "Do not unregister" ) == 1 ) {
4196             // register, save, recycle the current list
4197             mmcustom_unregister ( maincat, NULL );
4198             mmcustom_write ( NULL );
4199             mmcustom_shutdown();
4200             mmcustom_setup();
4201           }
4202
4203         } // picked?
4204
4205       } else {
4206         ui_menu_oneby ( "Warning", "B/Enter to accept", "There are none registered." );
4207       }
4208       break;
4209
4210     case 5: // unreg custom sub
4211       if ( mmcustom_count ) {
4212         char *maincat = ui_pick_custom_category ( 2 );
4213
4214         if ( maincat ) {
4215           unsigned int subcount = mmcustom_count_subcats ( maincat );
4216           char titlebuf [ 201 ];
4217
4218           snprintf ( titlebuf, 200, "Category: %s", maincat );
4219
4220           if ( subcount == 0 ) {
4221             ui_menu_oneby ( titlebuf, "B/Enter to accept", "Category has no subcategories." );
4222           } else {
4223
4224             char **list = malloc ( subcount * sizeof(char*) );
4225             int i;
4226             unsigned int counter = 0;
4227
4228             for ( i = 0; i < mmcustom_count; i++ ) {
4229               if ( mmcustom_complete [ i ].parent_cat && strcasecmp ( mmcustom_complete [ i ].parent_cat, maincat ) == 0 ) {
4230                 list [ counter++ ] = mmcustom_complete [ i ].cat;
4231               }
4232             }
4233
4234             int sel = ui_modal_single_menu ( list, counter, titlebuf, "B to selct; other to exit." );
4235
4236             if ( sel >= 0 ) {
4237               char confirm [ 1001 ];
4238               snprintf ( confirm, 1000, "Confirm remove: %s", list [ sel ] );
4239
4240               if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm unregister", "Do not unregister" ) == 1 ) {
4241                 // register, save, recycle the current list
4242                 mmcustom_unregister ( list [ sel ], maincat );
4243                 mmcustom_write ( NULL );
4244                 mmcustom_shutdown();
4245                 mmcustom_setup();
4246               }
4247
4248             } // confirm kill?
4249
4250             free ( list );
4251
4252           } // more than 0 subcats?
4253
4254         } // user picked a main cat?
4255
4256       } else {
4257         ui_menu_oneby ( "Warning", "B/Enter to accept", "There are none registered." );
4258       }
4259       break;
4260
4261     } // switch
4262
4263     // exeunt
4264     if ( sel < 0 || sel > 5 ) {
4265       break;
4266     }
4267
4268   } // while running the menu
4269
4270   // shut down custom cats
4271   mmcustom_shutdown();
4272
4273   // reload apps?
4274   if ( require_app_scan ) {
4275     applications_free();
4276     applications_scan();
4277   }
4278
4279   // redraw
4280   render_mask |= CHANGED_EVERYTHING;
4281
4282   return;
4283 }
4284
4285 // mode 0 == custom main only; 1 == custom main + FD main; 2 == custom main + FD mains-with-custom-subs
4286 char *ui_pick_custom_category ( unsigned char mode ) {
4287   char **list;
4288   int i;
4289   unsigned int counter = 0;
4290
4291   // alloc space for list, depending on scope
4292   if ( mode > 0 ) {
4293     list = malloc ( (mmcustom_count+freedesktop_count()) * sizeof(char*) );
4294   } else {
4295     list = malloc ( mmcustom_count * sizeof(char*) );
4296   }
4297
4298   // add custom mains
4299   for ( i = 0; i < mmcustom_count; i++ ) {
4300     if ( mmcustom_complete [ i ].parent_cat == NULL ) {
4301       list [ counter++ ] = mmcustom_complete [ i ].cat;
4302     }
4303   }
4304
4305   // add FD if needed
4306   if ( mode > 0 ) {
4307     i = 3;
4308
4309     while ( 1 ) {
4310
4311       if ( ! freedesktop_complete [ i ].cat ) {
4312         break;
4313       }
4314
4315       // if FD main cat
4316       if ( freedesktop_complete [ i ].parent_cat == NULL ) {
4317
4318         // mode 1 == include them all
4319         // mode 2 == include them if they have a custom subcat
4320         if ( ( mode == 1 ) ||
4321              ( mmcustom_subcount ( freedesktop_complete [ i ].cat ) ) )
4322         {
4323           list [ counter++ ] = freedesktop_complete [ i ].cat;
4324         }
4325
4326       } // if parent cat
4327
4328       i++;
4329     } // while
4330
4331   } // if
4332
4333   // we actually showing anything?
4334   if ( ! counter ) {
4335     ui_menu_oneby ( "Warning", "B/Enter to accept", "There are none registered." );
4336     return ( NULL );
4337   }
4338
4339   // do it
4340   int sel = ui_modal_single_menu ( list, counter, "Custom Categories", "Any button to exit." );
4341
4342   if ( sel < 0 ) {
4343     free ( list );
4344     return ( NULL );
4345   }
4346
4347   char *foo = list [ sel ];
4348   free ( list );
4349
4350   return ( foo );
4351 }
4352
4353 void ui_start_defered_icon_thread ( void ) {
4354
4355   if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_icons_later", 0 ) == 0 ) {
4356     return;
4357   }
4358
4359   if ( g_icon_thread_busy ) {
4360     //fprintf ( stderr, "REM: Waiting for thread to stop..\n" );
4361     ui_stop_defered_icon_thread();
4362   }
4363
4364   //fprintf ( stderr, "WARN: Starting new icon caching thread..\n" );
4365   g_icon_thread = SDL_CreateThread ( (void*)ui_threaded_defered_icon, NULL );
4366
4367   if ( ! g_icon_thread ) {
4368     pnd_log ( pndn_error, "ERROR: Couldn't create icon thread\n" );
4369   }
4370
4371   return;
4372 }
4373
4374 void ui_stop_defered_icon_thread ( void ) {
4375   time_t started = time ( NULL );
4376
4377   // ask thread to stop, then wait for it (if two run at same time, or if we change
4378   // category content under neath it, could be bad..)
4379   g_icon_thread_stop = 1;
4380   while ( g_icon_thread_busy ) {
4381     time ( NULL ); // spin
4382   }
4383   g_icon_thread_stop = 0;
4384
4385   fprintf ( stderr, "REM: Thread stoppage took %u seconds.\n", (int) ( time ( NULL ) - started ) );
4386
4387   return;
4388 }