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
1832   // cache last known cat/app to /tmp, so we can use it again later
1833   conf_write ( g_conf, CONF_PREF_TEMPPATH );
1834
1835   // was this icon generated from filesystem, or from pnd-file?
1836   if ( ui_selected -> ref -> object_flags & PND_DISCO_GENERATED ) {
1837
1838     if ( ! ui_selected -> ref -> title_en ) {
1839       return; // no filename
1840     }
1841
1842     if ( ui_selected -> ref -> object_type == pnd_object_type_directory ) {
1843
1844       // check if this guy is a dir-browser tab, or is a directory on a pnd tab
1845       if ( ! g_categories [ ui_category] -> fspath ) {
1846         // pnd subcat as dir
1847
1848         // are we already in a subcat? if so, go back to parent; there is no grandparenting or deeper
1849         if ( g_categories [ ui_category ] -> parent_catname ) {
1850           // go back up
1851           ui_push_backup();
1852
1853         } else {
1854           // delve into subcat
1855
1856           // set to first cat!
1857           ui_category = 0;
1858           ui_catshift = 0;
1859
1860           // republish cats .. shoudl just be the one
1861           category_publish ( CFBYNAME, ui_selected -> ref -> object_path );
1862
1863         }
1864
1865         // forget the selection, nolonger applies
1866         ui_selected = NULL;
1867         ui_set_selected ( ui_selected );
1868         // redraw the grid
1869         render_mask |= CHANGED_EVERYTHING;
1870
1871       } else {
1872
1873         // delve up/down the dir tree
1874         if ( strcmp ( ui_selected -> ref -> title_en, ".." ) == 0 ) {
1875           ui_push_backup();
1876
1877         } else {
1878           // go down
1879           char *temp = malloc ( strlen ( g_categories [ ui_category] -> fspath ) + strlen ( ui_selected -> ref -> title_en ) + 1 + 1 );
1880           sprintf ( temp, "%s/%s", g_categories [ ui_category] -> fspath, ui_selected -> ref -> title_en );
1881           free ( g_categories [ ui_category] -> fspath );
1882           g_categories [ ui_category] -> fspath = temp;
1883         }
1884
1885         pnd_log ( pndn_debug, "Cat %s is now in path %s\n", g_categories [ ui_category ] -> catname, g_categories [ ui_category ]-> fspath );
1886
1887         // forget the selection, nolonger applies
1888         ui_selected = NULL;
1889         ui_set_selected ( ui_selected );
1890         // rescan the dir
1891         category_fs_restock ( g_categories [ ui_category ] );
1892         // redraw the grid
1893         render_mask |= CHANGED_SELECTION;
1894
1895       } // directory browser or pnd subcat?
1896
1897     } else {
1898       // just run it arbitrarily?
1899
1900       // if this a pnd-file, or just some executable?
1901       if ( strcasestr ( ui_selected -> ref -> object_filename, PND_PACKAGE_FILEEXT ) ) {
1902         // looks like a pnd, now what do we do..
1903         pnd_box_handle h = pnd_disco_file ( ui_selected -> ref -> object_path, ui_selected -> ref -> object_filename );
1904
1905         if ( h ) {
1906           pnd_disco_t *d = pnd_box_get_head ( h );
1907           pnd_apps_exec_disco ( pnd_run_script, d, PND_EXEC_OPTION_NORUN, NULL );
1908           char buffer [ PATH_MAX ];
1909           sprintf ( buffer, "%s %s\n", MM_RUN, pnd_apps_exec_runline() );
1910           if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.live_on_run", 0 ) == 0 ) {
1911             emit_and_quit ( buffer );
1912           } else {
1913             emit_and_run ( buffer );
1914           }
1915         }
1916
1917       } else {
1918         // random bin file
1919
1920         // is it even executable? if we don't have handlers for non-executables yet (Jan 2011 we don't),
1921         // then don't even try to run things not-flagged as executable.. but wait most people are on
1922         // FAT filesystems, what a drag, we can't tell at the fs level.
1923         // ... but we can still invoke 'file' and grep out the good bits, at least.
1924         //
1925         // open a stream reading 'file /path/to/file' and check output for 'executable'
1926         // -- not checking for "ARM" so it can pick up x86 (or whatever native) executables in build environment
1927         unsigned char is_executable = 0;
1928
1929         // popen test
1930         {
1931           char popenbuf [ FILENAME_MAX ];
1932           snprintf ( popenbuf, FILENAME_MAX, "%s %s/%s", MIMETYPE_EXE, g_categories [ ui_category ] -> fspath, ui_selected -> ref -> title_en );
1933
1934           FILE *marceau;
1935           if ( ! ( marceau = popen ( popenbuf, "r" ) ) ) {
1936             return; // error, we need some useful error handling and dialog boxes here
1937           }
1938
1939           if ( fgets ( popenbuf, FILENAME_MAX, marceau ) ) {
1940             //printf ( "File test returns: %s\n", popenbuf );
1941             if ( strstr ( popenbuf, "executable" ) != NULL ) {
1942               is_executable = 1;
1943             }
1944           }
1945
1946           pclose ( marceau );
1947
1948         } // popen test
1949
1950         if ( ! is_executable ) {
1951           fprintf ( stderr, "ERROR: File to invoke is not executable, skipping. (%s)\n", ui_selected -> ref -> title_en );
1952           return; // need some error handling here
1953         }
1954
1955 #if 0 // eat up any pending SDL events and toss 'em?
1956         {
1957           SDL_PumpEvents();
1958           SDL_Event e;
1959           while ( SDL_PeepEvents ( &e, 1, SDL_GETEVENT, SDL_ALLEVENTS ) > 0 ) {
1960             // spin
1961           }
1962         }
1963 #endif
1964
1965 #if 1
1966         // just exec it
1967         //
1968
1969         // get CWD so we can restore it on return
1970         char cwd [ PATH_MAX ];
1971         getcwd ( cwd, PATH_MAX );
1972
1973         // full path to executable so we don't rely on implicit "./"
1974         char execbuf [ FILENAME_MAX ];
1975         snprintf ( execbuf, FILENAME_MAX, "%s/%s", g_categories [ ui_category ] -> fspath, ui_selected -> ref -> title_en );
1976
1977         // do it!
1978         chdir ( g_categories [ ui_category ] -> fspath );
1979         exec_raw_binary ( execbuf /*ui_selected -> ref -> title_en*/ );
1980         chdir ( cwd );
1981 #else
1982         // DEPRECATED / NOT TESTED
1983         // get mmwrapper to run it
1984         char buffer [ PATH_MAX ];
1985         sprintf ( buffer, "%s %s/%s\n", MM_RUN, g_categories [ ui_category ] -> fspath, ui_selected -> ref -> title_en );
1986         if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.live_on_run", 0 ) == 0 ) {
1987           emit_and_quit ( buffer );
1988         } else {
1989           emit_and_run ( buffer );
1990         }
1991 #endif
1992       } // pnd or bin?
1993
1994     } // dir or file?
1995
1996   } else {
1997
1998     // set app-run speed
1999     int use_run_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.use_run_speed", 0 );
2000     if ( use_run_speed > 0 ) {
2001       int mm_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.run_speed", -1 );
2002       if ( mm_speed > -1 ) {
2003         char buffer [ 512 ];
2004         snprintf ( buffer, 500, "sudo /usr/pandora/scripts/op_cpuspeed.sh %d", mm_speed );
2005         system ( buffer );
2006       }
2007     } // do speed change?
2008
2009     // request app to run and quit mmenu
2010     pnd_apps_exec_disco ( pnd_run_script, ui_selected -> ref, PND_EXEC_OPTION_NORUN, NULL );
2011     char buffer [ PATH_MAX ];
2012     sprintf ( buffer, "%s %s\n", MM_RUN, pnd_apps_exec_runline() );
2013     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.live_on_run", 0 ) == 0 ) {
2014       emit_and_quit ( buffer );
2015     } else {
2016       emit_and_run ( buffer );
2017     }
2018   }
2019
2020   return;
2021 }
2022
2023 void ui_push_ltrigger ( void ) {
2024   unsigned char oldcat = ui_category;
2025   unsigned int screen_width = ui_display_context.screen_width;
2026   unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
2027
2028   if ( g_categorycount == 0 ) {
2029     return;
2030   }
2031
2032   if ( g_icon_thread_busy ) {
2033     ui_stop_defered_icon_thread();
2034   }
2035
2036   if ( ui_category > 0 ) {
2037     ui_category--;
2038     category_fs_restock ( g_categories [ ui_category ] );
2039   } else {
2040     if ( pnd_conf_get_as_int_d ( g_conf, "tabs.wraparound", 0 ) > 0 ) {
2041       ui_category = g_categorycount - 1;
2042       ui_catshift = 0;
2043       if ( ui_category >= ( screen_width / tab_width ) ) {
2044         ui_catshift = ui_category - ( screen_width / tab_width ) + 1;
2045       }
2046       category_fs_restock ( g_categories [ ui_category ] );
2047     }
2048   }
2049
2050   if ( oldcat != ui_category ) {
2051     ui_selected = NULL;
2052     ui_set_selected ( ui_selected );
2053   }
2054
2055   // make tab visible?
2056   if ( ui_catshift > 0 && ui_category == ui_catshift - 1 ) {
2057     ui_catshift--;
2058   }
2059
2060   // unscroll
2061   ui_rows_scrolled_down = 0;
2062
2063   render_mask |= CHANGED_CATEGORY;
2064   ui_start_defered_icon_thread();
2065
2066   return;
2067 }
2068
2069 void ui_push_rtrigger ( void ) {
2070   unsigned char oldcat = ui_category;
2071
2072   if ( g_categorycount == 0 ) {
2073     return;
2074   }
2075
2076   if ( g_icon_thread_busy ) {
2077     ui_stop_defered_icon_thread();
2078   }
2079
2080   unsigned int screen_width = ui_display_context.screen_width;
2081   unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
2082
2083   if ( ui_category < ( g_categorycount - 1 ) ) {
2084     ui_category++;
2085     category_fs_restock ( g_categories [ ui_category ] );
2086   } else {
2087     if ( pnd_conf_get_as_int_d ( g_conf, "tabs.wraparound", 0 ) > 0 ) {
2088       ui_category = 0;
2089       ui_catshift = 0;
2090       category_fs_restock ( g_categories [ ui_category ] );
2091     }
2092   }
2093
2094   if ( oldcat != ui_category ) {
2095     ui_selected = NULL;
2096     ui_set_selected ( ui_selected );
2097   }
2098
2099   // make tab visible?
2100   if ( ui_category > ui_catshift + ( screen_width / tab_width ) - 1 ) {
2101     ui_catshift++;
2102   }
2103
2104   // unscroll
2105   ui_rows_scrolled_down = 0;
2106
2107   render_mask |= CHANGED_CATEGORY;
2108   ui_start_defered_icon_thread();
2109
2110   return;
2111 }
2112
2113 SDL_Surface *ui_scale_image ( SDL_Surface *s, unsigned int maxwidth, int maxheight ) {
2114   double scale = 1000000.0;
2115   double scalex = 1000000.0;
2116   double scaley = 1000000.0;
2117   SDL_Surface *scaled;
2118
2119   scalex = (double)maxwidth / (double)s -> w;
2120
2121   if ( maxheight == -1 ) {
2122     scale = scalex;
2123   } else {
2124     scaley = (double)maxheight / (double)s -> h;
2125
2126     if ( scaley < scalex ) {
2127       scale = scaley;
2128     } else {
2129       scale = scalex;
2130     }
2131
2132   }
2133
2134   scaled = rotozoomSurface ( s, 0 /* angle*/, scale /* scale */, 1 /* smooth==1*/ );
2135   SDL_FreeSurface ( s );
2136   s = scaled;
2137
2138   return ( s );
2139 }
2140
2141 void ui_loadscreen ( void ) {
2142
2143   SDL_Rect dest;
2144
2145   // clear the screen
2146   SDL_FillRect( SDL_GetVideoSurface(), NULL, 0 );
2147
2148   // render text
2149   SDL_Surface *rtext;
2150   rtext = TTF_RenderText_Blended ( g_big_font, "Setting up menu...", ui_display_context.fontcolor );
2151   dest.x = 20;
2152   dest.y = 20;
2153   SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, &dest );
2154   SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2155   SDL_FreeSurface ( rtext );
2156
2157   return;
2158 }
2159
2160 void ui_discoverscreen ( unsigned char clearscreen ) {
2161
2162   SDL_Rect dest;
2163
2164   // clear the screen
2165   if ( clearscreen ) {
2166     SDL_FillRect( SDL_GetVideoSurface(), NULL, 0 );
2167
2168     // render background
2169     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
2170       dest.x = 0;
2171       dest.y = 0;
2172       dest.w = sdl_realscreen -> w;
2173       dest.h = sdl_realscreen -> h;
2174       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, NULL /* whole image */, sdl_realscreen, NULL /* 0,0 */ );
2175       SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2176     }
2177
2178   }
2179
2180   // render text
2181   SDL_Surface *rtext;
2182   rtext = TTF_RenderText_Blended ( g_big_font, "Looking for applications...", ui_display_context.fontcolor );
2183   if ( clearscreen ) {
2184     dest.x = 20;
2185     dest.y = 20;
2186   } else {
2187     dest.x = 20;
2188     dest.y = 40;
2189   }
2190   SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, &dest );
2191   SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2192   SDL_FreeSurface ( rtext );
2193
2194   // render icon
2195   if ( g_imagecache [ IMG_ICON_MISSING ].i ) {
2196     dest.x = rtext -> w + 30;
2197     dest.y = 20;
2198     SDL_BlitSurface ( g_imagecache [ IMG_ICON_MISSING ].i, NULL, sdl_realscreen, &dest );
2199     SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2200   }
2201
2202   return;
2203 }
2204
2205 void ui_cachescreen ( unsigned char clearscreen, char *filename ) {
2206
2207   SDL_Rect rects [ 4 ];
2208   SDL_Rect *dest = rects;
2209   SDL_Rect src;
2210   bzero ( dest, sizeof(SDL_Rect)* 4 );
2211
2212   unsigned int font_rgba_r = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_r", 200 );
2213   unsigned int font_rgba_g = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_g", 200 );
2214   unsigned int font_rgba_b = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_b", 200 );
2215   unsigned int font_rgba_a = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_a", 100 );
2216
2217   static unsigned int stepx = 0;
2218
2219   // clear the screen
2220   if ( clearscreen ) {
2221     SDL_FillRect( SDL_GetVideoSurface(), NULL, 0 );
2222
2223     // render background
2224     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
2225       dest -> x = 0;
2226       dest -> y = 0;
2227       dest -> w = sdl_realscreen -> w;
2228       dest -> h = sdl_realscreen -> h;
2229       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, NULL /* whole image */, sdl_realscreen, NULL /* 0,0 */ );
2230       dest++;
2231     }
2232
2233   } else {
2234
2235     // render background
2236     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
2237       src.x = 0;
2238       src.y = 0;
2239       src.w = sdl_realscreen -> w;
2240       src.h = 100;
2241       dest -> x = 0;
2242       dest -> y = 0;
2243       dest -> w = sdl_realscreen -> w;
2244       dest -> h = sdl_realscreen -> h;
2245       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, &src, sdl_realscreen, dest );
2246       dest++;
2247     }
2248
2249   } // clear it
2250
2251   // render text
2252   SDL_Surface *rtext;
2253   SDL_Color tmpfontcolor = { font_rgba_r, font_rgba_g, font_rgba_b, font_rgba_a };
2254   rtext = TTF_RenderText_Blended ( g_big_font, "Caching applications artwork...", tmpfontcolor );
2255   dest -> x = 20;
2256   dest -> y = 20;
2257   SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2258   SDL_FreeSurface ( rtext );
2259   dest++;
2260
2261   // render icon
2262   if ( g_imagecache [ IMG_ICON_MISSING ].i ) {
2263     dest -> x = rtext -> w + 30 + stepx;
2264     dest -> y = 20;
2265     SDL_BlitSurface ( g_imagecache [ IMG_ICON_MISSING ].i, NULL, sdl_realscreen, dest );
2266     dest++;
2267   }
2268
2269   // filename
2270   if ( filename ) {
2271     rtext = TTF_RenderText_Blended ( g_tab_font, filename, tmpfontcolor );
2272     dest -> x = 20;
2273     dest -> y = 50;
2274     SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2275     SDL_FreeSurface ( rtext );
2276     dest++;
2277   }
2278
2279   // move across
2280   stepx += 20;
2281
2282   if ( stepx > 350 ) {
2283     stepx = 0;
2284   }
2285
2286   SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
2287
2288   return;
2289 }
2290
2291 int ui_selected_index ( void ) {
2292
2293   if ( ! ui_selected ) {
2294     return ( -1 ); // no index
2295   }
2296
2297   mm_appref_t *r = g_categories [ ui_category ] -> refs;
2298   int counter = 0;
2299   while ( r ) {
2300     if ( r == ui_selected ) {
2301       return ( counter );
2302     }
2303     r = r -> next;
2304     counter++;
2305   }
2306
2307   return ( -1 );
2308 }
2309
2310 static mm_appref_t *timer_ref = NULL;
2311 void ui_set_selected ( mm_appref_t *r ) {
2312
2313   render_mask |= CHANGED_SELECTION;
2314
2315   // preview pic stuff
2316   //
2317
2318   if ( ! pnd_conf_get_as_int_d ( g_conf, "minimenu.load_previews_later", 0 ) ) {
2319     return; // no desire to defer anything
2320   }
2321
2322   if ( ! r ) {
2323     // cancel timer
2324     SDL_SetTimer ( 0, NULL );
2325     timer_ref = NULL;
2326     return;
2327   }
2328
2329   SDL_SetTimer ( pnd_conf_get_as_int_d ( g_conf, "previewpic.defer_timer_ms", 1000 ), ui_callback_f );
2330   timer_ref = r;
2331
2332   return;
2333 }
2334
2335 unsigned int ui_callback_f ( unsigned int t ) {
2336
2337   if ( ui_selected != timer_ref ) {
2338     return ( 0 ); // user has moved it, who cares
2339   }
2340
2341   SDL_Event e;
2342   bzero ( &e, sizeof(SDL_Event) );
2343   e.type = SDL_USEREVENT;
2344   e.user.code = sdl_user_ticker;
2345   SDL_PushEvent ( &e );
2346
2347   return ( 0 );
2348 }
2349
2350 int ui_modal_single_menu ( char *argv[], unsigned int argc, char *title, char *footer ) {
2351   SDL_Rect rects [ 40 ];
2352   SDL_Rect *dest = rects;
2353   SDL_Rect src;
2354   SDL_Surface *rtext;
2355   unsigned char max_visible = pnd_conf_get_as_int_d ( g_conf, "detailtext.max_visible" , 11 );
2356   unsigned char first_visible = 0;
2357
2358   bzero ( rects, sizeof(SDL_Rect) * 40 );
2359
2360   unsigned int sel = 0;
2361
2362   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 };
2363
2364   unsigned int i;
2365   SDL_Event event;
2366
2367   while ( 1 ) {
2368
2369     // clear
2370     dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
2371     dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
2372     dest -> w = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> w;
2373     dest -> h = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h;
2374     SDL_FillRect( sdl_realscreen, dest, 0 );
2375
2376     // show dialog background
2377     if ( g_imagecache [ IMG_DETAIL_BG ].i ) {
2378       src.x = 0;
2379       src.y = 0;
2380       src.w = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> w;
2381       src.h = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> h;
2382       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
2383       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
2384       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
2385       // repeat for darken?
2386       //SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
2387       //SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
2388       //SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2389       dest++;
2390     }
2391
2392     // show dialog frame
2393     if ( g_imagecache [ IMG_DETAIL_PANEL ].i ) {
2394       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
2395       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
2396       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_PANEL ].i, NULL /* whole image */, sdl_realscreen, dest );
2397       //SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2398       dest++;
2399     }
2400
2401     // show header
2402     if ( title ) {
2403       rtext = TTF_RenderText_Blended ( g_tab_font, title, ui_display_context.fontcolor );
2404       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
2405       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 20;
2406       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2407       SDL_FreeSurface ( rtext );
2408       dest++;
2409     }
2410
2411     // show footer
2412     if ( footer ) {
2413       rtext = TTF_RenderText_Blended ( g_tab_font, footer, ui_display_context.fontcolor );
2414       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
2415       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) +
2416         ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h
2417         - 60;
2418       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2419       SDL_FreeSurface ( rtext );
2420       dest++;
2421     }
2422
2423     // show options
2424     for ( i = first_visible; i < first_visible + max_visible && i < argc; i++ ) {
2425
2426       // show options
2427       if ( sel == i ) {
2428         rtext = TTF_RenderText_Blended ( g_tab_font, argv [ i ], selfontcolor );
2429       } else {
2430         rtext = TTF_RenderText_Blended ( g_tab_font, argv [ i ], ui_display_context.fontcolor );
2431       }
2432       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
2433       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 40 + ( 20 * ( i + 1 - first_visible ) );
2434       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2435       SDL_FreeSurface ( rtext );
2436       dest++;
2437
2438     } // for
2439
2440     // update all the rects and send it all to sdl
2441     SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
2442     dest = rects;
2443
2444     // check for input
2445     while ( SDL_WaitEvent ( &event ) ) {
2446
2447       switch ( event.type ) {
2448
2449       //case SDL_KEYUP:
2450       case SDL_KEYDOWN:
2451
2452         if ( event.key.keysym.sym == SDLK_UP ) {
2453           if ( sel ) {
2454             sel--;
2455
2456             if ( sel < first_visible ) {
2457               first_visible--;
2458             }
2459
2460           }
2461         } else if ( event.key.keysym.sym == SDLK_DOWN ) {
2462
2463           if ( sel < argc - 1 ) {
2464             sel++;
2465
2466             // ensure visibility
2467             if ( sel >= first_visible + max_visible ) {
2468               first_visible++;
2469             }
2470
2471           }
2472
2473         } else if ( event.key.keysym.sym == SDLK_RETURN || event.key.keysym.sym == SDLK_END ) { // return, or "B"
2474           return ( sel );
2475
2476 #if 0
2477         } else if ( event.key.keysym.sym == SDLK_q ) {
2478           exit ( 0 );
2479 #endif
2480
2481         } else {
2482           return ( -1 ); // nada
2483         }
2484
2485         break;
2486
2487       } // switch
2488
2489       break;
2490     } // while
2491
2492   } // while
2493
2494   return ( -1 );
2495 }
2496
2497 unsigned char ui_determine_row ( mm_appref_t *a ) {
2498   unsigned int row = 0;
2499
2500   mm_appref_t *i = g_categories [ ui_category ] -> refs;
2501   while ( i != a ) {
2502     i = i -> next;
2503     row++;
2504   } // while
2505   row /= ui_display_context.col_max;
2506
2507   return ( row );
2508 }
2509
2510 unsigned char ui_determine_screen_row ( mm_appref_t *a ) {
2511   return ( ui_determine_row ( a ) % ui_display_context.row_max );
2512 }
2513
2514 unsigned char ui_determine_screen_col ( mm_appref_t *a ) {
2515   unsigned int col = 0;
2516
2517   mm_appref_t *i = g_categories [ ui_category ] -> refs;
2518   while ( i != a ) {
2519     i = i -> next;
2520     col++;
2521   } // while
2522   col %= ui_display_context.col_max;
2523
2524   return ( col );
2525 }
2526
2527 unsigned char ui_show_info ( char *pndrun, pnd_disco_t *p ) {
2528   char *viewer, *searchpath;
2529   pnd_conf_handle desktoph;
2530
2531   // viewer
2532   searchpath = pnd_conf_query_searchpath();
2533
2534   desktoph = pnd_conf_fetch_by_id ( pnd_conf_desktop, searchpath );
2535
2536   if ( ! desktoph ) {
2537     return ( 0 );
2538   }
2539
2540   viewer = pnd_conf_get_as_char ( desktoph, "info.viewer" );
2541
2542   if ( ! viewer ) {
2543     return ( 0 ); // no way to view the file
2544   }
2545
2546   // etc
2547   if ( ! p -> unique_id ) {
2548     return ( 0 );
2549   }
2550
2551   if ( ! p -> info_filename ) {
2552     return ( 0 );
2553   }
2554
2555   if ( ! p -> info_name ) {
2556     return ( 0 );
2557   }
2558
2559   if ( ! pndrun ) {
2560     return ( 0 );
2561   }
2562
2563   // exec line
2564   char args [ 1001 ];
2565   char *pargs = args;
2566   if ( pnd_conf_get_as_char ( desktoph, "info.viewer_args" ) ) {
2567     snprintf ( pargs, 1001, "%s %s",
2568                pnd_conf_get_as_char ( desktoph, "info.viewer_args" ), p -> info_filename );
2569   } else {
2570     pargs = NULL;
2571   }
2572
2573   char pndfile [ 1024 ];
2574   if ( p -> object_type == pnd_object_type_directory ) {
2575     // for PXML-app-dir, pnd_run.sh doesn't want the PXML.xml.. it just wants the dir-name
2576     strncpy ( pndfile, p -> object_path, 1000 );
2577   } else if ( p -> object_type == pnd_object_type_pnd ) {
2578     // pnd_run.sh wants the full path and filename for the .pnd file
2579     snprintf ( pndfile, 1020, "%s/%s", p -> object_path, p -> object_filename );
2580   }
2581
2582   if ( ! pnd_apps_exec ( pndrun, pndfile, p -> unique_id, viewer, p -> startdir, pargs,
2583                          p -> clockspeed ? atoi ( p -> clockspeed ) : 0, PND_EXEC_OPTION_NORUN ) )
2584   {
2585     return ( 0 );
2586   }
2587
2588   pnd_log ( pndn_debug, "Info Exec=%s\n", pnd_apps_exec_runline() );
2589
2590   // try running it
2591   int x;
2592   if ( ( x = fork() ) < 0 ) {
2593     pnd_log ( pndn_error, "ERROR: Couldn't fork()\n" );
2594     return ( 0 );
2595   }
2596
2597   if ( x == 0 ) {
2598     execl ( "/bin/sh", "/bin/sh", "-c", pnd_apps_exec_runline(), (char*)NULL );
2599     pnd_log ( pndn_error, "ERROR: Couldn't exec(%s)\n", pnd_apps_exec_runline() );
2600     return ( 0 );
2601   }
2602
2603   return ( 1 );
2604 }
2605
2606 typedef struct {
2607   SDL_Rect r;
2608   int catnum;
2609   mm_appref_t *ref;
2610 } ui_touch_t;
2611 #define MAXTOUCH 100
2612 ui_touch_t ui_touchrects [ MAXTOUCH ];
2613 unsigned char ui_touchrect_count = 0;
2614
2615 void ui_register_reset ( void ) {
2616   bzero ( ui_touchrects, sizeof(ui_touch_t)*MAXTOUCH );
2617   ui_touchrect_count = 0;
2618   return;
2619 }
2620
2621 void ui_register_tab ( unsigned char catnum, unsigned int x, unsigned int y, unsigned int w, unsigned int h ) {
2622
2623   if ( ui_touchrect_count == MAXTOUCH ) {
2624     return;
2625   }
2626
2627   ui_touchrects [ ui_touchrect_count ].r.x = x;
2628   ui_touchrects [ ui_touchrect_count ].r.y = y;
2629   ui_touchrects [ ui_touchrect_count ].r.w = w;
2630   ui_touchrects [ ui_touchrect_count ].r.h = h;
2631   ui_touchrects [ ui_touchrect_count ].catnum = catnum;
2632   ui_touchrect_count++;
2633
2634   return;
2635 }
2636
2637 void ui_register_app ( mm_appref_t *app, unsigned int x, unsigned int y, unsigned int w, unsigned int h ) {
2638
2639   if ( ui_touchrect_count == MAXTOUCH ) {
2640     return;
2641   }
2642
2643   ui_touchrects [ ui_touchrect_count ].r.x = x;
2644   ui_touchrects [ ui_touchrect_count ].r.y = y;
2645   ui_touchrects [ ui_touchrect_count ].r.w = w;
2646   ui_touchrects [ ui_touchrect_count ].r.h = h;
2647   ui_touchrects [ ui_touchrect_count ].ref = app;
2648   ui_touchrect_count++;
2649
2650   return;
2651 }
2652
2653 void ui_touch_act ( unsigned int x, unsigned int y ) {
2654
2655   unsigned char i;
2656   ui_touch_t *t;
2657
2658   for ( i = 0; i < ui_touchrect_count; i++ ) {
2659     t = &(ui_touchrects [ i ]);
2660
2661     if ( x >= t -> r.x &&
2662          x <= t -> r.x + t -> r.w &&
2663          y >= t -> r.y &&
2664          y <= t -> r.y + t -> r.h
2665        )
2666     {
2667
2668       if ( t -> ref ) {
2669         ui_selected = t -> ref;
2670         ui_push_exec();
2671       } else {
2672         if ( ui_category != t -> catnum ) {
2673           ui_selected = NULL;
2674         }
2675         ui_category = t -> catnum;
2676         render_mask |= CHANGED_CATEGORY;
2677         // rescan the dir
2678         category_fs_restock ( g_categories [ ui_category ] );
2679         ui_start_defered_icon_thread();
2680       }
2681
2682       break;
2683     }
2684
2685   } // for
2686
2687   return;
2688 }
2689
2690 unsigned char ui_forkexec ( char *argv[] ) {
2691   char *fooby = argv[0];
2692   int x;
2693
2694   if ( ( x = fork() ) < 0 ) {
2695     pnd_log ( pndn_error, "ERROR: Couldn't fork() for '%s'\n", fooby );
2696     return ( 0 );
2697   }
2698
2699   if ( x == 0 ) { // child
2700     execv ( fooby, argv );
2701     pnd_log ( pndn_error, "ERROR: Couldn't exec(%s)\n", fooby );
2702     return ( 0 );
2703   }
2704
2705   // parent, success
2706   return ( 1 );
2707 }
2708
2709 unsigned char ui_threaded_timer_create ( void ) {
2710
2711   g_timer_thread = SDL_CreateThread ( (void*)ui_threaded_timer, NULL );
2712
2713   if ( ! g_timer_thread ) {
2714     pnd_log ( pndn_error, "ERROR: Couldn't create timer thread\n" );
2715     return ( 0 );
2716   }
2717
2718   return ( 1 );
2719 }
2720
2721 int ui_threaded_timer ( pnd_disco_t *p ) {
2722
2723   // this timer's job is to ..
2724   // - do nothing for quite awhile
2725   // - on wake, post event to SDL event queue, so that main thread will check if SD insert/eject occurred
2726   // - goto 10
2727
2728   unsigned int delay_s = 2; // seconds
2729
2730   while ( 1 ) {
2731
2732     // pause...
2733     //sleep ( delay_s );
2734     SDL_Delay ( delay_s * 1000 );
2735
2736     // .. trigger SD check
2737     SDL_Event e;
2738     bzero ( &e, sizeof(SDL_Event) );
2739     e.type = SDL_USEREVENT;
2740     e.user.code = sdl_user_checksd;
2741     SDL_PushEvent ( &e );
2742
2743   } // while
2744
2745   return ( 0 );
2746 }
2747
2748 unsigned char ui_threaded_defered_preview ( pnd_disco_t *p ) {
2749
2750   if ( ! cache_preview ( p, pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 200 ),
2751                          pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 180 ) )
2752      )
2753   {
2754     pnd_log ( pndn_debug, "THREAD: Couldn't load preview pic: '%s' -> '%s'\n",
2755               IFNULL(p->title_en,"No Name"), p -> preview_pic1 );
2756   }
2757
2758   // trigger that we completed
2759   SDL_Event e;
2760   bzero ( &e, sizeof(SDL_Event) );
2761   e.type = SDL_USEREVENT;
2762   e.user.code = sdl_user_finishedpreview;
2763   e.user.data1 = p;
2764   SDL_PushEvent ( &e );
2765
2766   return ( 0 );
2767 }
2768
2769 void ui_post_scan ( void ) {
2770
2771   // reset view
2772   ui_selected = NULL;
2773   ui_rows_scrolled_down = 0;
2774   // set back to first tab, to be safe
2775   ui_category = 0;
2776   ui_catshift = 0;
2777
2778   // do we have a preferred category to jump to? or a last known one?
2779   char *dc = pnd_conf_get_as_char ( g_conf, "categories.default_cat" );
2780   char *lastcat = pnd_conf_get_as_char ( g_conf, "minimenu.last_known_catname" );
2781   if ( ( dc ) ||
2782        ( pnd_conf_get_as_int_d ( g_conf, "minimenu.start_selected", 0 ) && lastcat ) )
2783   {
2784     char *catpick = NULL;
2785
2786     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.start_selected", 0 ) && lastcat ) {
2787       catpick = lastcat;
2788     } else if ( dc ) {
2789       catpick = dc;
2790     }
2791
2792     // attempt to find default cat; if we do find it, select it; otherwise
2793     // default behaviour will pick first cat (ie: usually All)
2794     if ( catpick ) {
2795       unsigned int i;
2796
2797       for ( i = 0; i < g_categorycount; i++ ) {
2798         if ( strcasecmp ( g_categories [ i ] -> catname, catpick ) == 0 ) {
2799           ui_category = i;
2800           // ensure visibility
2801           unsigned int screen_width = ui_display_context.screen_width;
2802           unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
2803           if ( ui_category > ui_catshift + ( screen_width / tab_width ) - 1 ) {
2804             ui_catshift = ui_category - ( screen_width / tab_width ) + 1;
2805           }
2806           break;
2807         }
2808       }
2809
2810       if ( i == g_categorycount ) {
2811         pnd_log ( pndn_warning, "  User defined default category or last known cat '%s' but not found, so using default behaviour\n", catpick );
2812       }
2813
2814     } // cat change?
2815
2816   } // default cat
2817
2818   // if we're sent right to a dirbrowser tab, restock it now (normally we restock on entry)
2819   if ( g_categories [ ui_category ] -> fspath ) {
2820     printf ( "Restock on start: '%s'\n", g_categories [ ui_category ] -> fspath );
2821     category_fs_restock ( g_categories [ ui_category ] );
2822   }
2823
2824   // redraw all
2825   render_mask |= CHANGED_EVERYTHING;
2826
2827   // if deferred icon load, kick off the thread now
2828   if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_icons_later", 0 ) == 1 ) {
2829     ui_start_defered_icon_thread();
2830   } // deferred icon load
2831
2832   return;
2833 }
2834
2835 unsigned char ui_threaded_defered_icon ( void *p ) {
2836   extern pnd_box_handle g_active_apps;
2837
2838   unsigned char maxwidth, maxheight;
2839   maxwidth = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_width", 50 );
2840   maxheight = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_height", 50 );
2841
2842   pnd_disco_t *iter;
2843
2844   g_icon_thread_busy = 1;
2845
2846   // work at it in order within current category
2847
2848   mm_appref_t *refiter = g_categories [ ui_category ] -> refs;
2849   while ( refiter && ! g_icon_thread_stop ) {
2850     iter = refiter -> ref;
2851
2852     // has an icon that is not already cached?
2853     if ( ( iter -> pnd_icon_pos ) ||
2854          ( iter -> icon && iter -> object_flags & PND_DISCO_CUSTOM1 )
2855        )
2856     {
2857
2858       // try to cache it?
2859       if ( ! cache_icon ( iter, maxwidth, maxheight ) ) {
2860         //pnd_log ( pndn_warning, "  Couldn't load icon: '%s'\n", IFNULL(iter->title_en,"No Name") );
2861
2862       } else {
2863
2864         // trigger that we completed
2865         SDL_Event e;
2866         bzero ( &e, sizeof(SDL_Event) );
2867         e.type = SDL_USEREVENT;
2868         e.user.code = sdl_user_finishedicon;
2869         SDL_PushEvent ( &e );
2870
2871         //pnd_log ( pndn_warning, "  Finished deferred load icon: '%s'\n", IFNULL(iter->title_en,"No Name") );
2872         //usleep ( pnd_conf_get_as_int_d ( g_conf, "minimenu.defer_icon_us", 50000 ) );
2873
2874       }
2875
2876       // avoid churn
2877       iter -> pnd_icon_pos = 0;
2878       if ( iter -> icon ) {
2879         free ( iter -> icon );
2880         iter -> icon = NULL;
2881       }
2882
2883       // let user do something..
2884       SDL_Delay ( 200 );
2885
2886     } // has icon
2887
2888     refiter = refiter -> next;
2889   }
2890
2891   // mark as done
2892   g_icon_thread_busy = 0;
2893
2894   return ( 0 );
2895 }
2896
2897 void ui_show_hourglass ( unsigned char updaterect ) {
2898
2899   SDL_Rect dest;
2900   SDL_Surface *s = g_imagecache [ IMG_HOURGLASS ].i;
2901
2902   dest.x = ( 800 - s -> w ) / 2;
2903   dest.y = ( 480 - s -> h ) / 2;
2904
2905   SDL_BlitSurface ( s, NULL /* whole image */, sdl_realscreen, &dest );
2906
2907   if ( updaterect ) {
2908     SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2909   }
2910
2911   return;
2912 }
2913
2914 unsigned char ui_pick_skin ( void ) {
2915 #define MAXSKINS 10
2916   char *skins [ MAXSKINS ];
2917   unsigned char iter;
2918
2919   char *searchpath = pnd_conf_get_as_char ( g_conf, "minimenu.skin_searchpath" );
2920   char tempname [ 100 ];
2921
2922   iter = 0;
2923
2924   skins [ iter++ ] = "No skin change";
2925
2926   SEARCHPATH_PRE
2927   {
2928     DIR *d = opendir ( buffer );
2929
2930     if ( d ) {
2931       struct dirent *dd;
2932
2933       while ( ( dd = readdir ( d ) ) ) {
2934
2935         if ( dd -> d_name [ 0 ] == '.' ) {
2936           // ignore
2937         } else if ( ( dd -> d_type == DT_DIR || dd -> d_type == DT_UNKNOWN ) &&
2938                     iter < MAXSKINS )
2939         {
2940           snprintf ( tempname, 100, "Skin: %s", dd -> d_name );
2941           skins [ iter++ ] = strdup ( tempname );
2942         }
2943
2944       }
2945
2946       closedir ( d );
2947     }
2948
2949   }
2950   SEARCHPATH_POST
2951
2952   int sel = ui_modal_single_menu ( skins, iter, "Skins", "Enter to select; other to return." );
2953
2954   // did they pick one?
2955   if ( sel > 0 ) {
2956     FILE *f;
2957
2958     char *s = strdup ( pnd_conf_get_as_char ( g_conf, "minimenu.skin_selected" ) );
2959     s = pnd_expand_tilde ( s );
2960
2961     f = fopen ( s, "w" );
2962
2963     free ( s );
2964
2965     if ( f ) {
2966       fprintf ( f, "%s\n", skins [ sel ] + 6 );
2967       fclose ( f );
2968     }
2969
2970     return ( 1 );
2971   }
2972
2973   return ( 0 );
2974 }
2975
2976 void ui_aboutscreen ( char *textpath ) {
2977 #define PIXELW 7
2978 #define PIXELH 7
2979 #define MARGINW 3
2980 #define MARGINH 3
2981 #define SCRW 800
2982 #define SCRH 480
2983 #define ROWS SCRH / ( PIXELH + MARGINH )
2984 #define COLS SCRW / ( PIXELW + MARGINW )
2985
2986   unsigned char pixelboard [ ROWS * COLS ]; // pixel heat
2987   bzero ( pixelboard, ROWS * COLS );
2988
2989   SDL_Surface *rtext;
2990   SDL_Rect r;
2991
2992   SDL_Color rtextc = { 200, 200, 200, 100 };
2993
2994   // pixel scroller
2995   char *textloop [ 500 ];
2996   unsigned int textmax = 0;
2997   bzero ( textloop, 500 * sizeof(char*) );
2998
2999   // cursor scroller
3000   char cbuffer [ 50000 ];
3001   bzero ( cbuffer, 50000 );
3002   unsigned int crevealed = 0;
3003
3004   FILE *f = fopen ( textpath, "r" );
3005
3006   if ( ! f ) {
3007     pnd_log ( pndn_error, "ERROR: Couldn't open about text: %s\n", textpath );
3008     return;
3009   }
3010
3011   char textbuf [ 100 ];
3012   while ( fgets ( textbuf, 100, f ) ) {
3013
3014     // add to full buffer
3015     strncat ( cbuffer, textbuf, 50000 );
3016
3017     // chomp
3018     if ( strchr ( textbuf, '\n' ) ) {
3019       * strchr ( textbuf, '\n' ) = '\0';
3020     }
3021
3022     // add to pixel loop
3023     if ( 1||textbuf [ 0 ] ) {
3024       textloop [ textmax ] = strdup ( textbuf );
3025       textmax++;
3026     }
3027
3028   } // while fgets
3029
3030   fclose ( f );
3031
3032   unsigned int textiter = 0;
3033   while ( textiter < textmax ) {
3034     char *text = textloop [ textiter ];
3035
3036     rtext = NULL;
3037     if ( text [ 0 ] ) {
3038       // render to surface
3039       rtext = TTF_RenderText_Blended ( g_grid_font, text, rtextc );
3040
3041       // render font to pixelboard
3042       unsigned int px, py;
3043       unsigned char *ph;
3044       unsigned int *pixels = rtext -> pixels;
3045       unsigned char cr, cg, cb, ca;
3046       for ( py = 0; py < rtext -> h; py ++ ) {
3047         for ( px = 0; px < ( rtext -> w > COLS ? COLS : rtext -> w ); px++ ) {
3048
3049           SDL_GetRGBA ( pixels [ ( py * rtext -> pitch / 4 ) + px ],
3050                         rtext -> format, &cr, &cg, &cb, &ca );
3051
3052           if ( ca != 0 ) {
3053
3054             ph = pixelboard + ( /*y offset */ 30 * COLS ) + ( py * COLS ) + px /* / 2 */;
3055
3056             if ( *ph < 100 ) {
3057               *ph = 100;
3058             }
3059
3060             ca /= 5;
3061             if ( *ph + ca < 250 ) {
3062               *ph += ca;
3063             }
3064
3065           } // got a pixel?
3066
3067         } // x
3068       } // y
3069
3070     } // got text?
3071
3072     unsigned int runcount = 10;
3073     while ( runcount-- ) {
3074
3075       // clear display
3076       SDL_FillRect( sdl_realscreen, NULL /* whole */, 0 );
3077
3078       // render pixelboard
3079       unsigned int x, y;
3080       unsigned int c;
3081       for ( y = 0; y < ROWS; y++ ) {
3082         for ( x = 0; x < COLS; x++ ) {
3083
3084           if ( 1||pixelboard [ ( y * COLS ) + x ] ) {
3085
3086             // position
3087             r.x = x * ( PIXELW + MARGINW );
3088             r.y = y * ( PIXELH + MARGINH );
3089             r.w = PIXELW;
3090             r.h = PIXELH;
3091             // heat -> colour
3092             c = SDL_MapRGB ( sdl_realscreen -> format, 100 /* r */, 0 /* g */, pixelboard [ ( y * COLS ) + x ] );
3093             // render
3094             SDL_FillRect( sdl_realscreen, &r /* whole */, c );
3095
3096           }
3097
3098         } // x
3099       } // y
3100
3101       // cool pixels
3102       unsigned char *pc = pixelboard;
3103       for ( y = 0; y < ROWS; y++ ) {
3104         for ( x = 0; x < COLS; x++ ) {
3105
3106           if ( *pc > 10 ) {
3107             (*pc) -= 3;
3108           }
3109
3110           pc++;
3111         } // x
3112       } // y
3113
3114       // slide pixels upwards
3115       memmove ( pixelboard, pixelboard + COLS, ( COLS * ROWS ) - COLS );
3116
3117       // render actual readable text
3118       {
3119
3120         // display up to cursor
3121         SDL_Rect dest;
3122         unsigned int cdraw = 0;
3123         SDL_Surface *cs;
3124         char ctb [ 2 ];
3125
3126         if ( crevealed > 200 ) {
3127           cdraw = crevealed - 200;
3128         }
3129
3130         dest.x = 400;
3131         dest.y = 20;
3132
3133         for ( ; cdraw < crevealed; cdraw++ ) {
3134           ctb [ 0 ] = cbuffer [ cdraw ];
3135           ctb [ 1 ] = '\0';
3136           // move over or down
3137           if ( cbuffer [ cdraw ] == '\n' ) {
3138             // EOL
3139             dest.x = 400;
3140             dest.y += 14;
3141
3142             if ( dest.y > 450 ) {
3143               dest.y = 450;
3144             }
3145
3146           } else {
3147             // draw the char
3148             cs = TTF_RenderText_Blended ( g_tab_font, ctb, rtextc );
3149             if ( cs ) {
3150               SDL_BlitSurface ( cs, NULL /* all */, sdl_realscreen, &dest );
3151               SDL_FreeSurface ( cs );
3152               // over
3153               dest.x += cs -> w;
3154             }
3155           }
3156
3157         }
3158
3159         dest.w = 10;
3160         dest.h = 20;
3161         SDL_FillRect ( sdl_realscreen, &dest /* whole */, 220 );
3162
3163         // increment cursor to next character
3164         if ( cbuffer [ crevealed ] != '\0' ) {
3165           crevealed++;
3166         }
3167
3168       } // draw cursor text
3169
3170       // reveal
3171       //
3172       SDL_UpdateRect ( sdl_realscreen, 0, 0, 0, 0 ); // whole screen
3173
3174       usleep ( 50000 );
3175
3176       // any button? if so, about
3177       {
3178         SDL_PumpEvents();
3179
3180         SDL_Event e;
3181
3182         if ( SDL_PeepEvents ( &e, 1, SDL_GETEVENT, SDL_EVENTMASK(/*SDL_KEYUP|*/SDL_KEYDOWN) ) > 0 ) {
3183           return;
3184         }
3185
3186       }
3187
3188     } // while cooling
3189
3190     if ( rtext ) {
3191       SDL_FreeSurface ( rtext );
3192     }
3193
3194     textiter++;
3195   } // while more text
3196
3197   // free up
3198   unsigned int i;
3199   for ( i = 0; i < textmax; i++ ) {
3200     if ( textloop [ i ] ) {
3201       free ( textloop [ i ] );
3202       textloop [ i ] = 0;
3203     }
3204   }
3205
3206   return;
3207 }
3208
3209 void ui_revealscreen ( void ) {
3210   char *labels [ 500 ];
3211   unsigned int labelmax = 0;
3212   unsigned int i;
3213   char fulllabel [ 200 ];
3214
3215   if ( ! category_count ( CFHIDDEN ) ) {
3216     return; // nothing to do
3217   }
3218
3219   // switch to hidden categories
3220   category_publish ( CFHIDDEN, NULL );
3221
3222   // build up labels to show in menu
3223   for ( i = 0; i < g_categorycount; i++ ) {
3224
3225     if ( g_categories [ i ] -> parent_catname ) {
3226       sprintf ( fulllabel, "%s [%s]", g_categories [ i ] -> catname, g_categories [ i ] -> parent_catname );
3227     } else {
3228       sprintf ( fulllabel, "%s", g_categories [ i ] -> catname );
3229     }
3230
3231     labels [ labelmax++ ] = strdup ( fulllabel );
3232   }
3233
3234   // show menu
3235   int sel = ui_modal_single_menu ( labels, labelmax, "Temporary Category Reveal",
3236                                    "Enter to select; other to return." );
3237
3238   // if selected, try to set this guy to visible
3239   if ( sel >= 0 ) {
3240
3241     // fix up category name, if its been hacked
3242 #if 0 // prepending and .. wtf crap is this
3243     if ( strchr ( g_categories [ sel ] -> catname, '.' ) ) {
3244       char *t = g_categories [ sel ] -> catname;
3245       g_categories [ sel ] -> catname = strdup ( strchr ( g_categories [ sel ] -> catname, '.' ) + 1 );
3246       free ( t );
3247     }
3248 #endif
3249
3250     // reflag this guy to be visible
3251     g_categories [ sel ] -> catflags = CFNORMAL;
3252
3253     // switch to the new category.. cache name.
3254     char *switch_to_name = g_categories [ sel ] -> catname;
3255
3256     // republish categories
3257     category_publish ( CFNORMAL, NULL );
3258
3259     // switch to the new category.. with the cached name!
3260     ui_category = category_index ( switch_to_name );
3261
3262     // ensure visibility
3263     unsigned int screen_width = ui_display_context.screen_width;
3264     unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
3265     if ( ui_category > ui_catshift + ( screen_width / tab_width ) - 1 ) {
3266       ui_catshift = ui_category - ( screen_width / tab_width ) + 1;
3267     }
3268
3269   }
3270
3271   // republish categories
3272   category_publish ( CFNORMAL, NULL );
3273
3274   // redraw tabs
3275   render_mask |= CHANGED_CATEGORY;
3276   ui_start_defered_icon_thread();
3277
3278   return;
3279 }
3280
3281 void ui_recache_context ( ui_context_t *c ) {
3282
3283   c -> screen_width = pnd_conf_get_as_int_d ( g_conf, "display.screen_width", 800 );
3284
3285   c -> font_rgba_r = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_r", 200 );
3286   c -> font_rgba_g = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_g", 200 );
3287   c -> font_rgba_b = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_b", 200 );
3288   c -> font_rgba_a = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_a", 100 );
3289
3290   c -> grid_offset_x = pnd_conf_get_as_int ( g_conf, "grid.grid_offset_x" );
3291   c -> grid_offset_y = pnd_conf_get_as_int ( g_conf, "grid.grid_offset_y" );
3292
3293   c -> icon_offset_x = pnd_conf_get_as_int ( g_conf, "grid.icon_offset_x" );
3294   c -> icon_offset_y = pnd_conf_get_as_int ( g_conf, "grid.icon_offset_y" );
3295   c -> icon_max_width = pnd_conf_get_as_int ( g_conf, "grid.icon_max_width" );
3296   c -> icon_max_height = pnd_conf_get_as_int ( g_conf, "grid.icon_max_height" );
3297   c -> sel_icon_offset_x = pnd_conf_get_as_int_d ( g_conf, "grid.sel_offoffset_x", 0 );
3298   c -> sel_icon_offset_y = pnd_conf_get_as_int_d ( g_conf, "grid.sel_offoffset_y", 0 );
3299
3300   c -> text_width = pnd_conf_get_as_int ( g_conf, "grid.text_width" );
3301   c -> text_clip_x = pnd_conf_get_as_int ( g_conf, "grid.text_clip_x" );
3302   c -> text_offset_x = pnd_conf_get_as_int ( g_conf, "grid.text_offset_x" );
3303   c -> text_offset_y = pnd_conf_get_as_int ( g_conf, "grid.text_offset_y" );
3304   c -> text_hilite_offset_y = pnd_conf_get_as_int ( g_conf, "grid.text_hilite_offset_y" );
3305
3306   c -> row_max = pnd_conf_get_as_int_d ( g_conf, "grid.row_max", 4 );
3307   c -> col_max = pnd_conf_get_as_int_d ( g_conf, "grid.col_max", 5 );
3308
3309   c -> cell_width = pnd_conf_get_as_int ( g_conf, "grid.cell_width" );
3310   c -> cell_height = pnd_conf_get_as_int ( g_conf, "grid.cell_height" );
3311
3312   c -> arrow_bar_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_x", 450 );
3313   c -> arrow_bar_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_y", 100 );
3314   c -> arrow_bar_clip_w = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_clip_w", 10 );
3315   c -> arrow_bar_clip_h = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_clip_h", 100 );
3316   c -> arrow_up_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_up_x", 450 );
3317   c -> arrow_up_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_up_y", 80 );
3318   c -> arrow_down_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_down_x", 450 );
3319   c -> arrow_down_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_down_y", 80 );
3320
3321   // font colour
3322   SDL_Color tmp = { c -> font_rgba_r, c -> font_rgba_g, c -> font_rgba_b, c -> font_rgba_a };
3323   c -> fontcolor = tmp;
3324
3325   // now that we've got 'normal' (detail pane shown) param's, lets check if detail pane
3326   // is hidden; if so, override some values with those alternate skin values where possible.
3327   if ( ui_detail_hidden ) {
3328     // if detail panel is hidden, and theme cannot support it, unhide the bloody thing. (This may help
3329     // when someone is amid theme hacking or changing.)
3330     if ( ! ui_is_detail_hideable() ) {
3331       ui_detail_hidden = 0;
3332     }
3333
3334     // still hidden?
3335     if ( ui_detail_hidden ) {
3336
3337       c -> row_max = pnd_conf_get_as_int_d ( g_conf, "grid.row_max_w", c -> row_max );
3338       c -> col_max = pnd_conf_get_as_int_d ( g_conf, "grid.col_max_w", c -> col_max );
3339
3340       c -> cell_width = pnd_conf_get_as_int_d ( g_conf, "grid.cell_width_w", c -> cell_width );
3341       c -> cell_height = pnd_conf_get_as_int_d ( g_conf, "grid.cell_height_w", c -> cell_height );
3342
3343       c -> arrow_bar_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_x_w", 450 );
3344       c -> arrow_bar_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_bar_y_w", 100 );
3345       c -> arrow_up_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_up_x_w", 450 );
3346       c -> arrow_up_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_up_y_w", 80 );
3347       c -> arrow_down_x = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_down_x_w", 450 );
3348       c -> arrow_down_y = pnd_conf_get_as_int_d ( g_conf, "grid.arrow_down_y_w", 80 );
3349
3350     } // if detail hidden.. still.
3351
3352   } // if detail hidden
3353
3354   return;
3355 }
3356
3357 unsigned char ui_is_detail_hideable ( void ) {
3358
3359   // if skin has a bit of info for wide-mode, we assume wide-mode is available
3360   if ( pnd_conf_get_as_char ( g_conf, "grid.row_max_w" ) != NULL ) {
3361     return ( 1 );
3362   }
3363
3364   // else not!
3365   return ( 0 );
3366 }
3367
3368 void ui_toggle_detail_pane ( void ) {
3369
3370   // no bitmask trickery here; I like it to be stand-out obvious at 3am.
3371
3372   if ( ui_detail_hidden ) {
3373     ui_detail_hidden = 0;
3374   } else {
3375     ui_detail_hidden = 1;
3376   }
3377
3378   // repull skin config
3379   ui_recache_context ( &ui_display_context );
3380
3381   // redraw
3382   render_mask |= CHANGED_EVERYTHING;
3383
3384   return;
3385 }
3386
3387 void ui_menu_context ( mm_appref_t *a ) {
3388
3389   unsigned char rescan_apps = 0;
3390   unsigned char context_alive = 1;
3391
3392   enum {
3393     context_done = 0,
3394     context_file_info,
3395     context_file_delete,
3396     context_app_info,
3397     context_app_hide,
3398     context_app_recategorize,
3399     context_app_recategorize_sub,
3400     context_app_rename,
3401     context_app_cpuspeed,
3402     context_app_run,
3403     context_app_notes1,
3404     context_app_notes2,
3405     context_app_notes3,
3406     context_menu_max
3407   };
3408
3409   char *verbiage[] = {
3410     "Done (return to grid)",      // context_done
3411     "Get info about file/dir",    // context_file_info
3412     "Delete file/dir",            // context_file_delete
3413     "Get info",                   // context_app_info
3414     "Hide application",           //             hide
3415     "Recategorize",               //             recategorize
3416     "Recategorize subcategory",   //             recategorize
3417     "Change displayed title",     //             rename
3418     "Set CPU speed for launch",   //             cpuspeed
3419     "Run application",            //             run
3420     "Edit notes line 1",          //             notes1
3421     "Edit notes line 2",          //             notes2
3422     "Edit notes line 3",          //             notes3
3423   };
3424
3425   unsigned short int menu [ context_menu_max ];
3426   char *menustring [ context_menu_max ];
3427   unsigned char menumax = 0;
3428
3429   // ++ done
3430   menu [ menumax ] = context_done; menustring [ menumax++ ] = verbiage [ context_done ];
3431
3432   // hook up appropriate menu options based on tab-type and object-type
3433   if ( g_categories [ ui_category ] -> fspath ) {
3434     return; // TBD
3435     menu [ menumax ] = context_file_info; menustring [ menumax++ ] = verbiage [ context_file_info ];
3436     menu [ menumax ] = context_file_delete; menustring [ menumax++ ] = verbiage [ context_file_delete ];
3437   } else {
3438
3439     if ( a -> ref -> object_type == pnd_object_type_directory ) {
3440       return; // don't do anything if the guy is a subcat-as-folder
3441     }
3442
3443     //menu [ menumax ] = context_app_info; menustring [ menumax++ ] = verbiage [ context_app_info ];
3444     menu [ menumax ] = context_app_run; menustring [ menumax++ ] = verbiage [ context_app_run ];
3445     menu [ menumax ] = context_app_hide; menustring [ menumax++ ] = verbiage [ context_app_hide ];
3446     menu [ menumax ] = context_app_recategorize; menustring [ menumax++ ] = verbiage [ context_app_recategorize ];
3447     menu [ menumax ] = context_app_recategorize_sub; menustring [ menumax++ ] = verbiage [ context_app_recategorize_sub ];
3448     menu [ menumax ] = context_app_rename; menustring [ menumax++ ] = verbiage [ context_app_rename ];
3449     menu [ menumax ] = context_app_cpuspeed; menustring [ menumax++ ] = verbiage [ context_app_cpuspeed ];
3450     menu [ menumax ] = context_app_notes1; menustring [ menumax++ ] = verbiage [ context_app_notes1 ];
3451     menu [ menumax ] = context_app_notes2; menustring [ menumax++ ] = verbiage [ context_app_notes2 ];
3452     menu [ menumax ] = context_app_notes3; menustring [ menumax++ ] = verbiage [ context_app_notes3 ];
3453   }
3454
3455   // operate the menu
3456   while ( context_alive ) {
3457
3458     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 */ );
3459
3460     if ( sel < 0 ) {
3461       context_alive = 0;
3462
3463     } else {
3464
3465       switch ( menu [ sel ] ) {
3466
3467       case context_done:
3468         context_alive = 0;
3469         break;
3470
3471       case context_file_info:
3472         break;
3473
3474       case context_file_delete:
3475         //ui_menu_twoby ( "Delete - Are you sure?", "B/enter; other to cancel", "Delete", "Do not delete" );
3476         break;
3477
3478       case context_app_info:
3479         break;
3480
3481       case context_app_hide:
3482         {
3483           // determine key
3484           char confkey [ 1000 ];
3485           snprintf ( confkey, 999, "%s.%s", "appshow", a -> ref -> unique_id );
3486
3487           // turn app 'off'
3488           pnd_conf_set_char ( g_conf, confkey, "0" );
3489
3490           // write conf, so it will take next time
3491           conf_write ( g_conf, conf_determine_location ( g_conf ) );
3492           conf_write ( g_conf, CONF_PREF_TEMPPATH );
3493
3494           // can we just 'hide' this guy without reloading all apps? (this is for you, EvilDragon)
3495           if ( 0 ) {
3496             //
3497             // DOESN'T WORK YET; other parts of app are still hanging onto some values and blow up
3498             //
3499             char *uid = strdup ( a -> ref -> unique_id );
3500             unsigned int i;
3501             for ( i = 0; i < g_categorycount; i++ ) {
3502               mm_appref_t *p = g_categories [ i ] -> refs;
3503               mm_appref_t *n;
3504               while ( p ) {
3505                 n = p -> next;
3506
3507                 if ( strcmp ( p -> ref -> unique_id, uid ) == 0 ) {
3508                   free ( p );
3509                   if ( g_categories [ i ] -> refcount ) {
3510                     g_categories [ i ] -> refcount--;
3511                   }
3512                 }
3513
3514                 p = n;
3515               } // while for each appref
3516             } // for each cat/tab
3517
3518             free ( uid );
3519
3520           } else {
3521             // request rescan and wrap up
3522             rescan_apps++;
3523           }
3524
3525           context_alive = 0; // nolonger visible, so lets just get out
3526
3527         }
3528
3529         break;
3530
3531       case context_app_recategorize:
3532         {
3533           char *opts [ 250 ];
3534           unsigned char optmax = 0;
3535           unsigned char i;
3536
3537           // show custom categories
3538           if ( mmcustom_setup() ) {
3539
3540             for ( i = 0; i < mmcustom_count; i++ ) {
3541               if ( mmcustom_complete [ i ].parent_cat == NULL ) {
3542                 opts [ optmax++ ] = mmcustom_complete [ i ].cat;
3543               }
3544             }
3545
3546           }
3547
3548           // show FD categories
3549           i = 2; // skip first two - Other and NoParentCategory
3550           while ( 1 ) {
3551
3552             if ( ! freedesktop_complete [ i ].cat ) {
3553               break;
3554             }
3555
3556             if ( ! freedesktop_complete [ i ].parent_cat ) {
3557               opts [ optmax++ ] = freedesktop_complete [ i ].cat;
3558             }
3559
3560             i++;
3561           } // while
3562
3563           // picker
3564           char prompt [ 101 ];
3565           snprintf ( prompt, 100, "Pick category [%s]", a -> ref -> main_category ? a -> ref -> main_category : "NoParentCategory" );
3566
3567           int sel = ui_modal_single_menu ( opts, optmax, prompt /*"Select parent category"*/, "Enter to select; other to skip." );
3568
3569           if ( sel >= 0 ) {
3570             char confirm [ 1001 ];
3571             snprintf ( confirm, 1000, "Confirm: %s", opts [ sel ] );
3572
3573             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm categorization", "Do not set category" ) == 1 ) {
3574               ovr_replace_or_add ( a, "maincategory", opts [ sel ] );
3575               rescan_apps++;
3576               // when changing main cat, reset subcat, otherwise you go from Game/Emu to Network/Emu and get sent to Other right away
3577               ovr_replace_or_add ( a, "maincategorysub1", freedesktop_complete [ 2 ].cat );
3578             }
3579
3580           }
3581
3582           if ( mmcustom_is_ready() ) {
3583             mmcustom_shutdown();
3584           }
3585
3586         }
3587         break;
3588
3589       case context_app_recategorize_sub:
3590         {
3591           char *opts [ 250 ];
3592           unsigned char optmax = 0;
3593           unsigned char i = 0;
3594
3595           char *whichparentarewe;
3596           if ( g_categories [ ui_category ] -> parent_catname ) {
3597             whichparentarewe = g_categories [ ui_category ] -> parent_catname;
3598           } else {
3599             whichparentarewe = g_categories [ ui_category ] -> catname;
3600           }
3601
3602           // add NoSubcategory magic one
3603           opts [ optmax++ ] = freedesktop_complete [ 2 ].cat;
3604
3605           // add custom categories
3606           if ( mmcustom_setup() ) {
3607
3608             for ( i = 0; i < mmcustom_count; i++ ) {
3609               if ( mmcustom_complete [ i ].parent_cat && strcmp ( mmcustom_complete [ i ].parent_cat, whichparentarewe ) == 0  ) {
3610                 opts [ optmax++ ] = mmcustom_complete [ i ].cat;
3611               }
3612             }
3613
3614           }
3615
3616           // add FD categories
3617           while ( 1 ) {
3618
3619             if ( ! freedesktop_complete [ i ].cat ) {
3620               break;
3621             }
3622
3623             if ( ( freedesktop_complete [ i ].parent_cat ) &&
3624                  ( strcasecmp ( freedesktop_complete [ i ].parent_cat, whichparentarewe ) == 0 )
3625                )
3626             {
3627               opts [ optmax++ ] = freedesktop_complete [ i ].cat;
3628             }
3629
3630             i++;
3631           } // while
3632
3633           char prompt [ 101 ];
3634           //snprintf ( prompt, 100, "Currently: %s", a -> ref -> main_category1 ? a -> ref -> main_category1 : "NoSubcategory" );
3635           snprintf ( prompt, 100, "%s [%s]", a -> ref -> main_category1 ? a -> ref -> main_category1 : "NoSubcategory", whichparentarewe );
3636
3637           int sel = ui_modal_single_menu ( opts, optmax, prompt /*"Select subcategory"*/, "Enter to select; other to skip." );
3638
3639           if ( sel >= 0 ) {
3640             char confirm [ 1001 ];
3641             snprintf ( confirm, 1000, "Confirm: %s", opts [ sel ] );
3642
3643             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm sub-categorization", "Do not set sub-category" ) == 1 ) {
3644               ovr_replace_or_add ( a, "maincategorysub1", opts [ sel ] );
3645               rescan_apps++;
3646             }
3647
3648           }
3649
3650           if ( mmcustom_is_ready() ) {
3651             mmcustom_shutdown();
3652           }
3653
3654         }
3655         break;
3656
3657       case context_app_rename:
3658         {
3659           char namebuf [ 101 ];
3660           unsigned char changed;
3661
3662           changed = ui_menu_get_text_line ( "Rename application", "Use keyboard; Enter when done.",
3663                                             a -> ref -> title_en ? a -> ref -> title_en : "blank", namebuf, 30, 0 /* alphanumeric */ );
3664
3665           if ( changed ) {
3666             char confirm [ 1001 ];
3667             snprintf ( confirm, 1000, "Confirm: %s", namebuf );
3668
3669             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm rename", "Do not rename" ) == 1 ) {
3670               ovr_replace_or_add ( a, "title", namebuf );
3671               rescan_apps++;
3672             }
3673
3674           }
3675
3676         }
3677
3678         break;
3679
3680       case context_app_cpuspeed:
3681         {
3682           char namebuf [ 101 ];
3683           unsigned char changed;
3684
3685           changed = ui_menu_get_text_line ( "Specify runspeed", "Use keyboard; Enter when done.",
3686                                             a -> ref -> clockspeed ? a -> ref -> clockspeed : "500", namebuf, 6, 1 /* numeric */ );
3687
3688           if ( changed ) {
3689             char confirm [ 1001 ];
3690             snprintf ( confirm, 1000, "Confirm: %s", namebuf );
3691
3692             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm clockspeed", "Do not set" ) == 1 ) {
3693               ovr_replace_or_add ( a, "clockspeed", namebuf );
3694               rescan_apps++;
3695             }
3696
3697           }
3698
3699         }
3700
3701         break;
3702
3703       case context_app_run:
3704         ui_push_exec();
3705         break;
3706
3707       case context_app_notes1:
3708       case context_app_notes2:
3709       case context_app_notes3:
3710         {
3711           char namebuf [ 101 ] = "";
3712
3713           char key [ 501 ];
3714           unsigned char notenum;
3715
3716           // which note line?
3717           if ( menu [ sel ] == context_app_notes1 ) {
3718             notenum = 1;
3719           } else if ( menu [ sel ] == context_app_notes2 ) {
3720             notenum = 2;
3721           } else if ( menu [ sel ] == context_app_notes3 ) {
3722             notenum = 3;
3723           }
3724
3725           // figure out key for looking up existing, and for storing replacement
3726           snprintf ( key, 500, "Application-%u.note-%u", a -> ref -> subapp_number, notenum );
3727
3728           // do we have existing value?
3729           if ( a -> ovrh ) {
3730             char *existing = pnd_conf_get_as_char ( a -> ovrh, key );
3731             if ( existing ) {
3732               strncpy ( namebuf, existing, 100 );
3733             }
3734           }
3735
3736           unsigned char changed;
3737
3738           changed = ui_menu_get_text_line ( "Enter replacement note", "Use keyboard; Enter when done.",
3739                                             namebuf, namebuf, 30, 0 /* not-numeric-forced */ );
3740
3741           if ( changed ) {
3742             ovr_replace_or_add ( a, strchr ( key, '.' ) + 1, namebuf );
3743             rescan_apps++;
3744           }
3745
3746         }
3747         break;
3748
3749       default:
3750         return;
3751
3752       } // switch
3753
3754     } // if useful return
3755
3756   } // menu is alive?
3757
3758   // rescan apps?
3759   if ( rescan_apps ) {
3760     applications_free();
3761     applications_scan();
3762   }
3763
3764   return;
3765 }
3766
3767 unsigned char ui_menu_oneby ( char *title, char *footer, char *one ) {
3768   char *opts [ 2 ];
3769   opts [ 0 ] = one;
3770   int sel = ui_modal_single_menu ( opts, 1, title, footer );
3771   if ( sel < 0 ) {
3772     return ( 0 );
3773   }
3774   return ( sel + 1 );
3775 }
3776
3777 unsigned char ui_menu_twoby ( char *title, char *footer, char *one, char *two ) {
3778   char *opts [ 3 ];
3779   opts [ 0 ] = one;
3780   opts [ 1 ] = two;
3781   int sel = ui_modal_single_menu ( opts, 2, title, footer );
3782   if ( sel < 0 ) {
3783     return ( 0 );
3784   }
3785   return ( sel + 1 );
3786 }
3787
3788 unsigned char ui_menu_get_text_line ( char *title, char *footer, char *initialvalue,
3789                                       char *r_buffer, unsigned char maxlen, unsigned char numbersonlyp )
3790 {
3791   SDL_Rect rects [ 40 ];
3792   SDL_Rect *dest = rects;
3793   SDL_Rect src;
3794   SDL_Surface *rtext;
3795
3796   char hacktext [ 1024 ];
3797   unsigned char shifted = 0;
3798
3799   bzero ( rects, sizeof(SDL_Rect) * 40 );
3800
3801   if ( initialvalue ) {
3802     if ( initialvalue == r_buffer ) {
3803       // already good to go
3804     } else {
3805       strncpy ( r_buffer, initialvalue, maxlen );
3806     }
3807   } else {
3808     bzero ( r_buffer, maxlen );
3809   }
3810
3811   while ( 1 ) {
3812
3813     // clear
3814     dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
3815     dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
3816     dest -> w = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> w;
3817     dest -> h = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h;
3818     SDL_FillRect( sdl_realscreen, dest, 0 );
3819
3820     // show dialog background
3821     if ( g_imagecache [ IMG_DETAIL_BG ].i ) {
3822       src.x = 0;
3823       src.y = 0;
3824       src.w = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> w;
3825       src.h = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> h;
3826       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
3827       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
3828       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
3829       dest++;
3830     }
3831
3832     // show dialog frame
3833     if ( g_imagecache [ IMG_DETAIL_PANEL ].i ) {
3834       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
3835       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
3836       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_PANEL ].i, NULL /* whole image */, sdl_realscreen, dest );
3837       dest++;
3838     }
3839
3840     // show header
3841     if ( title ) {
3842       rtext = TTF_RenderText_Blended ( g_tab_font, title, ui_display_context.fontcolor );
3843       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
3844       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 20;
3845       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
3846       SDL_FreeSurface ( rtext );
3847       dest++;
3848     }
3849
3850     // show footer
3851     if ( footer ) {
3852       rtext = TTF_RenderText_Blended ( g_tab_font, footer, ui_display_context.fontcolor );
3853       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
3854       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) +
3855         ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h
3856         - 60;
3857       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
3858       SDL_FreeSurface ( rtext );
3859       dest++;
3860     }
3861
3862     // show text line - and embed cursor
3863     dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
3864     dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 40 + ( 20 * ( 0/*i*/ + 1 - 0/*first_visible*/ ) );
3865
3866     strncpy ( hacktext, r_buffer, 1000 );
3867     strncat ( hacktext, "\n", 1000 ); // add [] in most fonts
3868
3869     rtext = TTF_RenderText_Blended ( g_tab_font, hacktext, ui_display_context.fontcolor );
3870     SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
3871     SDL_FreeSurface ( rtext );
3872     dest++;
3873
3874     // update all the rects and send it all to sdl
3875     SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
3876     dest = rects;
3877
3878     // check for input
3879     SDL_Event event;
3880     while ( SDL_WaitEvent ( &event ) ) {
3881
3882       switch ( event.type ) {
3883
3884       case SDL_KEYUP:
3885         if ( event.key.keysym.sym == SDLK_LSHIFT || event.key.keysym.sym == SDLK_RSHIFT ) {
3886           shifted = 0;
3887         }
3888         break;
3889
3890       case SDL_KEYDOWN:
3891
3892         if ( event.key.keysym.sym == SDLK_LEFT || event.key.keysym.sym == SDLK_BACKSPACE ) {
3893           if ( strlen ( r_buffer ) > 0 ) {
3894             char *eol = strchr ( r_buffer, '\0' );
3895             *( eol - 1 ) = '\0';
3896           }
3897
3898         } else if ( event.key.keysym.sym == SDLK_UP ) {
3899           r_buffer [ 0 ] = '\0'; // truncate!
3900
3901         } else if ( event.key.keysym.sym == SDLK_RETURN || event.key.keysym.sym == SDLK_END ) { // return, or "B"
3902           // on Enter/Return or B, if the buffer has 1 or more chars, we return it as valid.. otherwise, invalid.
3903           if ( strlen ( r_buffer ) > 0 ) {
3904             return ( 1 );
3905           }
3906           return ( 0 );
3907
3908         } else if ( event.key.keysym.sym == SDLK_LSHIFT || event.key.keysym.sym == SDLK_RSHIFT ) {
3909           shifted = 1;
3910
3911         } else if ( event.key.keysym.sym == SDLK_ESCAPE ||
3912                     event.key.keysym.sym == SDLK_PAGEUP ||
3913                     event.key.keysym.sym == SDLK_PAGEDOWN ||
3914                     event.key.keysym.sym == SDLK_HOME
3915                   )
3916         {
3917           return ( 0 );
3918
3919         } else {
3920
3921           if ( isprint(event.key.keysym.sym) ) {
3922
3923             unsigned char good = 1;
3924
3925             if ( numbersonlyp && ( ! isdigit(event.key.keysym.sym) ) ) {
3926               good = 0;
3927             }
3928
3929             if ( maxlen && strlen(r_buffer) >= maxlen ) {
3930               good = 0;
3931             }
3932
3933             if ( good ) {
3934               char b [ 2 ] = { '\0', '\0' };
3935               if ( shifted ) {
3936                 b [ 0 ] = toupper ( event.key.keysym.sym );
3937               } else {
3938                 b [ 0 ] = event.key.keysym.sym;
3939               }
3940               strncat ( r_buffer, b, maxlen );
3941             } // good?
3942
3943           } // printable?
3944
3945         }
3946
3947         break;
3948
3949       } // switch
3950
3951       break;
3952
3953     } // while waiting for input
3954
3955   } // while
3956
3957   return ( 0 );
3958 }
3959
3960 unsigned char ovr_replace_or_add ( mm_appref_t *a, char *keybase, char *newvalue ) {
3961   //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 );
3962
3963   char fullpath [ PATH_MAX ];
3964
3965   sprintf ( fullpath, "%s/%s", a -> ref -> object_path, a -> ref -> object_filename );
3966   char *dot = strrchr ( fullpath, '.' );
3967   if ( dot ) {
3968     sprintf ( dot, PXML_SAMEPATH_OVERRIDE_FILEEXT );
3969   } else {
3970     pnd_log ( pndn_error, "ERROR: Bad pnd-path in disco_t! %s\n", fullpath );
3971     return ( 0 );
3972   }
3973
3974   struct stat statbuf;
3975
3976   if ( stat ( fullpath, &statbuf ) == 0 ) {
3977     // file exists
3978     pnd_conf_handle h;
3979
3980     h = pnd_conf_fetch_by_path ( fullpath );
3981
3982     if ( ! h ) {
3983       return ( 0 ); // fail!
3984     }
3985
3986     char key [ 101 ];
3987     snprintf ( key, 100, "Application-%u.%s", a -> ref -> subapp_number, keybase );
3988
3989     pnd_conf_set_char ( h, key, newvalue );
3990
3991     return ( pnd_conf_write ( h, fullpath ) );
3992
3993   } else {
3994     // file needs to be created - easy!
3995
3996     FILE *f = fopen ( fullpath, "w" );
3997
3998     if ( f ) {
3999       fprintf ( f, "Application-%u.%s\t%s\n", a -> ref -> subapp_number, keybase, newvalue );
4000       fclose ( f );
4001
4002     } else {
4003       return ( 0 ); // fail!
4004     }
4005
4006   } // new or used?
4007
4008   return ( 1 );
4009 }
4010
4011 void ui_manage_categories ( void ) {
4012   unsigned char require_app_scan = 0;
4013
4014   if ( ! mmcustom_setup() ) {
4015     return; // error
4016   }
4017
4018   char *opts [ 20 ] = {
4019     "List custom categories",
4020     "List custom subcategories",
4021     "Register custom category",
4022     "Register custom subcategory",
4023     "Unregister custom category",
4024     "Unregister custom subcategory",
4025     "Done"
4026   };
4027
4028   while ( 1 ) {
4029
4030     int sel = ui_modal_single_menu ( opts, 7, "Custom Categories", "B to select; other to cancel." );
4031
4032     switch ( sel ) {
4033
4034     case 0: // list custom
4035       ui_pick_custom_category ( 0 );
4036       break;
4037
4038     case 1: // list custom sub
4039       if ( mmcustom_count ) {
4040
4041         char *maincat = ui_pick_custom_category ( 2 );
4042
4043         if ( maincat ) {
4044           unsigned int subcount = mmcustom_count_subcats ( maincat );
4045           char titlebuf [ 201 ];
4046
4047           snprintf ( titlebuf, 200, "Category: %s", maincat );
4048
4049           if ( subcount == 0 ) {
4050             ui_menu_oneby ( titlebuf, "B/Enter to accept", "Category has no subcategories." );
4051           } else {
4052
4053             char **list = malloc ( subcount * sizeof(char*) );
4054             int i;
4055             unsigned int counter = 0;
4056
4057             for ( i = 0; i < mmcustom_count; i++ ) {
4058               if ( mmcustom_complete [ i ].parent_cat && strcasecmp ( mmcustom_complete [ i ].parent_cat, maincat ) == 0 ) {
4059                 list [ counter++ ] = mmcustom_complete [ i ].cat;
4060               }
4061             }
4062
4063             ui_modal_single_menu ( list, counter, titlebuf, "Any button to exit." );
4064
4065             free ( list );
4066
4067           } // more than 0 subcats?
4068
4069         } // user picked a main cat?
4070
4071       } else {
4072         ui_menu_oneby ( "Warning", "B/Enter to accept", "There are none registered." );
4073       }
4074       break;
4075
4076     case 2: // register custom
4077       {
4078         unsigned char changed;
4079         char namebuf [ 101 ] = "";
4080
4081         changed = ui_menu_get_text_line ( "Enter unique category name", "Use keyboard; Enter when done.",
4082                                           "Pandora", namebuf, 30, 0 /* alphanumeric */ );
4083
4084         // did the user enter something?
4085         if ( changed ) {
4086
4087           // and if so, is it existant already or not?
4088           if ( mmcustom_query ( namebuf, NULL ) ) {
4089             ui_menu_oneby ( "Warning", "B/Enter to accept", "Already a registered category." );
4090           } else if ( freedesktop_category_query ( namebuf, NULL ) ) {
4091             ui_menu_oneby ( "Warning", "B/Enter to accept", "Already a Standard category." );
4092           } else {
4093
4094             char confirm [ 1001 ];
4095             snprintf ( confirm, 1000, "Confirm: %s", namebuf );
4096
4097             if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm new category", "Do not register" ) == 1 ) {
4098               // register, save, recycle the current list
4099               mmcustom_register ( namebuf, NULL );
4100               mmcustom_write ( NULL );
4101               mmcustom_shutdown();
4102               mmcustom_setup();
4103             }
4104
4105           } // dupe?
4106
4107         } // entered something?
4108
4109       }
4110       break;
4111
4112     case 3: // register custom sub
4113       if ( 1 /*mmcustom_count -- we allow FD cats now, so this isn't applicable error */ ) {
4114
4115         char *maincat = ui_pick_custom_category ( 1 /* include FD */ );
4116
4117         if ( maincat ) {
4118           char titlebuf [ 201 ];
4119
4120           snprintf ( titlebuf, 200, "Subcat of: %s", maincat );
4121
4122           unsigned char changed;
4123           char namebuf [ 101 ] = "";
4124
4125           changed = ui_menu_get_text_line ( titlebuf, "Use keyboard; Enter when done.", "Submarine", namebuf, 30, 0 /* alphanumeric */ );
4126
4127           // did the user enter something?
4128           if ( changed ) {
4129
4130             // and if so, is it existant already or not?
4131             if ( mmcustom_query ( namebuf, maincat ) ) {
4132               ui_menu_oneby ( "Warning", "B/Enter to accept", "Already a subcategory." );
4133             } else if ( freedesktop_category_query ( namebuf, maincat ) ) {
4134               ui_menu_oneby ( "Warning", "B/Enter to accept", "Already a Standard subcategory." );
4135             } else {
4136
4137               char confirm [ 1001 ];
4138               snprintf ( confirm, 1000, "Confirm: %s [%s]", namebuf, maincat );
4139
4140               if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm new category", "Do not register" ) == 1 ) {
4141                 // register, save, recycle the current list
4142                 mmcustom_register ( namebuf, maincat );
4143                 mmcustom_write ( NULL );
4144                 mmcustom_shutdown();
4145                 mmcustom_setup();
4146               }
4147
4148             } // dupe?
4149
4150           } // entered something?
4151
4152         } // selected parent cat?
4153
4154       } else {
4155         ui_menu_oneby ( "Warning", "B/Enter to accept", "No categories registered." );
4156       }
4157       break;
4158
4159     case 4: // unreg custom
4160       if ( mmcustom_count ) {
4161         char *maincat = ui_pick_custom_category ( 0 );
4162
4163         if ( maincat ) {
4164           char confirm [ 1001 ];
4165           snprintf ( confirm, 1000, "Confirm remove: %s", maincat );
4166
4167           if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm unregister", "Do not unregister" ) == 1 ) {
4168             // register, save, recycle the current list
4169             mmcustom_unregister ( maincat, NULL );
4170             mmcustom_write ( NULL );
4171             mmcustom_shutdown();
4172             mmcustom_setup();
4173           }
4174
4175         } // picked?
4176
4177       } else {
4178         ui_menu_oneby ( "Warning", "B/Enter to accept", "There are none registered." );
4179       }
4180       break;
4181
4182     case 5: // unreg custom sub
4183       if ( mmcustom_count ) {
4184         char *maincat = ui_pick_custom_category ( 2 );
4185
4186         if ( maincat ) {
4187           unsigned int subcount = mmcustom_count_subcats ( maincat );
4188           char titlebuf [ 201 ];
4189
4190           snprintf ( titlebuf, 200, "Category: %s", maincat );
4191
4192           if ( subcount == 0 ) {
4193             ui_menu_oneby ( titlebuf, "B/Enter to accept", "Category has no subcategories." );
4194           } else {
4195
4196             char **list = malloc ( subcount * sizeof(char*) );
4197             int i;
4198             unsigned int counter = 0;
4199
4200             for ( i = 0; i < mmcustom_count; i++ ) {
4201               if ( mmcustom_complete [ i ].parent_cat && strcasecmp ( mmcustom_complete [ i ].parent_cat, maincat ) == 0 ) {
4202                 list [ counter++ ] = mmcustom_complete [ i ].cat;
4203               }
4204             }
4205
4206             int sel = ui_modal_single_menu ( list, counter, titlebuf, "B to selct; other to exit." );
4207
4208             if ( sel >= 0 ) {
4209               char confirm [ 1001 ];
4210               snprintf ( confirm, 1000, "Confirm remove: %s", list [ sel ] );
4211
4212               if ( ui_menu_twoby ( confirm, "B/enter; other to cancel", "Confirm unregister", "Do not unregister" ) == 1 ) {
4213                 // register, save, recycle the current list
4214                 mmcustom_unregister ( list [ sel ], maincat );
4215                 mmcustom_write ( NULL );
4216                 mmcustom_shutdown();
4217                 mmcustom_setup();
4218               }
4219
4220             } // confirm kill?
4221
4222             free ( list );
4223
4224           } // more than 0 subcats?
4225
4226         } // user picked a main cat?
4227
4228       } else {
4229         ui_menu_oneby ( "Warning", "B/Enter to accept", "There are none registered." );
4230       }
4231       break;
4232
4233     } // switch
4234
4235     // exeunt
4236     if ( sel < 0 || sel > 5 ) {
4237       break;
4238     }
4239
4240   } // while running the menu
4241
4242   // shut down custom cats
4243   mmcustom_shutdown();
4244
4245   // reload apps?
4246   if ( require_app_scan ) {
4247     applications_free();
4248     applications_scan();
4249   }
4250
4251   // redraw
4252   render_mask |= CHANGED_EVERYTHING;
4253
4254   return;
4255 }
4256
4257 // mode 0 == custom main only; 1 == custom main + FD main; 2 == custom main + FD mains-with-custom-subs
4258 char *ui_pick_custom_category ( unsigned char mode ) {
4259   char **list;
4260   int i;
4261   unsigned int counter = 0;
4262
4263   // alloc space for list, depending on scope
4264   if ( mode > 0 ) {
4265     list = malloc ( (mmcustom_count+freedesktop_count()) * sizeof(char*) );
4266   } else {
4267     list = malloc ( mmcustom_count * sizeof(char*) );
4268   }
4269
4270   // add custom mains
4271   for ( i = 0; i < mmcustom_count; i++ ) {
4272     if ( mmcustom_complete [ i ].parent_cat == NULL ) {
4273       list [ counter++ ] = mmcustom_complete [ i ].cat;
4274     }
4275   }
4276
4277   // add FD if needed
4278   if ( mode > 0 ) {
4279     i = 3;
4280
4281     while ( 1 ) {
4282
4283       if ( ! freedesktop_complete [ i ].cat ) {
4284         break;
4285       }
4286
4287       // if FD main cat
4288       if ( freedesktop_complete [ i ].parent_cat == NULL ) {
4289
4290         // mode 1 == include them all
4291         // mode 2 == include them if they have a custom subcat
4292         if ( ( mode == 1 ) ||
4293              ( mmcustom_subcount ( freedesktop_complete [ i ].cat ) ) )
4294         {
4295           list [ counter++ ] = freedesktop_complete [ i ].cat;
4296         }
4297
4298       } // if parent cat
4299
4300       i++;
4301     } // while
4302
4303   } // if
4304
4305   // we actually showing anything?
4306   if ( ! counter ) {
4307     ui_menu_oneby ( "Warning", "B/Enter to accept", "There are none registered." );
4308     return ( NULL );
4309   }
4310
4311   // do it
4312   int sel = ui_modal_single_menu ( list, counter, "Custom Categories", "Any button to exit." );
4313
4314   if ( sel < 0 ) {
4315     free ( list );
4316     return ( NULL );
4317   }
4318
4319   char *foo = list [ sel ];
4320   free ( list );
4321
4322   return ( foo );
4323 }
4324
4325 void ui_start_defered_icon_thread ( void ) {
4326
4327   if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_icons_later", 0 ) == 0 ) {
4328     return;
4329   }
4330
4331   if ( g_icon_thread_busy ) {
4332     //fprintf ( stderr, "REM: Waiting for thread to stop..\n" );
4333     ui_stop_defered_icon_thread();
4334   }
4335
4336   //fprintf ( stderr, "WARN: Starting new icon caching thread..\n" );
4337   g_icon_thread = SDL_CreateThread ( (void*)ui_threaded_defered_icon, NULL );
4338
4339   if ( ! g_icon_thread ) {
4340     pnd_log ( pndn_error, "ERROR: Couldn't create icon thread\n" );
4341   }
4342
4343   return;
4344 }
4345
4346 void ui_stop_defered_icon_thread ( void ) {
4347   time_t started = time ( NULL );
4348
4349   // ask thread to stop, then wait for it (if two run at same time, or if we change
4350   // category content under neath it, could be bad..)
4351   g_icon_thread_stop = 1;
4352   while ( g_icon_thread_busy ) {
4353     time ( NULL ); // spin
4354   }
4355   g_icon_thread_stop = 0;
4356
4357   fprintf ( stderr, "REM: Thread stoppage took %u seconds.\n", (int) ( time ( NULL ) - started ) );
4358
4359   return;
4360 }