mmenu: Mostly untested; pushing in list-view changes so porg/pmprog can fiddle easier :)
[pandora-libraries.git] / 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_viewmode_e ui_viewmode = uiv_list;  // default to traditional icon view; why or why is viewstate not per-viewmode :/
93 ui_context_t ui_display_context;        // display paramaters: see mmui_context.h
94 unsigned char ui_detail_hidden = 0;     // if >0, detail panel is hidden
95 // FUTURE: If multiple panels can be shown/hidden, convert ui_detail_hidden to a bitmask
96
97 SDL_Surface *ui_scale_image ( SDL_Surface *s, unsigned int maxwidth, int maxheight ); // height -1 means ignore
98 static int ui_selected_index ( void );
99 static void ui_start_defered_icon_thread ( void );
100 static void ui_stop_defered_icon_thread ( void );
101
102 unsigned char ui_setup ( void ) {
103
104   /* set up SDL
105    */
106
107   SDL_Init ( SDL_INIT_EVERYTHING | SDL_INIT_NOPARACHUTE );
108
109   SDL_JoystickOpen ( 0 ); // turn on joy-0
110
111   SDL_WM_SetCaption ( "mmenu", "mmenu" );
112
113   // hide the mouse cursor if we can
114   if ( SDL_ShowCursor ( -1 ) == 1 ) {
115     SDL_ShowCursor ( 0 );
116   }
117
118   atexit ( SDL_Quit );
119
120   // open up a surface
121   unsigned int svm = SDL_SWSURFACE /*| SDL_FULLSCREEN*/ /* 0*/;
122   if ( pnd_conf_get_as_int_d ( g_conf, "display.fullscreen", 0 ) > 0 ) {
123     svm |= SDL_FULLSCREEN;
124   }
125
126   sdl_realscreen =
127     SDL_SetVideoMode ( 800 * g_scale, 480 * g_scale, 16 /*bpp*/, svm );
128
129   if ( ! sdl_realscreen ) {
130     pnd_log ( pndn_error, "ERROR: Couldn't open SDL real screen; dieing." );
131     return ( 0 );
132   }
133
134   pnd_log ( pndn_debug, "Pixel format:" );
135   pnd_log ( pndn_debug, "bpp b: %u\n", sdl_realscreen -> format -> BitsPerPixel );
136   pnd_log ( pndn_debug, "bpp B: %u\n", sdl_realscreen -> format -> BytesPerPixel );
137   pnd_log ( pndn_debug, "R mask: %08x\n", sdl_realscreen -> format -> Rmask );
138   pnd_log ( pndn_debug, "G mask: %08x\n", sdl_realscreen -> format -> Gmask );
139   pnd_log ( pndn_debug, "B mask: %08x\n", sdl_realscreen -> format -> Bmask );
140
141 #if 0 // audio
142   {
143     SDL_AudioSpec fmt;
144
145     /* Set 16-bit stereo audio at 22Khz */
146     fmt.freq = 44100; //22050;
147     fmt.format = AUDIO_S16; //AUDIO_S16;
148     fmt.channels = 1;
149     fmt.samples = 2048;        /* A good value for games */
150     fmt.callback = mixaudio;
151     fmt.userdata = NULL;
152
153     /* Open the audio device and start playing sound! */
154     if ( SDL_OpenAudio ( &fmt, NULL ) < 0 ) {
155       zotlog ( "Unable to open audio: %s\n", SDL_GetError() );
156       exit ( 1 );
157     }
158
159     SDL_PauseAudio ( 0 );
160   }
161 #endif
162
163   // key repeat
164   SDL_EnableKeyRepeat ( 500, 125 /* 150 */ );
165
166   // images
167   //IMG_Init ( IMG_INIT_JPG | IMG_INIT_PNG );
168
169   /* fonts
170    */
171
172   // init
173   if ( TTF_Init() == -1 ) {
174     pnd_log ( pndn_error, "ERROR: Couldn't set up SDL TTF lib\n" );
175     return ( 0 ); // couldn't set up SDL TTF
176   }
177
178   char fullpath [ PATH_MAX ];
179   // big font
180   sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "minimenu.font" ) );
181   g_big_font = TTF_OpenFont ( fullpath, pnd_conf_get_as_int_d ( g_conf, "minimenu.font_ptsize", 24 ) );
182   if ( ! g_big_font ) {
183     pnd_log ( pndn_error, "ERROR: Couldn't load font '%s' for size %u\n",
184               pnd_conf_get_as_char ( g_conf, "minimenu.font" ), pnd_conf_get_as_int_d ( g_conf, "minimenu.font_ptsize", 24 ) );
185     return ( 0 ); // couldn't set up SDL TTF
186   }
187
188   // grid font
189   sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "grid.font" ) );
190   g_grid_font = TTF_OpenFont ( fullpath, pnd_conf_get_as_int_d ( g_conf, "grid.font_ptsize", 10 ) );
191   if ( ! g_grid_font ) {
192     pnd_log ( pndn_error, "ERROR: Couldn't load font '%s' for size %u\n",
193               pnd_conf_get_as_char ( g_conf, "grid.font" ), pnd_conf_get_as_int_d ( g_conf, "grid.font_ptsize", 10 ) );
194     return ( 0 ); // couldn't set up SDL TTF
195   }
196
197   // detailtext font
198   sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "detailtext.font" ) );
199   g_detailtext_font = TTF_OpenFont ( fullpath, pnd_conf_get_as_int_d ( g_conf, "detailtext.font_ptsize", 10 ) );
200   if ( ! g_detailtext_font ) {
201     pnd_log ( pndn_error, "ERROR: Couldn't load font '%s' for size %u\n",
202               pnd_conf_get_as_char ( g_conf, "detailtext.font" ), pnd_conf_get_as_int_d ( g_conf, "detailtext.font_ptsize", 10 ) );
203     return ( 0 ); // couldn't set up SDL TTF
204   }
205
206   // tab font
207   sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "tabs.font" ) );
208   g_tab_font = TTF_OpenFont ( fullpath, pnd_conf_get_as_int_d ( g_conf, "tabs.font_ptsize", 10 ) );
209   if ( ! g_tab_font ) {
210     pnd_log ( pndn_error, "ERROR: Couldn't load font '%s' for size %u\n",
211               pnd_conf_get_as_char ( g_conf, "tabs.font" ), pnd_conf_get_as_int_d ( g_conf, "tabs.font_ptsize", 10 ) );
212     return ( 0 ); // couldn't set up SDL TTF
213   }
214
215   // determine display context
216   if ( pnd_conf_get_as_int_d ( g_conf, "display.show_detail_pane", 1 ) > 0 ) {
217     ui_detail_hidden = 0;
218   } else {
219     ui_detail_hidden = 1;
220   }
221   ui_recache_context ( &ui_display_context );
222
223   return ( 1 );
224 }
225
226 mm_imgcache_t g_imagecache [ IMG_TRUEMAX ] = {
227   { IMG_BACKGROUND_800480,    "graphics.IMG_BACKGROUND_800480" },
228   { IMG_BACKGROUND_TABMASK,   "graphics.IMG_BACKGROUND_TABMASK" },
229   { IMG_DETAIL_PANEL,         "graphics.IMG_DETAIL_PANEL" },
230   { IMG_DETAIL_BG,            "graphics.IMG_DETAIL_BG" },
231   { IMG_SELECTED_ALPHAMASK,   "graphics.IMG_SELECTED_ALPHAMASK" },
232   { IMG_TAB_SEL,              "graphics.IMG_TAB_SEL" },
233   { IMG_TAB_SEL_L,            "graphics.IMG_TAB_SEL_L" },
234   { IMG_TAB_SEL_R,            "graphics.IMG_TAB_SEL_R" },
235   { IMG_TAB_UNSEL,            "graphics.IMG_TAB_UNSEL" },
236   { IMG_TAB_UNSEL_L,          "graphics.IMG_TAB_UNSEL_L" },
237   { IMG_TAB_UNSEL_R,          "graphics.IMG_TAB_UNSEL_R" },
238   { IMG_TAB_LINE,             "graphics.IMG_TAB_LINE" },
239   { IMG_TAB_LINEL,            "graphics.IMG_TAB_LINEL" },
240   { IMG_TAB_LINER,            "graphics.IMG_TAB_LINER" },
241   { IMG_ICON_MISSING,         "graphics.IMG_ICON_MISSING" },
242   { IMG_SELECTED_HILITE,      "graphics.IMG_SELECTED_HILITE" },
243   { IMG_PREVIEW_MISSING,      "graphics.IMG_PREVIEW_MISSING" },
244   { IMG_ARROW_UP,             "graphics.IMG_ARROW_UP", },
245   { IMG_ARROW_DOWN,           "graphics.IMG_ARROW_DOWN", },
246   { IMG_ARROW_SCROLLBAR,      "graphics.IMG_ARROW_SCROLLBAR", },
247   { IMG_HOURGLASS,            "graphics.IMG_HOURGLASS", },
248   { IMG_FOLDER,               "graphics.IMG_FOLDER", },
249   { IMG_EXECBIN,              "graphics.IMG_EXECBIN", },
250   { IMG_SUBCATFOLDER,         "graphics.IMG_SUBCATFOLDER", "graphics.IMG_FOLDER", },
251   { IMG_DOTDOTFOLDER,         "graphics.IMG_DOTDOTFOLDER", "graphics.IMG_FOLDER", },
252   { IMG_MAX,                  NULL },
253   { IMG_LIST_ALPHAMASK,       NULL }, // generated
254   { IMG_LIST_ALPHAMASK_W,     NULL }, // generated
255 };
256
257 unsigned char ui_imagecache ( char *basepath ) {
258   unsigned int i;
259   char fullpath [ PATH_MAX ];
260   unsigned char try;
261
262   // loaded
263
264   for ( i = 0; i < IMG_MAX; i++ ) {
265
266     if ( g_imagecache [ i ].id != i ) {
267       pnd_log ( pndn_error, "ERROR: Internal table mismatch during caching [%u]\n", i );
268       exit ( -1 );
269     }
270
271     for ( try = 0; try < 2; try++ ) {
272
273       char *filename;
274
275       if ( try == 0 ) {
276         filename = pnd_conf_get_as_char ( g_conf, g_imagecache [ i ].confname );
277       } else {
278         if ( g_imagecache [ i ].alt_confname ) {
279           filename = pnd_conf_get_as_char ( g_conf, g_imagecache [ i ].alt_confname );
280         } else {
281           return ( 0 );
282         }
283       }
284
285       if ( ! filename ) {
286         pnd_log ( pndn_error, "ERROR: (Try %u) Missing filename in conf for key: %s\n", try + 1, g_imagecache [ i ].confname );
287         if ( try == 0 ) { continue; } else { return ( 0 ); }
288       }
289
290       if ( filename [ 0 ] == '/' ) {
291         strncpy ( fullpath, filename, PATH_MAX );
292       } else {
293         sprintf ( fullpath, "%s/%s", basepath, filename );
294       }
295
296       if ( ( g_imagecache [ i ].i = IMG_Load ( fullpath ) ) ) {
297         break; // no retry needed
298       } else {
299         pnd_log ( pndn_error, "ERROR: (Try %u) Couldn't load static cache image: %s\n", try + 1, fullpath );
300         if ( try == 0 ) { continue; } else { return ( 0 ); }
301       }
302
303     } // try twice
304
305   } // for
306
307   // generated
308   //
309
310   //g_imagecache [ IMG_SELECTED_ALPHAMASK ].i = SDL_CreateRGBSurface ( SDL_SWSURFACE, 60, 60, 32, 0xFF0000, 0x00FF00, 0xFF, 0xFF000000 );
311   //boxRGBA ( g_imagecache [ IMG_SELECTED_ALPHAMASK ].i, 0, 0, 60, 60, 100, 100, 100, 250 );
312
313   SDL_Surface *p = g_imagecache [ IMG_SELECTED_ALPHAMASK ].i;
314   g_imagecache [ IMG_LIST_ALPHAMASK ].i = SDL_ConvertSurface ( p, p -> format, p -> flags );
315   g_imagecache [ IMG_LIST_ALPHAMASK_W ].i = SDL_ConvertSurface ( p, p -> format, p -> flags );
316
317   g_imagecache [ IMG_LIST_ALPHAMASK ].i =
318     ui_scale_image ( g_imagecache [ IMG_LIST_ALPHAMASK ].i,
319                      pnd_conf_get_as_int ( g_conf, "grid.col_max" ) * pnd_conf_get_as_int ( g_conf, "grid.cell_width" ) , -1 );
320
321   g_imagecache [ IMG_LIST_ALPHAMASK_W ].i =
322     ui_scale_image ( g_imagecache [ IMG_LIST_ALPHAMASK_W ].i,
323                      pnd_conf_get_as_int ( g_conf, "grid.col_max_w" ) * pnd_conf_get_as_int ( g_conf, "grid.cell_width_w" ) , -1 );
324
325   // post processing
326   //
327
328   // scale icons
329   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 );
330   // scale text hilight
331   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 );
332   // scale preview no-pic
333   g_imagecache [ IMG_PREVIEW_MISSING ].i = ui_scale_image ( g_imagecache [ IMG_PREVIEW_MISSING ].i,
334                                                             pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 50 ),
335                                                             pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 50 ) );
336
337   // set alpha on detail panel
338   //SDL_SetAlpha ( g_imagecache [ IMG_DETAIL_BG ].i, SDL_SRCALPHA, pnd_conf_get_as_int_d ( g_conf, "display.detail_bg_alpha", 50 ) );
339
340   return ( 1 );
341 } // ui_imagecache
342
343 void ui_render ( void ) {
344
345   // 800x480:
346   // divide width: 550 / 250
347   // divide left side: 5 columns == 110px width
348   //   20px buffer either side == 70px wide icon + 20 + 20?
349
350   // what jobs to do during render?
351   //
352
353 #define R_BG     (1<<0)
354 #define R_TABS   (1<<1)
355 #define R_DETAIL (1<<2)
356 #define R_GRID   (1<<3)
357
358 #define R_ALL (R_BG|R_TABS|R_DETAIL|R_GRID)
359
360   unsigned int render_jobs_b = 0;
361
362   if ( render_mask & CHANGED_EVERYTHING ) {
363     render_jobs_b |= R_ALL;
364   }
365
366   if ( render_mask & CHANGED_SELECTION ) {
367     render_jobs_b |= R_GRID;
368     render_jobs_b |= R_DETAIL;
369   }
370
371   if ( render_mask & CHANGED_CATEGORY ) {
372     render_jobs_b |= R_ALL;
373   }
374
375   render_mask = CHANGED_NOTHING;
376
377   // render everything
378   //
379   unsigned int icon_rows;
380   unsigned int icon_visible_rows = 0; // list view, max number of visible rows
381
382 #define MAXRECTS 200
383   SDL_Rect rects [ MAXRECTS ], src;
384   SDL_Rect *dest = rects;
385   bzero ( dest, sizeof(SDL_Rect)*MAXRECTS );
386
387   unsigned int row, displayrow, col;
388   mm_appref_t *appiter;
389
390   ui_context_t *c = &ui_display_context; // for convenience and shorthand
391
392   // on demand icon loading
393   static int load_visible = -1;
394   if ( load_visible == -1 ) {
395     load_visible = pnd_conf_get_as_int_d ( g_conf, "minimenu.load_visible_icons", 0 );
396   }
397
398 #if 1
399   // if no selected app yet, select the first one
400   if ( ! ui_selected && pnd_conf_get_as_int_d ( g_conf, "minimenu.start_selected", 0 ) ) {
401
402     // pick first visible app
403     ui_selected = g_categories [ ui_category ] -> refs;
404
405     // change.. so we pick first visible if option is set .. but now we also try to restore
406     // selection to the last app selected in previous session (if there is one.)
407     char *previous_unique_id = pnd_conf_get_as_char ( g_conf, "minimenu.last_known_app_uid" );
408
409     if ( previous_unique_id ) {
410
411       // 1) we should already be in the right category, since its set in ui_post_scan to minimenu.last_known_catname
412       // 2) so we just pick the app in question..
413       mm_appref_t *previter = g_categories [ ui_category ] -> refs;
414       while ( previter ) {
415         if ( strcmp ( previter -> ref -> unique_id, previous_unique_id ) == 0 ) {
416           break;
417         }
418         previter = previter -> next;
419       }
420
421       if ( previter ) {
422         ui_selected = previter;
423       }
424
425     } // last known app?
426
427   }
428 #endif
429
430   // how many total rows do we need?
431   if ( g_categorycount ) {
432
433     if ( ui_viewmode == uiv_list ) {
434       // in list view, dimension of grid area is ..
435       // grid height == cell-height * row-max
436       // font height == display_context -> text_height
437       // padding == icon_offset_y
438       // max visible --> row-max == grid height / ( font-height + padding )
439
440       icon_rows = g_categories [ ui_category ] -> refcount; // one app per row
441       icon_visible_rows = ( c -> cell_height * c -> row_max ) / ( c -> text_height + c -> icon_offset_y );
442
443     } else {
444
445       icon_rows = g_categories [ ui_category ] -> refcount / c -> col_max;
446       if ( g_categories [ ui_category ] -> refcount % c -> col_max > 0 ) {
447         icon_rows++;
448       }
449
450     }
451
452   } else {
453     icon_rows = 0;
454     icon_visible_rows = 0;
455   }
456
457   // reset touchscreen regions
458   if ( render_jobs_b ) {
459     ui_register_reset();
460   }
461
462   // ensure selection is visible
463   if ( ui_selected ) {
464
465     unsigned char autoscrolled = 1;
466     while ( autoscrolled ) {
467       autoscrolled = 0;
468
469       int index = ui_selected_index();
470
471       if ( ui_viewmode == uiv_list ) {
472
473         if ( index >= ui_rows_scrolled_down + icon_visible_rows ) {
474           ui_rows_scrolled_down += 1;
475           autoscrolled = 1;
476           render_jobs_b |= R_ALL;
477         } else if ( index < ui_rows_scrolled_down ) {
478           ui_rows_scrolled_down -= 1;
479           autoscrolled = 1;
480           render_jobs_b |= R_ALL;
481         }
482
483       } else {
484         // icons
485
486         int topleft = c -> col_max * ui_rows_scrolled_down;
487         int botright = ( c -> col_max * ( ui_rows_scrolled_down + c -> row_max ) - 1 );
488
489         if ( index < topleft ) {
490           ui_rows_scrolled_down -= pnd_conf_get_as_int_d ( g_conf, "grid.scroll_increment", 1 );
491           render_jobs_b |= R_ALL;
492           autoscrolled = 1;
493         } else if ( index > botright ) {
494           ui_rows_scrolled_down += pnd_conf_get_as_int_d ( g_conf, "grid.scroll_increment", 1 );
495           render_jobs_b |= R_ALL;
496           autoscrolled = 1;
497         }
498
499       } // viewmode
500
501     } // while autoscrolling
502
503     if ( ui_rows_scrolled_down < 0 ) {
504       ui_rows_scrolled_down = 0;
505     } else if ( ui_rows_scrolled_down > icon_rows ) {
506       ui_rows_scrolled_down = icon_rows;
507     }
508
509   } // ensure visible
510
511   // render background
512   if ( render_jobs_b & R_BG ) {
513
514     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
515       dest -> x = 0;
516       dest -> y = 0;
517       dest -> w = sdl_realscreen -> w;
518       dest -> h = sdl_realscreen -> h;
519       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, NULL /* whole image */, sdl_realscreen, dest /* 0,0 */ );
520       dest++;
521     }
522
523     // tabmask
524     if ( g_imagecache [ IMG_BACKGROUND_TABMASK ].i ) {
525       dest -> x = 0;
526       dest -> y = 0;
527       dest -> w = sdl_realscreen -> w;
528       dest -> h = sdl_realscreen -> h;
529       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_TABMASK ].i, NULL /* whole image */, sdl_realscreen, dest /* 0,0 */ );
530       dest++;
531     }
532
533   } // r_bg
534
535   // tabs
536   if ( g_imagecache [ IMG_TAB_SEL ].i && g_imagecache [ IMG_TAB_UNSEL ].i ) {
537     static unsigned int tab_width;
538     static unsigned int tab_height;
539     static unsigned int tab_offset_x;
540     static unsigned int tab_offset_y;
541     static unsigned int text_offset_x;
542     static unsigned int text_offset_y;
543     static unsigned int text_width;
544
545     static unsigned char tab_first_run = 1;
546     if ( tab_first_run ) {
547       tab_first_run = 0;
548       tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
549       tab_height = pnd_conf_get_as_int ( g_conf, "tabs.tab_height" );
550       tab_offset_x = pnd_conf_get_as_int ( g_conf, "tabs.tab_offset_x" );
551       tab_offset_y = pnd_conf_get_as_int ( g_conf, "tabs.tab_offset_y" );
552       text_offset_x = pnd_conf_get_as_int ( g_conf, "tabs.text_offset_x" );
553       text_offset_y = pnd_conf_get_as_int ( g_conf, "tabs.text_offset_y" );
554       text_width = pnd_conf_get_as_int ( g_conf, "tabs.text_width" );
555     }
556
557     unsigned int maxtab = ( c -> screen_width / tab_width ) < g_categorycount ? ( c -> screen_width / tab_width ) + ui_catshift : g_categorycount + ui_catshift;
558     unsigned int maxtabspot = ( c -> screen_width / tab_width );
559
560     if ( g_categorycount > 0 ) {
561
562       // draw tabs with categories
563       for ( col = ui_catshift;
564             col < maxtab;
565             col++ )
566       {
567
568         SDL_Surface *s;
569
570         // if this is the first (leftmost) tab, we use different artwork
571         // than if the other tabs (so skinner can link lines up nicely.)
572         if ( col == ui_catshift ) {
573           // leftmost tab, special case
574
575           if ( col == ui_category ) {
576             s = g_imagecache [ IMG_TAB_SEL_L ].i;
577           } else {
578             s = g_imagecache [ IMG_TAB_UNSEL_L ].i;
579           }
580
581         } else if ( col == maxtab - 1 ) {
582           // rightmost tab, special case
583
584           if ( col == ui_category ) {
585             s = g_imagecache [ IMG_TAB_SEL_R ].i;
586           } else {
587             s = g_imagecache [ IMG_TAB_UNSEL_R ].i;
588           }
589
590         } else {
591           // normal (not leftmost) tab
592
593           if ( col == ui_category ) {
594             s = g_imagecache [ IMG_TAB_SEL ].i;
595           } else {
596             s = g_imagecache [ IMG_TAB_UNSEL ].i;
597           }
598
599         } // first col, or not first col?
600
601         // draw tab
602         src.x = 0;
603         src.y = 0;
604 #if 0
605         src.w = tab_width;
606         if ( col == ui_category ) {
607           src.h = tab_selheight;
608         } else {
609           src.h = tab_height;
610         }
611 #else
612         src.w = s -> w;
613         src.h = s -> h;
614 #endif
615         dest -> x = tab_offset_x + ( (col-ui_catshift) * tab_width );
616         dest -> y = tab_offset_y;
617
618         // store touch info
619         ui_register_tab ( col, dest -> x, dest -> y, tab_width, tab_height );
620
621         if ( render_jobs_b & R_TABS ) {
622           //pnd_log ( pndn_debug, "tab %u at %ux%u\n", col, dest.x, dest.y );
623           SDL_BlitSurface ( s, &src, sdl_realscreen, dest );
624           dest++;
625
626           // draw tab line
627           if ( col == ui_category ) {
628             // no line for selected tab
629           } else {
630             if ( col - ui_catshift == 0 ) {
631               s = g_imagecache [ IMG_TAB_LINEL ].i;
632             } else if ( col - ui_catshift == maxtabspot - 1 ) {
633               s = g_imagecache [ IMG_TAB_LINER ].i;
634             } else {
635               s = g_imagecache [ IMG_TAB_LINE ].i;
636             }
637             dest -> x = tab_offset_x + ( (col-ui_catshift) * tab_width );
638             dest -> y = tab_offset_y + tab_height;
639             SDL_BlitSurface ( s, NULL /* whole image */, sdl_realscreen, dest );
640             dest++;
641           }
642
643           // draw text
644           SDL_Surface *rtext;
645           rtext = TTF_RenderText_Blended ( g_tab_font, g_categories [ col ] -> catname, c -> fontcolor );
646           src.x = 0;
647           src.y = 0;
648           src.w = rtext -> w < text_width ? rtext -> w : text_width;
649           src.h = rtext -> h;
650           dest -> x = tab_offset_x + ( (col-ui_catshift) * tab_width ) + text_offset_x;
651           dest -> y = tab_offset_y + text_offset_y;
652           SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
653           SDL_FreeSurface ( rtext );
654           dest++;
655
656         } // r_tabs
657
658       } // for
659
660     } // if we got categories
661
662     if ( render_jobs_b & R_TABS ) {
663
664       // draw tab lines under where tabs would be if we had categories
665       for ( /* foo */; col < maxtabspot; col++ ) {
666         SDL_Surface *s;
667
668         if ( col - ui_catshift == 0 ) {
669           s = g_imagecache [ IMG_TAB_LINEL ].i;
670         } else if ( col - ui_catshift == maxtabspot - 1 ) {
671           s = g_imagecache [ IMG_TAB_LINER ].i;
672         } else {
673           s = g_imagecache [ IMG_TAB_LINE ].i;
674         }
675         dest -> x = tab_offset_x + ( (col-ui_catshift) * tab_width );
676         dest -> y = tab_offset_y + tab_height;
677         SDL_BlitSurface ( s, NULL /* whole image */, sdl_realscreen, dest );
678         dest++;
679
680       } // for
681
682     } // r_tabs
683
684   } // tabs
685
686   // scroll bars and arrows
687   if ( render_jobs_b & R_BG ) {
688     unsigned char show_bar = 0;
689
690     // up?
691     if ( ui_rows_scrolled_down && g_imagecache [ IMG_ARROW_UP ].i ) {
692       dest -> x = c -> arrow_up_x;
693       dest -> y = c -> arrow_up_y;
694       SDL_BlitSurface ( g_imagecache [ IMG_ARROW_UP ].i, NULL /* whole image */, sdl_realscreen, dest );
695       dest++;
696
697       show_bar = 1;
698     }
699
700     // down?
701     if ( ui_rows_scrolled_down + c -> row_max < icon_rows && g_imagecache [ IMG_ARROW_DOWN ].i ) {
702       dest -> x = c -> arrow_down_x;
703       dest -> y = c -> arrow_down_y;
704       SDL_BlitSurface ( g_imagecache [ IMG_ARROW_DOWN ].i, NULL /* whole image */, sdl_realscreen, dest );
705       dest++;
706
707       show_bar = 1;
708     }
709
710     if ( show_bar ) {
711       // show scrollbar as well
712       src.x = 0;
713       src.y = 0;
714       src.w = c -> arrow_bar_clip_w;
715       src.h = c -> arrow_bar_clip_h;
716       dest -> x = c -> arrow_bar_x;
717       dest -> y = c -> arrow_bar_y;
718       SDL_BlitSurface ( g_imagecache [ IMG_ARROW_SCROLLBAR ].i, &src /* whole image */, sdl_realscreen, dest );
719       dest++;
720     } // bar
721
722   } // r_bg, scroll bars
723
724   // render detail pane bg
725   if ( render_jobs_b & R_DETAIL && ui_detail_hidden == 0 ) {
726
727     if ( pnd_conf_get_as_int_d ( g_conf, "detailpane.show", 1 ) ) {
728
729       // render detail bg
730       if ( g_imagecache [ IMG_DETAIL_BG ].i ) {
731         src.x = 0; // pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
732         src.y = 0; // pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
733         src.w = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_PANEL ].i)) -> w;
734         src.h = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_PANEL ].i)) -> h;
735         dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
736         dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
737         SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
738         dest++;
739       }
740
741       // render detail pane
742       if ( g_imagecache [ IMG_DETAIL_PANEL ].i ) {
743         dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
744         dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
745         SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_PANEL ].i, NULL /* whole image */, sdl_realscreen, dest );
746         dest++;
747       }
748
749     } // detailpane frame/bg
750
751   } // r_details
752
753   // anything to render?
754   if ( render_jobs_b & R_GRID && g_categorycount ) {
755
756     // if just rendering grid, and nothing else, better clear it first
757     if ( ! ( render_jobs_b & R_BG ) ) {
758       if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
759         src.x = c -> grid_offset_x;
760         src.y = c -> grid_offset_y + c -> sel_icon_offset_y;
761         src.w = c -> col_max * c -> cell_width;
762         src.h = c -> row_max * c -> cell_height;
763
764         dest -> x = c -> grid_offset_x;
765         dest -> y = c -> grid_offset_y + c -> sel_icon_offset_y;
766
767         SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, &src, sdl_realscreen, dest );
768         dest++;
769
770       }
771     }
772
773     // any apps to render at all?
774     if ( g_categories [ ui_category ] -> refs ) {
775
776       // render grid differently based on view mode..
777       //
778       if ( ui_viewmode == uiv_list ) {
779
780         appiter = g_categories [ ui_category ] -> refs;
781         row = 0; // row under consideration (ie: could be scrolled off)
782         displayrow = 0; // rows displayed
783
784         while ( appiter != NULL ) {
785
786           // do we even need to render it? or are we suppressing it due to rows scrolled off the top?
787           if ( row >= ui_rows_scrolled_down ) {
788
789             // background hilight
790             SDL_Surface *hilight = ui_detail_hidden ? g_imagecache [ IMG_LIST_ALPHAMASK_W ].i : g_imagecache [ IMG_LIST_ALPHAMASK ].i;
791             if ( appiter == ui_selected ) {
792               src.x = 0;
793               src.y = 0;
794               src.w = hilight -> w;
795               src.h = c -> text_height + c -> icon_offset_y;
796               dest -> x = c -> grid_offset_x + c -> text_clip_x;
797               dest -> y = c -> grid_offset_y + ( displayrow * ( c -> text_height + c -> icon_offset_y ) ) - ( c -> icon_offset_y / 2 );
798               SDL_BlitSurface ( hilight, &src, sdl_realscreen, dest );
799               dest++;
800             }
801
802             // show icon
803             mm_cache_t *ic = cache_query_icon ( appiter -> ref -> unique_id );
804             if ( ic ) {
805               dest -> x = c -> grid_offset_x + c -> text_clip_x;
806               dest -> y = c -> grid_offset_y + ( displayrow * ( c -> text_height + c -> icon_offset_y ) ) - ( c -> icon_offset_y / 2 );
807               SDL_BlitSurface ( ic -> itiny, NULL, sdl_realscreen, dest );
808             }
809
810             // show title text
811             if ( appiter -> ref -> title_en ) {
812               SDL_Surface *rtext;
813               rtext = TTF_RenderText_Blended ( g_grid_font, appiter -> ref -> title_en, c -> fontcolor );
814               src.x = 0;
815               src.y = 0;
816               src.w = hilight -> w; //c -> text_width < rtext -> w ? c -> text_width : rtext -> w;
817               src.h = rtext -> h;
818
819               dest -> x = c -> grid_offset_x + c -> text_clip_x;
820               dest -> x += 20; // so all title-text line up, regardless of icon presence
821 #if 0
822               if ( ic ) {
823                 dest -> x += 20; //((SDL_Surface*)ic -> i) -> w;
824               }
825 #endif
826
827               dest -> y = c -> grid_offset_y + ( displayrow * ( c -> text_height + c -> icon_offset_y ) );
828               SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
829               SDL_FreeSurface ( rtext );
830               dest++;
831             }
832
833           } // visible or scrolled?
834
835           if ( row >= ui_rows_scrolled_down ) {
836             displayrow++;
837           }
838
839           // are we done displaying rows?
840           if ( displayrow >= icon_visible_rows ) {
841             break;
842           }
843
844           appiter = appiter -> next;
845           row++;
846
847         } // while
848
849       } else {
850
851         appiter = g_categories [ ui_category ] -> refs;
852         row = 0;
853         displayrow = 0;
854
855         // until we run out of apps, or run out of space
856         while ( appiter != NULL ) {
857
858           for ( col = 0; col < c -> col_max && appiter != NULL; col++ ) {
859
860             // do we even need to render it? or are we suppressing it due to rows scrolled off the top?
861             if ( row >= ui_rows_scrolled_down ) {
862
863               // selected? show hilights
864               if ( appiter == ui_selected ) {
865                 SDL_Surface *s = g_imagecache [ IMG_SELECTED_ALPHAMASK ].i;
866                 // icon
867                 //dest -> x = grid_offset_x + ( col * cell_width ) + icon_offset_x + ( ( icon_max_width - s -> w ) / 2 );
868                 dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> icon_offset_x + c -> sel_icon_offset_x;
869                 //dest -> y = grid_offset_y + ( displayrow * cell_height ) + icon_offset_y + ( ( icon_max_height - s -> h ) / 2 );
870                 dest -> y = c -> grid_offset_y + ( displayrow * c -> cell_height ) + c -> icon_offset_y + c -> sel_icon_offset_y;
871                 SDL_BlitSurface ( s, NULL /* all */, sdl_realscreen, dest );
872                 dest++;
873                 // text
874                 dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> text_clip_x;
875                 dest -> y = c -> grid_offset_y + ( displayrow * c -> cell_height ) + c -> text_hilite_offset_y;
876                 SDL_BlitSurface ( g_imagecache [ IMG_SELECTED_HILITE ].i, NULL /* all */, sdl_realscreen, dest );
877                 dest++;
878               } // selected?
879
880               // show icon
881               mm_cache_t *ic = cache_query_icon ( appiter -> ref -> unique_id );
882               SDL_Surface *iconsurface;
883
884               // if icon not in cache, and its a pnd-file source, perhaps try to load it right now..
885               if ( ( ! ic ) &&
886                    ( load_visible ) &&
887                    ( ! ( appiter -> ref -> object_flags & PND_DISCO_GENERATED ) )
888                  )
889               {
890                 // try to load any icons that..
891                 // - are not yet loaded
892                 // - did not fail a previous load attempt
893                 // this way user can upfront load all icons, or defer all icons, or even defer all icons
894                 // and still try to load visible ones 'just before needed'; so not at mmenu load time, but
895                 // as needed (only the ones needed.)
896
897                 if ( ( appiter -> ref -> pnd_icon_pos ) ||
898                      ( appiter -> ref -> icon && appiter -> ref -> object_flags & PND_DISCO_LIBPND_DD )
899                    )
900                 {
901   
902                   // try to cache it?
903                   if ( ! cache_icon ( appiter -> ref, ui_display_context.icon_max_width, ui_display_context.icon_max_width ) ) {
904                     // erm..
905                   }
906
907                   // avoid churn
908                   appiter -> ref -> pnd_icon_pos = 0;
909                   if ( appiter -> ref -> icon ) {
910                     free ( appiter -> ref -> icon );
911                     appiter -> ref -> icon = NULL;
912                   }
913
914                   // pick up as if nothing happened..
915                   ic = cache_query_icon ( appiter -> ref -> unique_id );
916
917                 }
918
919               } // load icon during rendering?
920
921               if ( ic ) {
922                 iconsurface = ic -> i;
923               } else {
924                 //pnd_log ( pndn_warning, "WARNING: TBD: Need Missin-icon icon for '%s'\n", IFNULL(appiter -> ref -> title_en,"No Name") );
925
926                 // no icon override; was this a pnd-file (show the unknown icon then), or was this generated from
927                 // filesystem (file or directory icon)
928                 if ( appiter -> ref -> object_flags & PND_DISCO_GENERATED ) {
929                   if ( appiter -> ref -> object_type == pnd_object_type_directory ) {
930
931                     // is this a subcat, a .., or a filesystem folder?
932                     //iconsurface = g_imagecache [ IMG_FOLDER ].i;
933                     if ( g_categories [ ui_category ] -> fspath ) {
934                       iconsurface = g_imagecache [ IMG_FOLDER ].i;
935                     } else if ( strcmp ( appiter -> ref -> title_en, ".." ) == 0 ) {
936                       iconsurface = g_imagecache [ IMG_DOTDOTFOLDER ].i;
937                     } else {
938                       iconsurface = g_imagecache [ IMG_SUBCATFOLDER ].i;
939                     }
940
941                   } else {
942                     iconsurface = g_imagecache [ IMG_EXECBIN ].i;
943                   }
944                 } else {
945                   iconsurface = g_imagecache [ IMG_ICON_MISSING ].i;
946                 }
947
948               }
949
950               // got an icon I hope?
951               if ( iconsurface ) {
952                 //pnd_log ( pndn_debug, "Got an icon for '%s'\n", IFNULL(appiter -> ref -> title_en,"No Name") );
953
954                 src.x = 0;
955                 src.y = 0;
956                 src.w = 60;
957                 src.h = 60;
958                 dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> icon_offset_x + (( c -> icon_max_width - iconsurface -> w ) / 2);
959                 dest -> y = c -> grid_offset_y + ( displayrow * c -> cell_height ) + c -> icon_offset_y + (( c -> icon_max_height - iconsurface -> h ) / 2);
960
961                 SDL_BlitSurface ( iconsurface, &src, sdl_realscreen, dest );
962
963                 // store touch info
964                 ui_register_app ( appiter, dest -> x, dest -> y, src.w, src.h );
965
966                 dest++;
967
968               }
969
970               // show text
971               if ( appiter -> ref -> title_en ) {
972                 SDL_Surface *rtext;
973                 rtext = TTF_RenderText_Blended ( g_grid_font, appiter -> ref -> title_en, c -> fontcolor );
974                 src.x = 0;
975                 src.y = 0;
976                 src.w = c -> text_width < rtext -> w ? c -> text_width : rtext -> w;
977                 src.h = rtext -> h;
978                 if ( rtext -> w > c -> text_width ) {
979                   dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> text_clip_x;
980                 } else {
981                   dest -> x = c -> grid_offset_x + ( col * c -> cell_width ) + c -> text_offset_x - ( rtext -> w / 2 );
982                 }
983                 dest -> y = c -> grid_offset_y + ( displayrow * c -> cell_height ) + c -> text_offset_y;
984                 SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
985                 SDL_FreeSurface ( rtext );
986                 dest++;
987               }
988
989             } // display now? or scrolled away..
990
991             // next
992             appiter = appiter -> next;
993
994           } // for column 1...X
995
996           if ( row >= ui_rows_scrolled_down ) {
997             displayrow++;
998           }
999
1000           row ++;
1001
1002           // are we done displaying rows?
1003           if ( displayrow >= c -> row_max ) {
1004             break;
1005           }
1006
1007         } // while
1008
1009       } // icon view
1010
1011     } else {
1012       // no apps to render?
1013       pnd_log ( pndn_rem, "No applications to render?\n" );
1014     } // apps to renser?
1015
1016   } // r_grid
1017
1018   // detail panel - show app details or blank-message
1019   if ( render_jobs_b & R_DETAIL && ui_detail_hidden == 0 ) {
1020
1021     unsigned int cell_offset_x = pnd_conf_get_as_int ( g_conf, "detailtext.cell_offset_x" );
1022     unsigned int cell_offset_y = pnd_conf_get_as_int ( g_conf, "detailtext.cell_offset_y" );
1023     unsigned int cell_width = pnd_conf_get_as_int ( g_conf, "detailtext.cell_width" );
1024
1025     unsigned int desty = cell_offset_y;
1026
1027     if ( ui_selected ) {
1028
1029       char buffer [ 256 ];
1030
1031       // full name
1032       if ( ui_selected -> ref -> title_en ) {
1033         SDL_Surface *rtext;
1034         rtext = TTF_RenderText_Blended ( g_detailtext_font, ui_selected -> ref -> title_en, c -> fontcolor );
1035         src.x = 0;
1036         src.y = 0;
1037         src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
1038         src.h = rtext -> h;
1039         dest -> x = cell_offset_x;
1040         dest -> y = desty;
1041         SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1042         SDL_FreeSurface ( rtext );
1043         dest++;
1044         desty += src.h;
1045       }
1046
1047       // category
1048 #if 0
1049       if ( ui_selected -> ref -> main_category ) {
1050
1051         sprintf ( buffer, "Category: %s", ui_selected -> ref -> main_category );
1052
1053         SDL_Surface *rtext;
1054         rtext = TTF_RenderText_Blended ( g_detailtext_font, buffer, c -> fontcolor );
1055         src.x = 0;
1056         src.y = 0;
1057         src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
1058         src.h = rtext -> h;
1059         dest -> x = cell_offset_x;
1060         dest -> y = desty;
1061         SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1062         SDL_FreeSurface ( rtext );
1063         dest++;
1064         desty += src.h;
1065       }
1066 #endif
1067
1068       // clock
1069       if ( ui_selected -> ref -> clockspeed ) {
1070
1071         sprintf ( buffer, "CPU Clock: %s", ui_selected -> ref -> clockspeed );
1072
1073         SDL_Surface *rtext;
1074         rtext = TTF_RenderText_Blended ( g_detailtext_font, buffer, c -> fontcolor );
1075         src.x = 0;
1076         src.y = 0;
1077         src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
1078         src.h = rtext -> h;
1079         dest -> x = cell_offset_x;
1080         dest -> y = desty;
1081         SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1082         SDL_FreeSurface ( rtext );
1083         dest++;
1084         desty += src.h;
1085       }
1086
1087       // show sub-app# on right side of cpu clock?
1088       //if ( ui_selected -> ref -> subapp_number )
1089       {
1090         sprintf ( buffer, "(app#%u)", ui_selected -> ref -> subapp_number );
1091
1092         SDL_Surface *rtext;
1093         rtext = TTF_RenderText_Blended ( g_grid_font, buffer, c -> fontcolor );
1094         dest -> x = cell_offset_x + cell_width - rtext -> w;
1095         dest -> y = desty - src.h;
1096         SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
1097         SDL_FreeSurface ( rtext );
1098         dest++;
1099       }
1100
1101       // info hint
1102 #if 0 // merged into hint-line
1103       if ( ui_selected -> ref -> info_filename ) {
1104
1105         sprintf ( buffer, "Documentation - hit Y" );
1106
1107         SDL_Surface *rtext;
1108         rtext = TTF_RenderText_Blended ( g_detailtext_font, buffer, c -> fontcolor );
1109         src.x = 0;
1110         src.y = 0;
1111         src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
1112         src.h = rtext -> h;
1113         dest -> x = cell_offset_x;
1114         dest -> y = desty;
1115         SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1116         SDL_FreeSurface ( rtext );
1117         dest++;
1118         desty += src.h;
1119       }
1120 #endif
1121
1122       // notes
1123       if ( ui_selected -> ovrh ) {
1124         char *n;
1125         unsigned char i;
1126         char buffer [ 50 ];
1127
1128         desty += 5; // a touch of spacing can't hurt
1129
1130         for ( i = 1; i < 4; i++ ) {
1131           sprintf ( buffer, "Application-%u.note-%u", ui_selected -> ref -> subapp_number, i );
1132           n = pnd_conf_get_as_char ( ui_selected -> ovrh, buffer );
1133
1134           if ( n ) {
1135             SDL_Surface *rtext;
1136             rtext = TTF_RenderText_Blended ( g_detailtext_font, n, c -> fontcolor );
1137             src.x = 0;
1138             src.y = 0;
1139             src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
1140             src.h = rtext -> h;
1141             dest -> x = cell_offset_x;
1142             dest -> y = desty;
1143             SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1144             SDL_FreeSurface ( rtext );
1145             dest++;
1146             desty += rtext -> h;
1147           }
1148         } // for
1149
1150       } // r_detail -> notes
1151
1152       // preview pic
1153       mm_cache_t *ic = cache_query_preview ( ui_selected -> ref -> unique_id );
1154       SDL_Surface *previewpic;
1155
1156       if ( ic ) {
1157         previewpic = ic -> i;
1158       } else {
1159         previewpic = g_imagecache [ IMG_PREVIEW_MISSING ].i;
1160       }
1161
1162       if ( previewpic ) {
1163         dest -> x = pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_offset_x", 50 ) +
1164           ( ( pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 50 ) - previewpic -> w ) / 2 );
1165         dest -> y = pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_offset_y", 50 );
1166         SDL_BlitSurface ( previewpic, NULL /* whole image */, sdl_realscreen, dest );
1167         dest++;
1168       }
1169
1170     } else {
1171
1172       char *empty_message = "Press SELECT for menu";
1173
1174       SDL_Surface *rtext;
1175
1176       rtext = TTF_RenderText_Blended ( g_detailtext_font, empty_message, c -> fontcolor );
1177
1178       src.x = 0;
1179       src.y = 0;
1180       src.w = rtext -> w < cell_width ? rtext -> w : cell_width;
1181       src.h = rtext -> h;
1182       dest -> x = cell_offset_x;
1183       dest -> y = desty;
1184       SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1185       SDL_FreeSurface ( rtext );
1186       dest++;
1187
1188       desty += src.h;
1189
1190       rtext = TTF_RenderText_Blended ( g_detailtext_font, "START or B to run app", c -> fontcolor );
1191       dest -> x = cell_offset_x;
1192       dest -> y = desty;
1193       SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1194       SDL_FreeSurface ( rtext );
1195       dest++;
1196       desty += src.h;
1197
1198       rtext = TTF_RenderText_Blended ( g_detailtext_font, "SPACE for app menu", c -> fontcolor );
1199       dest -> x = cell_offset_x;
1200       dest -> y = desty;
1201       SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1202       SDL_FreeSurface ( rtext );
1203       dest++;
1204       desty += src.h;
1205
1206       rtext = TTF_RenderText_Blended ( g_detailtext_font, "A to toggle details", c -> fontcolor );
1207       dest -> x = cell_offset_x;
1208       dest -> y = desty;
1209       SDL_BlitSurface ( rtext, &src, sdl_realscreen, dest );
1210       SDL_FreeSurface ( rtext );
1211       dest++;
1212       desty += src.h;
1213
1214     } // r_detail && selected?
1215
1216   } // r_detail
1217
1218   // extras
1219   //
1220
1221   // battery
1222   if ( render_jobs_b & R_BG ) {
1223     static int last_battlevel = 0;
1224     static unsigned char batterylevel = 0;
1225     char buffer [ 100 ];
1226
1227     if ( time ( NULL ) - last_battlevel > 60 ) {
1228       batterylevel = pnd_device_get_battery_gauge_perc();
1229       last_battlevel = time ( NULL );
1230     }
1231
1232     sprintf ( buffer, "Battery: %u%%", batterylevel );
1233
1234     SDL_Surface *rtext;
1235     rtext = TTF_RenderText_Blended ( g_grid_font, buffer, c -> fontcolor );
1236     dest -> x = pnd_conf_get_as_int_d ( g_conf, "display.battery_x", 20 );
1237     dest -> y = pnd_conf_get_as_int_d ( g_conf, "display.battery_y", 450 );
1238     SDL_BlitSurface ( rtext, NULL /* all */, sdl_realscreen, dest );
1239     SDL_FreeSurface ( rtext );
1240     dest++;
1241   }
1242
1243   // hints
1244   if ( pnd_conf_get_as_char ( g_conf, "display.hintline" ) ) {
1245     char *buffer;
1246     unsigned int hintx, hinty;
1247     hintx = pnd_conf_get_as_int_d ( g_conf, "display.hint_x", 40 );
1248     hinty = pnd_conf_get_as_int_d ( g_conf, "display.hint_y", 450 );
1249     static unsigned int lastwidth = 3000;
1250
1251     if ( ui_selected && ui_selected -> ref -> info_filename ) {
1252       buffer = "Documentation - hit Y";
1253     } else {
1254       buffer = pnd_conf_get_as_char ( g_conf, "display.hintline" );
1255     }
1256
1257     SDL_Surface *rtext;
1258     rtext = TTF_RenderText_Blended ( g_grid_font, buffer, c -> fontcolor );
1259
1260     // clear bg
1261     if ( ! ( render_jobs_b & R_BG ) ) {
1262       src.x = hintx;
1263       src.y = hinty;
1264       src.w = lastwidth;
1265       src.h = rtext -> h;
1266       dest -> x = hintx;
1267       dest -> y = hinty;
1268       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_TABMASK ].i, &src, sdl_realscreen, dest );
1269       dest++;
1270       lastwidth = rtext -> w;
1271     }
1272
1273     // now render text
1274     dest -> x = hintx;
1275     dest -> y = hinty;
1276     SDL_BlitSurface ( rtext, NULL /* all */, sdl_realscreen, dest );
1277     SDL_FreeSurface ( rtext );
1278     dest++;
1279   }
1280
1281   // clock time
1282   if ( render_jobs_b & R_BG &&
1283        pnd_conf_get_as_int_d ( g_conf, "display.clock_x", -1 ) != -1 )
1284   {
1285     char buffer [ 50 ];
1286
1287     time_t t = time ( NULL );
1288     struct tm *tm = localtime ( &t );
1289     strftime ( buffer, 50, "%a %H:%M %F", tm );
1290
1291     SDL_Surface *rtext;
1292     rtext = TTF_RenderText_Blended ( g_grid_font, buffer, c -> fontcolor );
1293     dest -> x = pnd_conf_get_as_int_d ( g_conf, "display.clock_x", 700 );
1294     dest -> y = pnd_conf_get_as_int_d ( g_conf, "display.clock_y", 450 );
1295     SDL_BlitSurface ( rtext, NULL /* all */, sdl_realscreen, dest );
1296     SDL_FreeSurface ( rtext );
1297     dest++;
1298   }
1299
1300   // update all the rects and send it all to sdl
1301   // - at this point, we could probably just do 1 rect, of the
1302   //   whole screen, and be faster :/
1303   SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
1304
1305 } // ui_render
1306
1307 void ui_process_input ( pnd_dbusnotify_handle dbh, pnd_notify_handle nh ) {
1308   SDL_Event event;
1309
1310   unsigned char ui_event = 0; // if we get a ui event, flip to 1 and break
1311   //static ui_sdl_button_e ui_mask = uisb_none; // current buttons down
1312
1313   while ( ( ! ui_event ) &&
1314           /*block_p ?*/ SDL_WaitEvent ( &event ) /*: SDL_PollEvent ( &event )*/ )
1315   {
1316
1317     switch ( event.type ) {
1318
1319     case SDL_USEREVENT:
1320       // update something
1321
1322       // the user-defined SDL events are all for threaded/delayed previews (and icons, which
1323       // generally are not used); if we're in wide mode, we can skip previews
1324       // to avoid slowing things down when they're not shown.
1325
1326       if ( event.user.code == sdl_user_ticker ) {
1327
1328         if ( ui_detail_hidden ) {
1329           break; // skip building previews when not showing them
1330         }
1331
1332         // timer went off, time to load something
1333         if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_previews_later", 0 ) ) {
1334
1335           if ( ! ui_selected ) {
1336             break;
1337           }
1338
1339           // load the preview pics now!
1340           pnd_disco_t *iter = ui_selected -> ref;
1341
1342           if ( iter -> preview_pic1 ) {
1343
1344             if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.threaded_preview", 0 ) ) {
1345               // load in bg thread, make user experience chuggy
1346
1347               g_preview_thread = SDL_CreateThread ( (void*)ui_threaded_defered_preview, iter );
1348
1349               if ( ! g_preview_thread ) {
1350                 pnd_log ( pndn_error, "ERROR: Couldn't create preview thread\n" );
1351               }
1352
1353             } else {
1354               // load it now, make user wait
1355
1356               if ( ! cache_preview ( iter, pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 200 ),
1357                                      pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 180 ) )
1358                  )
1359               {
1360                 pnd_log ( pndn_debug, "  Couldn't load preview pic: '%s' -> '%s'\n",
1361                           IFNULL(iter->title_en,"No Name"), iter -> preview_pic1 );
1362               }
1363
1364             } // threaded?
1365
1366           } // got a preview at all?
1367
1368           ui_event++;
1369         }
1370
1371       } else if ( event.user.code == sdl_user_finishedpreview ) {
1372
1373         // if we just finished the one we happen to be looking at, better redraw now; otherwise, if
1374         // we finished another, no big woop
1375         if ( ui_selected && event.user.data1 == ui_selected -> ref ) {
1376           ui_event++;
1377         }
1378
1379       } else if ( event.user.code == sdl_user_finishedicon ) {
1380         // redraw, so we can show the newly loaded icon
1381         ui_event++;
1382
1383       } else if ( event.user.code == sdl_user_checksd ) {
1384         // check if any inotify-type events occured, forcing us to rescan/re-disco the SDs
1385
1386         unsigned char watch_dbus = 0;
1387         unsigned char watch_inotify = 0;
1388
1389         if ( dbh ) {
1390           watch_dbus = pnd_dbusnotify_rediscover_p ( dbh );
1391         }
1392
1393         if ( nh ) {
1394           watch_inotify = pnd_notify_rediscover_p ( nh );
1395         }
1396
1397         if ( watch_dbus || watch_inotify ) {
1398           pnd_log ( pndn_debug, "dbusnotify detected SD event\n" );
1399           applications_free();
1400           applications_scan();
1401
1402           ui_event++;
1403         }
1404
1405       } // SDL user event
1406
1407       render_mask |= CHANGED_EVERYTHING;
1408
1409       break;
1410
1411 #if 0 // joystick motion
1412     case SDL_JOYAXISMOTION:
1413
1414       pnd_log ( PND_LOG_DEFAULT, "joystick axis\n" );
1415
1416         if ( event.jaxis.axis == 0 ) {
1417           // horiz
1418           if ( event.jaxis.value < 0 ) {
1419             ui_push_left ( 0 );
1420             pnd_log ( PND_LOG_DEFAULT, "joystick axis - LEFT\n" );
1421           } else if ( event.jaxis.value > 0 ) {
1422             ui_push_right ( 0 );
1423             pnd_log ( PND_LOG_DEFAULT, "joystick axis - RIGHT\n" );
1424           }
1425         } else if ( event.jaxis.axis == 1 ) {
1426           // vert
1427           if ( event.jaxis.value < 0 ) {
1428             ui_push_up();
1429           } else if ( event.jaxis.value > 0 ) {
1430             ui_push_down();
1431           }
1432         }
1433
1434         ui_event++;
1435
1436         break;
1437 #endif
1438
1439 #if 0 // joystick buttons
1440     case SDL_JOYBUTTONDOWN:
1441
1442       pnd_log ( PND_LOG_DEFAULT, "joystick button down %u\n", event.jbutton.button );
1443
1444       if ( event.jbutton.button == 0 ) { // B
1445         ui_mask |= uisb_b;
1446       } else if ( event.jbutton.button == 1 ) { // Y
1447         ui_mask |= uisb_y;
1448       } else if ( event.jbutton.button == 2 ) { // X
1449         ui_mask |= uisb_x;
1450       } else if ( event.jbutton.button == 3 ) { // A
1451         ui_mask |= uisb_a;
1452
1453       } else if ( event.jbutton.button == 4 ) { // Select
1454         ui_mask |= uisb_select;
1455       } else if ( event.jbutton.button == 5 ) { // Start
1456         ui_mask |= uisb_start;
1457
1458       } else if ( event.jbutton.button == 7 ) { // L
1459         ui_mask |= uisb_l;
1460       } else if ( event.jbutton.button == 8 ) { // R
1461         ui_mask |= uisb_r;
1462
1463       }
1464
1465       ui_event++;
1466
1467       break;
1468
1469     case SDL_JOYBUTTONUP:
1470
1471       pnd_log ( PND_LOG_DEFAULT, "joystick button up %u\n", event.jbutton.button );
1472
1473       if ( event.jbutton.button == 0 ) { // B
1474         ui_mask &= ~uisb_b;
1475         ui_push_exec();
1476       } else if ( event.jbutton.button == 1 ) { // Y
1477         ui_mask &= ~uisb_y;
1478       } else if ( event.jbutton.button == 2 ) { // X
1479         ui_mask &= ~uisb_x;
1480       } else if ( event.jbutton.button == 3 ) { // A
1481         ui_mask &= ~uisb_a;
1482
1483       } else if ( event.jbutton.button == 4 ) { // Select
1484         ui_mask &= ~uisb_select;
1485       } else if ( event.jbutton.button == 5 ) { // Start
1486         ui_mask &= ~uisb_start;
1487
1488       } else if ( event.jbutton.button == 7 ) { // L
1489         ui_mask &= ~uisb_l;
1490         ui_push_ltrigger();
1491       } else if ( event.jbutton.button == 8 ) { // R
1492         ui_mask &= ~uisb_r;
1493         ui_push_rtrigger();
1494
1495       }
1496
1497       ui_event++;
1498
1499       break;
1500 #endif
1501
1502 #if 1 // keyboard events
1503     //case SDL_KEYUP:
1504     case SDL_KEYDOWN:
1505
1506       //pnd_log ( pndn_debug, "key up %u\n", event.key.keysym.sym );
1507
1508       // SDLK_LALT -> Start
1509       // page up/down for y/x
1510       // home/end for a and b
1511
1512       // directional
1513       if ( event.key.keysym.sym == SDLK_RIGHT ) {
1514         ui_push_right ( 0 );
1515         ui_event++;
1516       } else if ( event.key.keysym.sym == SDLK_LEFT ) {
1517         ui_push_left ( 0 );
1518         ui_event++;
1519       } else if ( event.key.keysym.sym == SDLK_UP ) {
1520         ui_push_up();
1521         ui_event++;
1522       } else if ( event.key.keysym.sym == SDLK_DOWN ) {
1523         ui_push_down();
1524         ui_event++;
1525       } else if ( event.key.keysym.sym == SDLK_END ) { // B
1526         ui_push_exec();
1527         ui_event++;
1528       } else if ( event.key.keysym.sym == SDLK_SPACE ) { // space
1529         if ( ui_selected ) {
1530           ui_menu_context ( ui_selected );
1531         } else {
1532           // TBD: post an error?
1533         }
1534         render_mask |= CHANGED_EVERYTHING;
1535         ui_event++;
1536       } else if ( event.key.keysym.sym == SDLK_TAB || event.key.keysym.sym == SDLK_HOME ) { // tab or A
1537         // if detail panel is togglable, then toggle it
1538         // if not, make sure its ruddy well shown!
1539         if ( ui_is_detail_hideable() ) {
1540           ui_toggle_detail_pane();
1541         } else {
1542           ui_detail_hidden = 0;
1543         }
1544         ui_event++;
1545       } else if ( event.key.keysym.sym == SDLK_RSHIFT || event.key.keysym.sym == SDLK_COMMA ) { // left trigger or comma
1546         ui_push_ltrigger();
1547         ui_event++;
1548       } else if ( event.key.keysym.sym == SDLK_RCTRL || event.key.keysym.sym == SDLK_PERIOD ) { // right trigger or period
1549         ui_push_rtrigger();
1550         ui_event++;
1551
1552       } else if ( event.key.keysym.sym == SDLK_PAGEUP ) { // Y
1553         // info
1554         if ( ui_selected ) {
1555           ui_show_info ( pnd_run_script, ui_selected -> ref );
1556           ui_event++;
1557         }
1558       } else if ( event.key.keysym.sym == SDLK_PAGEDOWN ) { // X
1559         ui_push_backup();
1560
1561         // forget the selection, nolonger applies
1562         ui_selected = NULL;
1563         ui_set_selected ( ui_selected );
1564         // rescan the dir
1565         if ( g_categories [ ui_category ] -> fspath ) {
1566           category_fs_restock ( g_categories [ ui_category ] );
1567         }
1568         // redraw the grid
1569         render_mask |= CHANGED_EVERYTHING;
1570         ui_event++;
1571
1572       } else if ( event.key.keysym.sym == SDLK_LALT ) { // start button
1573         ui_push_exec();
1574         ui_event++;
1575
1576       } else if ( event.key.keysym.sym == SDLK_LCTRL /*LALT*/ ) { // select button
1577         char *opts [ 20 ] = {
1578           "Reveal hidden category",
1579           "Shutdown Pandora",
1580           "Configure Minimenu",
1581           "Manage custom app categories",
1582           "Rescan for applications",
1583           "Cache previews to SD now",
1584           "Run a terminal/console",
1585           "Run another GUI (xfce, etc)",
1586           "Quit (<- beware)",
1587           "Select a Minimenu skin",
1588           "About Minimenu"
1589         };
1590         int sel = ui_modal_single_menu ( opts, 11, "Minimenu", "Enter to select; other to return." );
1591
1592         char buffer [ 100 ];
1593         if ( sel == 0 ) {
1594           // do nothing
1595           ui_revealscreen();
1596         } else if ( sel == 1 ) {
1597           // store conf on exit, so that last app/cat can be cached.. for ED :)
1598           conf_write ( g_conf, conf_determine_location ( g_conf ) );
1599           // shutdown
1600           sprintf ( buffer, "sudo poweroff" );
1601           system ( buffer );
1602         } else if ( sel == 2 ) {
1603           // configure mm
1604           unsigned char restart = conf_run_menu ( NULL );
1605           conf_write ( g_conf, conf_determine_location ( g_conf ) );
1606           conf_write ( g_conf, CONF_PREF_TEMPPATH );
1607           if ( restart ) {
1608             emit_and_quit ( MM_RESTART );
1609           }
1610         } else if ( sel == 3 ) {
1611           // manage custom categories
1612           ui_manage_categories();
1613         } else if ( sel == 4 ) {
1614           // rescan apps
1615           pnd_log ( pndn_debug, "Freeing up applications\n" );
1616           applications_free();
1617           pnd_log ( pndn_debug, "Rescanning applications\n" );
1618           applications_scan();
1619         } else if ( sel == 5 ) {
1620           // cache preview to SD now
1621           extern pnd_box_handle g_active_apps;
1622           pnd_box_handle h = g_active_apps;
1623
1624           unsigned int maxwidth, maxheight;
1625           maxwidth = pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 200 );
1626           maxheight = pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 180 );
1627
1628           pnd_disco_t *iter = pnd_box_get_head ( h );
1629
1630           while ( iter ) {
1631
1632             // cache it
1633             if ( ! cache_preview ( iter, maxwidth, maxheight ) ) {
1634               pnd_log ( pndn_debug, "Force cache: Couldn't load preview pic: '%s' -> '%s'\n",
1635                         IFNULL(iter->title_en,"No Name"), iter -> preview_pic1 );
1636             }
1637
1638             // next
1639             iter = pnd_box_get_next ( iter );
1640           } // while
1641
1642         } else if ( sel == 6 ) {
1643           // run terminal
1644           char *argv[5];
1645           argv [ 0 ] = pnd_conf_get_as_char ( g_conf, "utility.terminal" );
1646           argv [ 1 ] = NULL;
1647
1648           if ( argv [ 0 ] ) {
1649             ui_forkexec ( argv );
1650           }
1651
1652         } else if ( sel == 7 ) {
1653           char buffer [ PATH_MAX ];
1654           sprintf ( buffer, "%s %s\n", MM_RUN, "/usr/pandora/scripts/op_switchgui.sh" );
1655           emit_and_quit ( buffer );
1656         } else if ( sel == 8 ) {
1657           emit_and_quit ( MM_QUIT );
1658         } else if ( sel == 9 ) {
1659           // select skin
1660           if ( ui_pick_skin() ) {
1661             emit_and_quit ( MM_RESTART );
1662           }
1663         } else if ( sel == 10 ) {
1664           // about
1665           char buffer [ PATH_MAX ];
1666           sprintf ( buffer, "%s/about.txt", g_skinpath );
1667           ui_aboutscreen ( buffer );
1668         }
1669
1670         ui_event++;
1671         render_mask |= CHANGED_EVERYTHING;
1672
1673       } else {
1674         // unknown SDLK_ keycode?
1675
1676         // many SDLK_keycodes map to ASCII ("a" is ascii(a)), so try to jump to a filename of that name, in this category?
1677         // and if already there, try to jump to next, maybe?
1678         // future: look for sequence typing? ie: user types 'm' then 'a', look for 'ma*' instead of 'm' then 'a' matching
1679         if ( isalpha ( event.key.keysym.sym ) && g_categories [ ui_category ] -> refcount > 0 ) {
1680           mm_appref_t *app = g_categories [ ui_category ] -> refs;
1681
1682           //fprintf ( stderr, "sel %s next %s\n", ui_selected -> ref -> title_en, ui_selected -> next -> ref -> title_en );
1683
1684           // are we already matching the same char? and next item is also same char?
1685           if ( app && ui_selected && ui_selected -> next &&
1686                ui_selected -> ref -> title_en && ui_selected -> next -> ref -> title_en &&
1687                toupper ( ui_selected -> ref -> title_en [ 0 ] ) == toupper ( ui_selected -> next -> ref -> title_en [ 0 ] ) &&
1688                toupper ( ui_selected -> ref -> title_en [ 0 ] ) == toupper ( event.key.keysym.sym )
1689              )
1690           {
1691             // just skip down one
1692             app = ui_selected -> next;
1693           } else {
1694
1695             // walk the category, looking for a first-char match
1696             while ( app ) {
1697               if ( app -> ref -> title_en && toupper ( app -> ref -> title_en [ 0 ] ) == toupper ( event.key.keysym.sym ) ) {
1698                 break;
1699               }
1700               app = app -> next;
1701             }
1702
1703           } // same start letter, or new run?
1704
1705           // found something, or no?
1706           if ( app ) {
1707             // looks like we found a potential match; try switching it to visible selection
1708             ui_selected = app;
1709             ui_set_selected ( ui_selected );
1710             ui_event++;
1711           }
1712
1713
1714         } // SDLK_alphanumeric?
1715
1716       } // SDLK_....
1717
1718       // extras
1719 #if 1
1720       if ( event.key.keysym.sym == SDLK_ESCAPE ) {
1721         emit_and_quit ( MM_QUIT );
1722       }
1723 #endif
1724
1725       break;
1726 #endif
1727
1728 #if 1 // mouse / touchscreen
1729 #if 0
1730     case SDL_MOUSEBUTTONDOWN:
1731       if ( event.button.button == SDL_BUTTON_LEFT ) {
1732         cb_pointer_press ( gc, event.button.x / g_scale, event.button.y / g_scale );
1733         ui_event++;
1734       }
1735       break;
1736 #endif
1737
1738     case SDL_MOUSEBUTTONUP:
1739       if ( event.button.button == SDL_BUTTON_LEFT ) {
1740         ui_touch_act ( event.button.x, event.button.y );
1741         ui_event++;
1742       }
1743       break;
1744 #endif
1745
1746     case SDL_QUIT:
1747       exit ( 0 );
1748       break;
1749
1750     default:
1751       break;
1752
1753     } // switch event type
1754
1755   } // while poll
1756
1757   return;
1758 }
1759
1760 void ui_push_left ( unsigned char forcecoil ) {
1761
1762   if ( ui_viewmode == uiv_list ) {
1763     ui_context_t *c = &ui_display_context;
1764     int i;
1765     int imax = ( c -> cell_height * c -> row_max ) / ( c -> text_height + c -> icon_offset_y ); // visible rows
1766     for ( i = 0; i < imax; i++ ) {
1767       ui_push_up();
1768     }
1769     return;
1770   }
1771
1772   if ( ! ui_selected ) {
1773     ui_push_right ( 0 );
1774     return;
1775   }
1776
1777   // what column we in?
1778   unsigned int col = ui_determine_screen_col ( ui_selected );
1779
1780   // are we already at first item?
1781   if ( forcecoil == 0 &&
1782        pnd_conf_get_as_int_d ( g_conf, "grid.wrap_horiz_samerow", 0 ) &&
1783        col == 0 )
1784   {
1785     unsigned int i = ui_display_context.col_max - 1;
1786     while ( i && ui_selected -> next ) {
1787       ui_push_right ( 0 );
1788       i--;
1789     }
1790
1791   } else if ( g_categories [ ui_category ] -> refs == ui_selected ) {
1792     // can't go any more left, we're at the head
1793
1794   } else {
1795     // figure out the previous item; yay for singly linked list :/
1796     mm_appref_t *i = g_categories [ ui_category ] -> refs;
1797     while ( i ) {
1798       if ( i -> next == ui_selected ) {
1799         ui_selected = i;
1800         break;
1801       }
1802       i = i -> next;
1803     }
1804   }
1805
1806   ui_set_selected ( ui_selected );
1807
1808   return;
1809 }
1810
1811 void ui_push_right ( unsigned char forcecoil ) {
1812
1813   if ( ui_viewmode == uiv_list ) {
1814     ui_context_t *c = &ui_display_context;
1815     int i;
1816     int imax = ( c -> cell_height * c -> row_max ) / ( c -> text_height + c -> icon_offset_y ); // visible rows
1817     for ( i = 0; i < imax; i++ ) {
1818       ui_push_down();
1819     }
1820     return;
1821   }
1822
1823   if ( ui_selected ) {
1824
1825     // what column we in?
1826     unsigned int col = ui_determine_screen_col ( ui_selected );
1827
1828     // wrap same or no?
1829     if ( forcecoil == 0 &&
1830          pnd_conf_get_as_int_d ( g_conf, "grid.wrap_horiz_samerow", 0 ) &&
1831          // and selected is far-right, or last icon in category (might not be far right)
1832          ( ( col == ui_display_context.col_max - 1 ) ||
1833            ( ui_selected -> next == NULL ) )
1834        )
1835     {
1836       // same wrap
1837       //unsigned int i = pnd_conf_get_as_int_d ( g_conf, "grid.col_max", 5 ) - 1;
1838       while ( col /*i*/ ) {
1839         ui_push_left ( 0 );
1840         col--; //i--;
1841       }
1842
1843     } else {
1844       // just go to the next
1845
1846       if ( ui_selected -> next ) {
1847         ui_selected = ui_selected -> next;
1848       }
1849
1850     }
1851
1852   } else {
1853     ui_selected = g_categories [ ui_category ] -> refs;
1854   }
1855
1856   ui_set_selected ( ui_selected );
1857
1858   return;
1859 }
1860
1861 void ui_push_up ( void ) {
1862
1863   unsigned char col_max = ui_display_context.col_max;
1864
1865   // not selected? well, no where to go..
1866   if ( ! ui_selected ) {
1867     return;
1868   }
1869
1870   if ( ui_viewmode == uiv_list ) {
1871
1872     if ( g_categories [ ui_category ] -> refs == ui_selected ) {
1873       // can't go any more up, we're at the head
1874
1875     } else {
1876       // figure out the previous item; yay for singly linked list :/
1877       mm_appref_t *i = g_categories [ ui_category ] -> refs;
1878       while ( i ) {
1879         if ( i -> next == ui_selected ) {
1880           ui_selected = i;
1881           break;
1882         }
1883         i = i -> next;
1884       }
1885
1886     }
1887
1888     // for list view.. we're done
1889     ui_set_selected ( ui_selected );
1890     return;
1891   }
1892
1893   // what row we in?
1894   unsigned int row = ui_determine_row ( ui_selected );
1895
1896   if ( row == 0 &&
1897        pnd_conf_get_as_int_d ( g_conf, "grid.wrap_vert_stop", 0 ) == 0 )
1898   {
1899     // wrap around instead
1900
1901     unsigned int col = ui_determine_screen_col ( ui_selected );
1902
1903     // go to end
1904     ui_selected = g_categories [ ui_category ] -> refs;
1905     while ( ui_selected -> next ) {
1906       ui_selected = ui_selected -> next;
1907     }
1908
1909     // try to move to same column
1910     unsigned int newcol = ui_determine_screen_col ( ui_selected );
1911     if ( newcol > col ) {
1912       col = newcol - col;
1913       while ( col ) {
1914         ui_push_left ( 0 );
1915         col--;
1916       }
1917     }
1918
1919     // scroll down to show it
1920     int r = ui_determine_row ( ui_selected ) - 1;
1921     if ( r - ui_display_context.row_max > 0 ) {
1922       ui_rows_scrolled_down = (unsigned int) r;
1923     }
1924
1925   } else {
1926     // stop at top/bottom
1927
1928     while ( col_max ) {
1929       ui_push_left ( 1 );
1930       col_max--;
1931     }
1932
1933   }
1934
1935   return;
1936 }
1937
1938 void ui_push_down ( void ) {
1939
1940   if ( ui_viewmode == uiv_list ) {
1941
1942     if ( ui_selected ) {
1943
1944       if ( ui_selected -> next ) {
1945         ui_selected = ui_selected -> next;
1946       }
1947
1948     } else {
1949       ui_selected = g_categories [ ui_category ] -> refs; // frist!
1950     }
1951
1952     // list view? we're done.
1953     ui_set_selected ( ui_selected );
1954     return;
1955   }
1956
1957   unsigned char col_max = ui_display_context.col_max;
1958
1959   if ( ui_selected ) {
1960
1961     // what row we in?
1962     unsigned int row = ui_determine_row ( ui_selected );
1963
1964     // max rows?
1965     unsigned int icon_rows = g_categories [ ui_category ] -> refcount / col_max;
1966     if ( g_categories [ ui_category ] -> refcount % col_max > 0 ) {
1967       icon_rows++;
1968     }
1969
1970     // we at the end?
1971     if ( row == ( icon_rows - 1 ) &&
1972          pnd_conf_get_as_int_d ( g_conf, "grid.wrap_vert_stop", 0 ) == 0 )
1973     {
1974
1975       unsigned char col = ui_determine_screen_col ( ui_selected );
1976
1977       ui_selected = g_categories [ ui_category ] -> refs;
1978
1979       while ( col ) {
1980         ui_selected = ui_selected -> next;
1981         col--;
1982       }
1983
1984       ui_rows_scrolled_down = 0;
1985
1986       render_mask |= CHANGED_EVERYTHING;
1987
1988     } else {
1989
1990       while ( col_max ) {
1991         ui_push_right ( 1 );
1992         col_max--;
1993       }
1994
1995     }
1996
1997   } else {
1998     ui_push_right ( 0 );
1999   }
2000
2001   return;
2002 }
2003
2004 // 'backup' is currently 'X', for going back up in a folder/subcat without having to hit exec on the '..' entry
2005 void ui_push_backup ( void ) {
2006
2007   // a subcat-as-dir, or a dir browser?
2008   if ( g_categories [ ui_category] -> fspath ) {
2009     // dir browser, just climb our way back up
2010
2011     // go up
2012     char *c;
2013
2014     // lop off last word; if the thing ends with /, lop that one, then the next word.
2015     while ( ( c = strrchr ( g_categories [ ui_category] -> fspath, '/' ) ) ) {
2016       *c = '\0'; // lop off the last hunk
2017       if ( *(c+1) != '\0' ) {
2018         break;
2019       }
2020     } // while
2021
2022     // nothing left?
2023     if ( g_categories [ ui_category] -> fspath [ 0 ] == '\0' ) {
2024       free ( g_categories [ ui_category] -> fspath );
2025       g_categories [ ui_category] -> fspath = strdup ( "/" );
2026     }
2027
2028   } else {
2029     // a pnd subcat .. are we in one, or at the 'top'?
2030     char *pcatname = g_categories [ ui_category ] -> parent_catname;
2031
2032     if ( ! pcatname ) {
2033       return; // we're at the 'top' already
2034     }
2035
2036     // set to first cat!
2037     ui_category = 0;
2038
2039     // republish cats .. shoudl just be the one
2040     category_publish ( CFNORMAL, NULL );
2041
2042     if ( pcatname ) {
2043       ui_category = category_index ( pcatname );
2044
2045       // ensure tab visible?
2046       unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
2047       if ( ui_category > ui_catshift + ( ui_display_context.screen_width / tab_width ) - 1 ) {
2048         ui_catshift = ui_category - ( ui_display_context.screen_width / tab_width ) + 1;
2049       }
2050
2051     }
2052
2053   } // dir or subcat?
2054
2055   return;
2056 }
2057
2058 void ui_push_exec ( void ) {
2059
2060   if ( ! ui_selected ) {
2061     return;
2062   }
2063
2064   // cache the category/app so we can come back to it another time
2065   if ( ui_selected ) {
2066     pnd_conf_set_char ( g_conf, "minimenu.last_known_app_uid", ui_selected -> ref -> unique_id );
2067   }
2068   if ( g_categories [ 0 ] ) {
2069     pnd_conf_set_char ( g_conf, "minimenu.last_known_catname", g_categories [ ui_category ] -> catname );
2070
2071     // and also the parent cat..
2072     if ( g_categories [ ui_category ] -> parent_catname ) {
2073       pnd_conf_set_char ( g_conf, "minimenu.last_known_parentcatname", g_categories [ ui_category ] -> parent_catname );
2074     } else {
2075       char *kv = pnd_box_find_by_key ( g_conf, "minimenu.last_known_parentcatname" );
2076       if ( kv ) {
2077         pnd_box_delete_node ( g_conf, kv );
2078       }
2079
2080     }
2081   }
2082
2083   // cache last known cat/app to /tmp, so we can use it again later
2084   conf_write ( g_conf, CONF_PREF_TEMPPATH );
2085
2086   // was this icon generated from filesystem, or from pnd-file?
2087   if ( ui_selected -> ref -> object_flags & PND_DISCO_GENERATED ) {
2088
2089     if ( ! ui_selected -> ref -> title_en ) {
2090       return; // no filename
2091     }
2092
2093     if ( ui_selected -> ref -> object_type == pnd_object_type_directory ) {
2094
2095       // check if this guy is a dir-browser tab, or is a directory on a pnd tab
2096       if ( ! g_categories [ ui_category] -> fspath ) {
2097         // pnd subcat as dir
2098
2099         // are we already in a subcat? if so, go back to parent; there is no grandparenting or deeper
2100         if ( g_categories [ ui_category ] -> parent_catname ) {
2101           // go back up
2102           ui_push_backup();
2103
2104         } else {
2105           // delve into subcat
2106
2107           // set to first cat!
2108           ui_category = 0;
2109           ui_catshift = 0;
2110
2111           // republish cats .. shoudl just be the one
2112           category_publish ( CFBYNAME, ui_selected -> ref -> object_path );
2113
2114         }
2115
2116         // forget the selection, nolonger applies
2117         ui_selected = NULL;
2118         ui_set_selected ( ui_selected );
2119         // redraw the grid
2120         render_mask |= CHANGED_EVERYTHING;
2121
2122       } else {
2123
2124         // delve up/down the dir tree
2125         if ( strcmp ( ui_selected -> ref -> title_en, ".." ) == 0 ) {
2126           ui_push_backup();
2127
2128         } else {
2129           // go down
2130           char *temp = malloc ( strlen ( g_categories [ ui_category] -> fspath ) + strlen ( ui_selected -> ref -> title_en ) + 1 + 1 );
2131           sprintf ( temp, "%s/%s", g_categories [ ui_category] -> fspath, ui_selected -> ref -> title_en );
2132           free ( g_categories [ ui_category] -> fspath );
2133           g_categories [ ui_category] -> fspath = temp;
2134         }
2135
2136         pnd_log ( pndn_debug, "Cat %s is now in path %s\n", g_categories [ ui_category ] -> catname, g_categories [ ui_category ]-> fspath );
2137
2138         // forget the selection, nolonger applies
2139         ui_selected = NULL;
2140         ui_set_selected ( ui_selected );
2141         // rescan the dir
2142         category_fs_restock ( g_categories [ ui_category ] );
2143         // redraw the grid
2144         render_mask |= CHANGED_SELECTION;
2145
2146       } // directory browser or pnd subcat?
2147
2148     } else {
2149       // just run it arbitrarily?
2150
2151       // if this a pnd-file, or just some executable?
2152       if ( strcasestr ( ui_selected -> ref -> object_filename, PND_PACKAGE_FILEEXT ) ) {
2153         // looks like a pnd, now what do we do..
2154         pnd_box_handle h = pnd_disco_file ( ui_selected -> ref -> object_path, ui_selected -> ref -> object_filename );
2155
2156         if ( h ) {
2157           pnd_disco_t *d = pnd_box_get_head ( h );
2158           pnd_apps_exec_disco ( pnd_run_script, d, PND_EXEC_OPTION_NORUN, NULL );
2159           char buffer [ PATH_MAX ];
2160           sprintf ( buffer, "%s %s\n", MM_RUN, pnd_apps_exec_runline() );
2161           if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.live_on_run", 0 ) == 0 ) {
2162             emit_and_quit ( buffer );
2163           } else {
2164             emit_and_run ( buffer );
2165           }
2166         }
2167
2168       } else {
2169         // random bin file
2170
2171         // is it even executable? if we don't have handlers for non-executables yet (Jan 2011 we don't),
2172         // then don't even try to run things not-flagged as executable.. but wait most people are on
2173         // FAT filesystems, what a drag, we can't tell at the fs level.
2174         // ... but we can still invoke 'file' and grep out the good bits, at least.
2175         //
2176         // open a stream reading 'file /path/to/file' and check output for 'executable'
2177         // -- not checking for "ARM" so it can pick up x86 (or whatever native) executables in build environment
2178         unsigned char is_executable = 0;
2179
2180         // popen test
2181         {
2182           char popenbuf [ FILENAME_MAX ];
2183           snprintf ( popenbuf, FILENAME_MAX, "%s %s/%s", MIMETYPE_EXE, g_categories [ ui_category ] -> fspath, ui_selected -> ref -> title_en );
2184
2185           FILE *marceau;
2186           if ( ! ( marceau = popen ( popenbuf, "r" ) ) ) {
2187             return; // error, we need some useful error handling and dialog boxes here
2188           }
2189
2190           if ( fgets ( popenbuf, FILENAME_MAX, marceau ) ) {
2191             //printf ( "File test returns: %s\n", popenbuf );
2192             if ( strstr ( popenbuf, "executable" ) != NULL ) {
2193               is_executable = 1;
2194             }
2195           }
2196
2197           pclose ( marceau );
2198
2199         } // popen test
2200
2201         if ( ! is_executable ) {
2202           fprintf ( stderr, "ERROR: File to invoke is not executable, skipping. (%s)\n", ui_selected -> ref -> title_en );
2203           return; // need some error handling here
2204         }
2205
2206 #if 0 // eat up any pending SDL events and toss 'em?
2207         {
2208           SDL_PumpEvents();
2209           SDL_Event e;
2210           while ( SDL_PeepEvents ( &e, 1, SDL_GETEVENT, SDL_ALLEVENTS ) > 0 ) {
2211             // spin
2212           }
2213         }
2214 #endif
2215
2216 #if 1
2217         // just exec it
2218         //
2219
2220         // get CWD so we can restore it on return
2221         char cwd [ PATH_MAX ];
2222         getcwd ( cwd, PATH_MAX );
2223
2224         // full path to executable so we don't rely on implicit "./"
2225         char execbuf [ FILENAME_MAX ];
2226         snprintf ( execbuf, FILENAME_MAX, "%s/%s", g_categories [ ui_category ] -> fspath, ui_selected -> ref -> title_en );
2227
2228         // do it!
2229         chdir ( g_categories [ ui_category ] -> fspath );
2230         exec_raw_binary ( execbuf /*ui_selected -> ref -> title_en*/ );
2231         chdir ( cwd );
2232 #else
2233         // DEPRECATED / NOT TESTED
2234         // get mmwrapper to run it
2235         char buffer [ PATH_MAX ];
2236         sprintf ( buffer, "%s %s/%s\n", MM_RUN, g_categories [ ui_category ] -> fspath, ui_selected -> ref -> title_en );
2237         if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.live_on_run", 0 ) == 0 ) {
2238           emit_and_quit ( buffer );
2239         } else {
2240           emit_and_run ( buffer );
2241         }
2242 #endif
2243       } // pnd or bin?
2244
2245     } // dir or file?
2246
2247   } else {
2248
2249     // set app-run speed
2250     int use_run_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.use_run_speed", 0 );
2251     if ( use_run_speed > 0 ) {
2252       int mm_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.run_speed", -1 );
2253       if ( mm_speed > -1 ) {
2254         char buffer [ 512 ];
2255         snprintf ( buffer, 500, "sudo /usr/pandora/scripts/op_cpuspeed.sh %d", mm_speed );
2256         system ( buffer );
2257       }
2258     } // do speed change?
2259
2260     // request app to run and quit mmenu
2261     pnd_apps_exec_disco ( pnd_run_script, ui_selected -> ref, PND_EXEC_OPTION_NORUN, NULL );
2262     char buffer [ PATH_MAX ];
2263     sprintf ( buffer, "%s %s\n", MM_RUN, pnd_apps_exec_runline() );
2264     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.live_on_run", 0 ) == 0 ) {
2265       emit_and_quit ( buffer );
2266     } else {
2267       emit_and_run ( buffer );
2268     }
2269   }
2270
2271   return;
2272 }
2273
2274 void ui_push_ltrigger ( void ) {
2275   unsigned char oldcat = ui_category;
2276   unsigned int screen_width = ui_display_context.screen_width;
2277   unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
2278
2279   if ( g_categorycount == 0 ) {
2280     return;
2281   }
2282
2283   if ( g_icon_thread_busy ) {
2284     ui_stop_defered_icon_thread();
2285   }
2286
2287   if ( ui_category > 0 ) {
2288     ui_category--;
2289     category_fs_restock ( g_categories [ ui_category ] );
2290   } else {
2291     if ( pnd_conf_get_as_int_d ( g_conf, "tabs.wraparound", 0 ) > 0 ) {
2292       ui_category = g_categorycount - 1;
2293       ui_catshift = 0;
2294       if ( ui_category >= ( screen_width / tab_width ) ) {
2295         ui_catshift = ui_category - ( screen_width / tab_width ) + 1;
2296       }
2297       category_fs_restock ( g_categories [ ui_category ] );
2298     }
2299   }
2300
2301   if ( oldcat != ui_category ) {
2302     ui_selected = NULL;
2303     ui_set_selected ( ui_selected );
2304   }
2305
2306   // make tab visible?
2307   if ( ui_catshift > 0 && ui_category == ui_catshift - 1 ) {
2308     ui_catshift--;
2309   }
2310
2311   // unscroll
2312   ui_rows_scrolled_down = 0;
2313
2314   render_mask |= CHANGED_CATEGORY;
2315   ui_start_defered_icon_thread();
2316
2317   return;
2318 }
2319
2320 void ui_push_rtrigger ( void ) {
2321   unsigned char oldcat = ui_category;
2322
2323   if ( g_categorycount == 0 ) {
2324     return;
2325   }
2326
2327   if ( g_icon_thread_busy ) {
2328     ui_stop_defered_icon_thread();
2329   }
2330
2331   unsigned int screen_width = ui_display_context.screen_width;
2332   unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
2333
2334   if ( ui_category < ( g_categorycount - 1 ) ) {
2335     ui_category++;
2336     category_fs_restock ( g_categories [ ui_category ] );
2337   } else {
2338     if ( pnd_conf_get_as_int_d ( g_conf, "tabs.wraparound", 0 ) > 0 ) {
2339       ui_category = 0;
2340       ui_catshift = 0;
2341       category_fs_restock ( g_categories [ ui_category ] );
2342     }
2343   }
2344
2345   if ( oldcat != ui_category ) {
2346     ui_selected = NULL;
2347     ui_set_selected ( ui_selected );
2348   }
2349
2350   // make tab visible?
2351   if ( ui_category > ui_catshift + ( screen_width / tab_width ) - 1 ) {
2352     ui_catshift++;
2353   }
2354
2355   // unscroll
2356   ui_rows_scrolled_down = 0;
2357
2358   render_mask |= CHANGED_CATEGORY;
2359   ui_start_defered_icon_thread();
2360
2361   return;
2362 }
2363
2364 SDL_Surface *ui_scale_image ( SDL_Surface *s, unsigned int maxwidth, int maxheight ) {
2365   double scale = 1000000.0;
2366   double scalex = 1000000.0;
2367   double scaley = 1000000.0;
2368   SDL_Surface *scaled;
2369
2370   scalex = (double)maxwidth / (double)s -> w;
2371
2372   if ( maxheight == -1 ) {
2373     scale = scalex;
2374   } else {
2375     scaley = (double)maxheight / (double)s -> h;
2376
2377     if ( scaley < scalex ) {
2378       scale = scaley;
2379     } else {
2380       scale = scalex;
2381     }
2382
2383   }
2384
2385   scaled = rotozoomSurface ( s, 0 /* angle*/, scale /* scale */, 1 /* smooth==1*/ );
2386   SDL_FreeSurface ( s );
2387   s = scaled;
2388
2389   return ( s );
2390 }
2391
2392 void ui_loadscreen ( void ) {
2393
2394   SDL_Rect dest;
2395
2396   // clear the screen
2397   SDL_FillRect( SDL_GetVideoSurface(), NULL, 0 );
2398
2399   // render text
2400   SDL_Surface *rtext;
2401   rtext = TTF_RenderText_Blended ( g_big_font, "Setting up menu...", ui_display_context.fontcolor );
2402   dest.x = 20;
2403   dest.y = 20;
2404   SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, &dest );
2405   SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2406   SDL_FreeSurface ( rtext );
2407
2408   return;
2409 }
2410
2411 void ui_discoverscreen ( unsigned char clearscreen ) {
2412
2413   SDL_Rect dest;
2414
2415   // clear the screen
2416   if ( clearscreen ) {
2417     SDL_FillRect( SDL_GetVideoSurface(), NULL, 0 );
2418
2419     // render background
2420     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
2421       dest.x = 0;
2422       dest.y = 0;
2423       dest.w = sdl_realscreen -> w;
2424       dest.h = sdl_realscreen -> h;
2425       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, NULL /* whole image */, sdl_realscreen, NULL /* 0,0 */ );
2426       SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2427     }
2428
2429   }
2430
2431   // render text
2432   SDL_Surface *rtext;
2433   rtext = TTF_RenderText_Blended ( g_big_font, "Looking for applications...", ui_display_context.fontcolor );
2434   if ( clearscreen ) {
2435     dest.x = 20;
2436     dest.y = 20;
2437   } else {
2438     dest.x = 20;
2439     dest.y = 40;
2440   }
2441   SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, &dest );
2442   SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2443   SDL_FreeSurface ( rtext );
2444
2445   // render icon
2446   if ( g_imagecache [ IMG_ICON_MISSING ].i ) {
2447     dest.x = rtext -> w + 30;
2448     dest.y = 20;
2449     SDL_BlitSurface ( g_imagecache [ IMG_ICON_MISSING ].i, NULL, sdl_realscreen, &dest );
2450     SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2451   }
2452
2453   return;
2454 }
2455
2456 void ui_cachescreen ( unsigned char clearscreen, char *filename ) {
2457
2458   SDL_Rect rects [ 4 ];
2459   SDL_Rect *dest = rects;
2460   SDL_Rect src;
2461   bzero ( dest, sizeof(SDL_Rect)* 4 );
2462
2463   unsigned int font_rgba_r = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_r", 200 );
2464   unsigned int font_rgba_g = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_g", 200 );
2465   unsigned int font_rgba_b = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_b", 200 );
2466   unsigned int font_rgba_a = pnd_conf_get_as_int_d ( g_conf, "display.font_rgba_a", 100 );
2467
2468   static unsigned int stepx = 0;
2469
2470   // clear the screen
2471   if ( clearscreen ) {
2472     SDL_FillRect( SDL_GetVideoSurface(), NULL, 0 );
2473
2474     // render background
2475     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
2476       dest -> x = 0;
2477       dest -> y = 0;
2478       dest -> w = sdl_realscreen -> w;
2479       dest -> h = sdl_realscreen -> h;
2480       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, NULL /* whole image */, sdl_realscreen, NULL /* 0,0 */ );
2481       dest++;
2482     }
2483
2484   } else {
2485
2486     // render background
2487     if ( g_imagecache [ IMG_BACKGROUND_800480 ].i ) {
2488       src.x = 0;
2489       src.y = 0;
2490       src.w = sdl_realscreen -> w;
2491       src.h = 100;
2492       dest -> x = 0;
2493       dest -> y = 0;
2494       dest -> w = sdl_realscreen -> w;
2495       dest -> h = sdl_realscreen -> h;
2496       SDL_BlitSurface ( g_imagecache [ IMG_BACKGROUND_800480 ].i, &src, sdl_realscreen, dest );
2497       dest++;
2498     }
2499
2500   } // clear it
2501
2502   // render text
2503   SDL_Surface *rtext;
2504   SDL_Color tmpfontcolor = { font_rgba_r, font_rgba_g, font_rgba_b, font_rgba_a };
2505   rtext = TTF_RenderText_Blended ( g_big_font, "Caching applications artwork...", tmpfontcolor );
2506   dest -> x = 20;
2507   dest -> y = 20;
2508   SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2509   SDL_FreeSurface ( rtext );
2510   dest++;
2511
2512   // render icon
2513   if ( g_imagecache [ IMG_ICON_MISSING ].i ) {
2514     dest -> x = rtext -> w + 30 + stepx;
2515     dest -> y = 20;
2516     SDL_BlitSurface ( g_imagecache [ IMG_ICON_MISSING ].i, NULL, sdl_realscreen, dest );
2517     dest++;
2518   }
2519
2520   // filename
2521   if ( filename ) {
2522     rtext = TTF_RenderText_Blended ( g_tab_font, filename, tmpfontcolor );
2523     dest -> x = 20;
2524     dest -> y = 50;
2525     SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2526     SDL_FreeSurface ( rtext );
2527     dest++;
2528   }
2529
2530   // move across
2531   stepx += 20;
2532
2533   if ( stepx > 350 ) {
2534     stepx = 0;
2535   }
2536
2537   SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
2538
2539   return;
2540 }
2541
2542 int ui_selected_index ( void ) {
2543
2544   if ( ! ui_selected ) {
2545     return ( -1 ); // no index
2546   }
2547
2548   mm_appref_t *r = g_categories [ ui_category ] -> refs;
2549   int counter = 0;
2550   while ( r ) {
2551     if ( r == ui_selected ) {
2552       return ( counter );
2553     }
2554     r = r -> next;
2555     counter++;
2556   }
2557
2558   return ( -1 );
2559 }
2560
2561 static mm_appref_t *timer_ref = NULL;
2562 void ui_set_selected ( mm_appref_t *r ) {
2563
2564   render_mask |= CHANGED_SELECTION;
2565
2566   // preview pic stuff
2567   //
2568
2569   if ( ! pnd_conf_get_as_int_d ( g_conf, "minimenu.load_previews_later", 0 ) ) {
2570     return; // no desire to defer anything
2571   }
2572
2573   if ( ! r ) {
2574     // cancel timer
2575     SDL_SetTimer ( 0, NULL );
2576     timer_ref = NULL;
2577     return;
2578   }
2579
2580   SDL_SetTimer ( pnd_conf_get_as_int_d ( g_conf, "previewpic.defer_timer_ms", 1000 ), ui_callback_f );
2581   timer_ref = r;
2582
2583   return;
2584 }
2585
2586 unsigned int ui_callback_f ( unsigned int t ) {
2587
2588   if ( ui_selected != timer_ref ) {
2589     return ( 0 ); // user has moved it, who cares
2590   }
2591
2592   SDL_Event e;
2593   bzero ( &e, sizeof(SDL_Event) );
2594   e.type = SDL_USEREVENT;
2595   e.user.code = sdl_user_ticker;
2596   SDL_PushEvent ( &e );
2597
2598   return ( 0 );
2599 }
2600
2601 int ui_modal_single_menu ( char *argv[], unsigned int argc, char *title, char *footer ) {
2602   SDL_Rect rects [ 40 ];
2603   SDL_Rect *dest = rects;
2604   SDL_Rect src;
2605   SDL_Surface *rtext;
2606   unsigned char max_visible = pnd_conf_get_as_int_d ( g_conf, "detailtext.max_visible" , 11 );
2607   unsigned char first_visible = 0;
2608
2609   bzero ( rects, sizeof(SDL_Rect) * 40 );
2610
2611   unsigned int sel = 0;
2612
2613   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 };
2614
2615   unsigned int i;
2616   SDL_Event event;
2617
2618   while ( 1 ) {
2619
2620     // clear
2621     dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
2622     dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
2623     dest -> w = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> w;
2624     dest -> h = ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h;
2625     SDL_FillRect( sdl_realscreen, dest, 0 );
2626
2627     // show dialog background
2628     if ( g_imagecache [ IMG_DETAIL_BG ].i ) {
2629       src.x = 0;
2630       src.y = 0;
2631       src.w = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> w;
2632       src.h = ((SDL_Surface*)(g_imagecache [ IMG_DETAIL_BG ].i)) -> h;
2633       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
2634       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
2635       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
2636       // repeat for darken?
2637       //SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
2638       //SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_BG ].i, &src, sdl_realscreen, dest );
2639       //SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2640       dest++;
2641     }
2642
2643     // show dialog frame
2644     if ( g_imagecache [ IMG_DETAIL_PANEL ].i ) {
2645       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 );
2646       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 );
2647       SDL_BlitSurface ( g_imagecache [ IMG_DETAIL_PANEL ].i, NULL /* whole image */, sdl_realscreen, dest );
2648       //SDL_UpdateRects ( sdl_realscreen, 1, &dest );
2649       dest++;
2650     }
2651
2652     // show header
2653     if ( title ) {
2654       rtext = TTF_RenderText_Blended ( g_tab_font, title, ui_display_context.fontcolor );
2655       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
2656       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 20;
2657       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2658       SDL_FreeSurface ( rtext );
2659       dest++;
2660     }
2661
2662     // show footer
2663     if ( footer ) {
2664       rtext = TTF_RenderText_Blended ( g_tab_font, footer, ui_display_context.fontcolor );
2665       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
2666       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) +
2667         ((SDL_Surface*) g_imagecache [ IMG_DETAIL_PANEL ].i) -> h
2668         - 60;
2669       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2670       SDL_FreeSurface ( rtext );
2671       dest++;
2672     }
2673
2674     // show options
2675     for ( i = first_visible; i < first_visible + max_visible && i < argc; i++ ) {
2676
2677       // show options
2678       if ( sel == i ) {
2679         rtext = TTF_RenderText_Blended ( g_tab_font, argv [ i ], selfontcolor );
2680       } else {
2681         rtext = TTF_RenderText_Blended ( g_tab_font, argv [ i ], ui_display_context.fontcolor );
2682       }
2683       dest -> x = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_x", 460 ) + 20;
2684       dest -> y = pnd_conf_get_as_int_d ( g_conf, "detailpane.pane_offset_y", 60 ) + 40 + ( 20 * ( i + 1 - first_visible ) );
2685       SDL_BlitSurface ( rtext, NULL /* full src */, sdl_realscreen, dest );
2686       SDL_FreeSurface ( rtext );
2687       dest++;
2688
2689     } // for
2690
2691     // update all the rects and send it all to sdl
2692     SDL_UpdateRects ( sdl_realscreen, dest - rects, rects );
2693     dest = rects;
2694
2695     // check for input
2696     while ( SDL_WaitEvent ( &event ) ) {
2697
2698       switch ( event.type ) {
2699
2700       //case SDL_KEYUP:
2701       case SDL_KEYDOWN:
2702
2703         if ( event.key.keysym.sym == SDLK_UP ) {
2704           if ( sel ) {
2705             sel--;
2706
2707             if ( sel < first_visible ) {
2708               first_visible--;
2709             }
2710
2711           }
2712         } else if ( event.key.keysym.sym == SDLK_DOWN ) {
2713
2714           if ( sel < argc - 1 ) {
2715             sel++;
2716
2717             // ensure visibility
2718             if ( sel >= first_visible + max_visible ) {
2719               first_visible++;
2720             }
2721
2722           }
2723
2724         } else if ( event.key.keysym.sym == SDLK_RETURN || event.key.keysym.sym == SDLK_END ) { // return, or "B"
2725           return ( sel );
2726
2727 #if 0
2728         } else if ( event.key.keysym.sym == SDLK_q ) {
2729           exit ( 0 );
2730 #endif
2731
2732         } else {
2733           return ( -1 ); // nada
2734         }
2735
2736         break;
2737
2738       } // switch
2739
2740       break;
2741     } // while
2742
2743   } // while
2744
2745   return ( -1 );
2746 }
2747
2748 unsigned char ui_determine_row ( mm_appref_t *a ) {
2749   unsigned int row = 0;
2750
2751   mm_appref_t *i = g_categories [ ui_category ] -> refs;
2752   while ( i != a ) {
2753     i = i -> next;
2754     row++;
2755   } // while
2756   row /= ui_display_context.col_max;
2757
2758   return ( row );
2759 }
2760
2761 unsigned char ui_determine_screen_row ( mm_appref_t *a ) {
2762   return ( ui_determine_row ( a ) % ui_display_context.row_max );
2763 }
2764
2765 unsigned char ui_determine_screen_col ( mm_appref_t *a ) {
2766   unsigned int col = 0;
2767
2768   mm_appref_t *i = g_categories [ ui_category ] -> refs;
2769   while ( i != a ) {
2770     i = i -> next;
2771     col++;
2772   } // while
2773   col %= ui_display_context.col_max;
2774
2775   return ( col );
2776 }
2777
2778 unsigned char ui_show_info ( char *pndrun, pnd_disco_t *p ) {
2779   char *viewer, *searchpath;
2780   pnd_conf_handle desktoph;
2781
2782   // viewer
2783   searchpath = pnd_conf_query_searchpath();
2784
2785   desktoph = pnd_conf_fetch_by_id ( pnd_conf_desktop, searchpath );
2786
2787   if ( ! desktoph ) {
2788     return ( 0 );
2789   }
2790
2791   viewer = pnd_conf_get_as_char ( desktoph, "info.viewer" );
2792
2793   if ( ! viewer ) {
2794     return ( 0 ); // no way to view the file
2795   }
2796
2797   // etc
2798   if ( ! p -> unique_id ) {
2799     return ( 0 );
2800   }
2801
2802   if ( ! p -> info_filename ) {
2803     return ( 0 );
2804   }
2805
2806   if ( ! p -> info_name ) {
2807     return ( 0 );
2808   }
2809
2810   if ( ! pndrun ) {
2811     return ( 0 );
2812   }
2813
2814   // exec line
2815   char args [ 1001 ];
2816   char *pargs = args;
2817   if ( pnd_conf_get_as_char ( desktoph, "info.viewer_args" ) ) {
2818     snprintf ( pargs, 1001, "%s %s",
2819                pnd_conf_get_as_char ( desktoph, "info.viewer_args" ), p -> info_filename );
2820   } else {
2821     pargs = NULL;
2822   }
2823
2824   char pndfile [ 1024 ];
2825   if ( p -> object_type == pnd_object_type_directory ) {
2826     // for PXML-app-dir, pnd_run.sh doesn't want the PXML.xml.. it just wants the dir-name
2827     strncpy ( pndfile, p -> object_path, 1000 );
2828   } else if ( p -> object_type == pnd_object_type_pnd ) {
2829     // pnd_run.sh wants the full path and filename for the .pnd file
2830     snprintf ( pndfile, 1020, "%s/%s", p -> object_path, p -> object_filename );
2831   }
2832
2833   if ( ! pnd_apps_exec ( pndrun, pndfile, p -> unique_id, viewer, p -> startdir, pargs,
2834                          p -> clockspeed ? atoi ( p -> clockspeed ) : 0, PND_EXEC_OPTION_NORUN ) )
2835   {
2836     return ( 0 );
2837   }
2838
2839   pnd_log ( pndn_debug, "Info Exec=%s\n", pnd_apps_exec_runline() );
2840
2841   // try running it
2842   int x;
2843   if ( ( x = fork() ) < 0 ) {
2844     pnd_log ( pndn_error, "ERROR: Couldn't fork()\n" );
2845     return ( 0 );
2846   }
2847
2848   if ( x == 0 ) {
2849     execl ( "/bin/sh", "/bin/sh", "-c", pnd_apps_exec_runline(), (char*)NULL );
2850     pnd_log ( pndn_error, "ERROR: Couldn't exec(%s)\n", pnd_apps_exec_runline() );
2851     return ( 0 );
2852   }
2853
2854   return ( 1 );
2855 }
2856
2857 typedef struct {
2858   SDL_Rect r;
2859   int catnum;
2860   mm_appref_t *ref;
2861 } ui_touch_t;
2862 #define MAXTOUCH 100
2863 ui_touch_t ui_touchrects [ MAXTOUCH ];
2864 unsigned char ui_touchrect_count = 0;
2865
2866 void ui_register_reset ( void ) {
2867   bzero ( ui_touchrects, sizeof(ui_touch_t)*MAXTOUCH );
2868   ui_touchrect_count = 0;
2869   return;
2870 }
2871
2872 void ui_register_tab ( unsigned char catnum, unsigned int x, unsigned int y, unsigned int w, unsigned int h ) {
2873
2874   if ( ui_touchrect_count == MAXTOUCH ) {
2875     return;
2876   }
2877
2878   ui_touchrects [ ui_touchrect_count ].r.x = x;
2879   ui_touchrects [ ui_touchrect_count ].r.y = y;
2880   ui_touchrects [ ui_touchrect_count ].r.w = w;
2881   ui_touchrects [ ui_touchrect_count ].r.h = h;
2882   ui_touchrects [ ui_touchrect_count ].catnum = catnum;
2883   ui_touchrect_count++;
2884
2885   return;
2886 }
2887
2888 void ui_register_app ( mm_appref_t *app, unsigned int x, unsigned int y, unsigned int w, unsigned int h ) {
2889
2890   if ( ui_touchrect_count == MAXTOUCH ) {
2891     return;
2892   }
2893
2894   ui_touchrects [ ui_touchrect_count ].r.x = x;
2895   ui_touchrects [ ui_touchrect_count ].r.y = y;
2896   ui_touchrects [ ui_touchrect_count ].r.w = w;
2897   ui_touchrects [ ui_touchrect_count ].r.h = h;
2898   ui_touchrects [ ui_touchrect_count ].ref = app;
2899   ui_touchrect_count++;
2900
2901   return;
2902 }
2903
2904 void ui_touch_act ( unsigned int x, unsigned int y ) {
2905
2906   unsigned char i;
2907   ui_touch_t *t;
2908
2909   for ( i = 0; i < ui_touchrect_count; i++ ) {
2910     t = &(ui_touchrects [ i ]);
2911
2912     if ( x >= t -> r.x &&
2913          x <= t -> r.x + t -> r.w &&
2914          y >= t -> r.y &&
2915          y <= t -> r.y + t -> r.h
2916        )
2917     {
2918
2919       if ( t -> ref ) {
2920         ui_selected = t -> ref;
2921         ui_push_exec();
2922       } else {
2923         if ( ui_category != t -> catnum ) {
2924           ui_selected = NULL;
2925         }
2926         ui_category = t -> catnum;
2927         render_mask |= CHANGED_CATEGORY;
2928         // rescan the dir
2929         category_fs_restock ( g_categories [ ui_category ] );
2930         ui_start_defered_icon_thread();
2931       }
2932
2933       break;
2934     }
2935
2936   } // for
2937
2938   return;
2939 }
2940
2941 unsigned char ui_forkexec ( char *argv[] ) {
2942   char *fooby = argv[0];
2943   int x;
2944
2945   if ( ( x = fork() ) < 0 ) {
2946     pnd_log ( pndn_error, "ERROR: Couldn't fork() for '%s'\n", fooby );
2947     return ( 0 );
2948   }
2949
2950   if ( x == 0 ) { // child
2951     execv ( fooby, argv );
2952     pnd_log ( pndn_error, "ERROR: Couldn't exec(%s)\n", fooby );
2953     return ( 0 );
2954   }
2955
2956   // parent, success
2957   return ( 1 );
2958 }
2959
2960 unsigned char ui_threaded_timer_create ( void ) {
2961
2962   g_timer_thread = SDL_CreateThread ( (void*)ui_threaded_timer, NULL );
2963
2964   if ( ! g_timer_thread ) {
2965     pnd_log ( pndn_error, "ERROR: Couldn't create timer thread\n" );
2966     return ( 0 );
2967   }
2968
2969   return ( 1 );
2970 }
2971
2972 int ui_threaded_timer ( pnd_disco_t *p ) {
2973
2974   // this timer's job is to ..
2975   // - do nothing for quite awhile
2976   // - on wake, post event to SDL event queue, so that main thread will check if SD insert/eject occurred
2977   // - goto 10
2978
2979   unsigned int delay_s = 2; // seconds
2980
2981   while ( 1 ) {
2982
2983     // pause...
2984     //sleep ( delay_s );
2985     SDL_Delay ( delay_s * 1000 );
2986
2987     // .. trigger SD check
2988     SDL_Event e;
2989     bzero ( &e, sizeof(SDL_Event) );
2990     e.type = SDL_USEREVENT;
2991     e.user.code = sdl_user_checksd;
2992     SDL_PushEvent ( &e );
2993
2994   } // while
2995
2996   return ( 0 );
2997 }
2998
2999 unsigned char ui_threaded_defered_preview ( pnd_disco_t *p ) {
3000
3001   if ( ! cache_preview ( p, pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 200 ),
3002                          pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 180 ) )
3003      )
3004   {
3005     pnd_log ( pndn_debug, "THREAD: Couldn't load preview pic: '%s' -> '%s'\n",
3006               IFNULL(p->title_en,"No Name"), p -> preview_pic1 );
3007   }
3008
3009   // trigger that we completed
3010   SDL_Event e;
3011   bzero ( &e, sizeof(SDL_Event) );
3012   e.type = SDL_USEREVENT;
3013   e.user.code = sdl_user_finishedpreview;
3014   e.user.data1 = p;
3015   SDL_PushEvent ( &e );
3016
3017   return ( 0 );
3018 }
3019
3020 void ui_post_scan ( void ) {
3021
3022   // reset view
3023   ui_selected = NULL;
3024   ui_rows_scrolled_down = 0;
3025   // set back to first tab, to be safe
3026   ui_category = 0;
3027   ui_catshift = 0;
3028
3029   // do we have a preferred category to jump to? or a last known one?
3030   char *dc = pnd_conf_get_as_char ( g_conf, "categories.default_cat" );
3031   char *lastcat = pnd_conf_get_as_char ( g_conf, "minimenu.last_known_catname" );
3032   if ( ( dc ) ||
3033        ( pnd_conf_get_as_int_d ( g_conf, "minimenu.start_selected", 0 ) && lastcat ) )
3034   {
3035     char *catpick = NULL;
3036
3037     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.start_selected", 0 ) && lastcat ) {
3038       catpick = lastcat;
3039
3040       // if this is a subcat, we have some doctoring to do :/ the hackishness is really
3041       // starting to show..
3042       if ( pnd_conf_get_as_char ( g_conf, "minimenu.last_known_parentcatname" ) ) {
3043         // in subcat view, we only have one cat
3044         ui_category = 0;
3045         ui_catshift = 0;
3046         // the cat name to search for is Child*Parent
3047         char key [ 512 ];
3048         sprintf ( key, "%s*%s",
3049                   pnd_conf_get_as_char ( g_conf, "minimenu.last_known_catname" )
3050                   , pnd_conf_get_as_char ( g_conf, "minimenu.last_known_parentcatname" ) );
3051         category_publish ( CFBYNAME, key );
3052         // since we forced it by hand, no need to do a cat-scan below
3053         catpick = NULL;
3054       }
3055
3056     } else if ( dc ) {
3057       catpick = dc;
3058     }
3059
3060     // attempt to find default cat; if we do find it, select it; otherwise
3061     // default behaviour will pick first cat (ie: usually All)
3062     if ( catpick ) {
3063       unsigned int i;
3064
3065       for ( i = 0; i < g_categorycount; i++ ) {
3066         if ( strcasecmp ( g_categories [ i ] -> catname, catpick ) == 0 ) {
3067           ui_category = i;
3068           // ensure visibility
3069           unsigned int screen_width = ui_display_context.screen_width;
3070           unsigned int tab_width = pnd_conf_get_as_int ( g_conf, "tabs.tab_width" );
3071           if ( ui_category > ui_catshift + ( screen_width / tab_width ) - 1 ) {
3072             ui_catshift = ui_category - ( screen_width / tab_width ) + 1;
3073           }
3074           break;
3075         }
3076       }
3077
3078       if ( i == g_categorycount ) {
3079         pnd_log ( pndn_warning, "  User defined default category or last known cat '%s' but not found, so using default behaviour\n", catpick );
3080       }
3081
3082     } // cat change?
3083
3084   } // default cat
3085
3086   // if we're sent right to a dirbrowser tab, restock it now (normally we restock on entry)
3087   if ( g_categories [ ui_category ] && g_categories [ ui_category ] -> fspath ) {
3088     printf ( "Restock on start: '%s'\n", g_categories [ ui_category ] -> fspath );
3089     category_fs_restock ( g_categories [ ui_category ] );
3090   }
3091
3092   // redraw all
3093   render_mask |= CHANGED_EVERYTHING;
3094
3095   // if deferred icon load, kick off the thread now
3096   if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_icons_later", 0 ) == 1 ) {
3097     ui_start_defered_icon_thread();
3098   } // deferred icon load
3099
3100   return;
3101 }
3102
3103 unsigned char ui_threaded_defered_icon ( void *p ) {
3104   extern pnd_box_handle g_active_apps;
3105
3106   unsigned char maxwidth, maxheight;
3107   maxwidth = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_width", 50 );
3108   maxheight = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_height", 50 );
3109
3110   pnd_disco_t *iter;
3111
3112   g_icon_thread_busy = 1;
3113
3114   // work at it in order within current category
3115
3116   mm_appref_t *refiter = g_categories [ ui_category ] ? g_categories [ ui_category ] -> refs : NULL;
3117   while ( refiter && ! g_icon_thread_stop ) {
3118     iter = refiter -> ref;
3119
3120     // has an icon that is not already cached?
3121     if ( ( iter -> pnd_icon_pos ) ||
3122          ( iter -> icon && iter -> object_flags & PND_DISCO_LIBPND_DD )
3123        )
3124     {
3125   
3126       // try to cache it?
3127       if ( ! cache_icon ( iter, maxwidth, maxheight ) ) {
3128         //pnd_log ( pndn_warning, "  Couldn't load icon: '%s'\n", IFNULL(iter->title_en,"No Name") );
3129
3130       } else {
3131
3132         // trigger that we completed
3133         SDL_Event e;
3134         bzero ( &e, sizeof(SDL_Event) );
3135         e.type = SDL_USEREVENT;
3136         e.user.code = sdl_user_finishedicon;
3137         SDL_PushEvent ( &e );
3138
3139         //pnd_log ( pndn_warning, "  Finished deferred load icon: '%s'\n", IFNULL(iter->title_en,"No Name") );
3140         //usleep ( pnd_conf_get_as_int_d ( g_conf, "minimenu.defer_icon_us", 50000 ) );
3141
3142       }
3143
3144       // avoid churn
3145       iter -> pnd_icon_pos = 0;
3146       if ( iter -> icon ) {
3147         free ( iter -> icon );
3148         iter -> icon = NULL;
3149       }
3150
3151       // let user do something..
3152       SDL_Delay ( 200 );
3153
3154     } // has icon
3155
3156     refiter = refiter -> next;
3157   }
3158
3159   // mark as done
3160   g_icon_thread_busy = 0;
3161
3162   return ( 0 );
3163 }
3164
3165 void ui_show_hourglass ( unsigned char updaterect ) {
3166
3167   SDL_Rect dest;
3168   SDL_Surface *s = g_imagecache [ IMG_HOURGLASS ].i;
3169
3170   dest.x = ( 800 - s -> w ) / 2;
3171   dest.y = ( 480 - s -> h ) / 2;
3172
3173   SDL_BlitSurface ( s, NULL /* whole image */, sdl_realscreen, &dest );
3174
3175   if ( updaterect ) {
3176     SDL_UpdateRects ( sdl_realscreen, 1, &dest );
3177   }
3178
3179   return;
3180 }
3181
3182 unsigned char ui_pick_skin ( void ) {
3183 #define MAXSKINS 10
3184   char *skins [ MAXSKINS ];
3185   unsigned char iter;
3186
3187   char *searchpath = pnd_conf_get_as_char ( g_conf, "minimenu.skin_searchpath" );
3188   char tempname [ 100 ];
3189
3190   iter = 0;
3191
3192   skins [ iter++ ] = "No skin change";
3193
3194   SEARCHPATH_PRE
3195   {
3196     DIR *d = opendir ( buffer );
3197
3198     if ( d ) {
3199       struct dirent *dd;
3200
3201       while ( ( dd = readdir ( d ) ) ) {
3202
3203         if ( dd -> d_name [ 0 ] == '.' ) {
3204           // ignore
3205         } else if ( ( dd -> d_type == DT_DIR || dd -> d_type == DT_UNKNOWN ) &&
3206                     iter < MAXSKINS )
3207         {
3208           snprintf ( tempname, 100, "Skin: %s", dd -> d_name );
3209           skins [ iter++ ] = strdup ( tempname );
3210         }
3211
3212       }
3213
3214       closedir ( d );
3215     }
3216
3217   }
3218   SEARCHPATH_POST
3219
3220   int sel = ui_modal_single_menu ( skins, iter, "Skins", "Enter to select; other to return." );
3221
3222   // did they pick one?
3223   if ( sel > 0 ) {
3224     FILE *f;
3225
3226     char *s = strdup ( pnd_conf_get_as_char ( g_conf, "minimenu.skin_selected" ) );
3227     s = pnd_expand_tilde ( s );
3228
3229     f = fopen ( s, "w" );
3230
3231     free ( s );
3232
3233     if ( f ) {
3234       fprintf ( f, "%s\n", skins [ sel ] + 6 );
3235       fclose ( f );
3236     }
3237
3238     return ( 1 );
3239   }
3240
3241   return ( 0 );
3242 }
3243
3244 void ui_aboutscreen ( char *textpath ) {
3245 #define PIXELW 7
3246 #define PIXELH 7
3247 #define MARGINW 3
3248 #define MARGINH 3
3249 #define SCRW 800
3250 #define SCRH 480
3251 #define ROWS SCRH / ( PIXELH + MARGINH )
3252 #define COLS SCRW / ( PIXELW + MARGINW )
3253
3254   unsigned char pixelboard [ ROWS * COLS ]; // pixel heat
3255   bzero ( pixelboard, ROWS * COLS );
3256
3257   SDL_Surface *rtext;
3258   SDL_Rect r;
3259
3260   SDL_Color rtextc = { 200, 200, 200, 100 };
3261
3262   // pixel scroller
3263   char *textloop [ 500 ];
3264   unsigned int textmax = 0;
3265   bzero ( textloop, 500 * sizeof(char*) );
3266
3267   // cursor scroller
3268   char cbuffer [ 50000 ];
3269   bzero ( cbuffer, 50000 );
3270   unsigned int crevealed = 0;
3271
3272   FILE *f = fopen ( textpath, "r" );
3273
3274   if ( ! f ) {
3275     pnd_log ( pndn_error, "ERROR: Couldn't open about text: %s\n", textpath );
3276     return;
3277   }
3278
3279   char textbuf [ 100 ];
3280   while ( fgets ( textbuf, 100, f ) ) {
3281
3282     // add to full buffer
3283     strncat ( cbuffer, textbuf, 50000 );
3284
3285     // chomp
3286     if ( strchr ( textbuf, '\n' ) ) {
3287       * strchr ( textbuf, '\n' ) = '\0';
3288     }
3289
3290     // add to pixel loop
3291     if ( 1||textbuf [ 0 ] ) {
3292       textloop [ textmax ] = strdup ( textbuf );
3293       textmax++;
3294     }
3295
3296   } // while fgets
3297
3298   fclose ( f );
3299
3300   unsigned int textiter = 0;
3301   while ( textiter < textmax ) {
3302     char *text = textloop [ textiter ];
3303
3304     rtext = NULL;
3305     if ( text [ 0 ] ) {
3306       // render to surface
3307       rtext = TTF_RenderText_Blended ( g_grid_font, text, rtextc );
3308
3309       // render font to pixelboard
3310       unsigned int px, py;
3311       unsigned char *ph;
3312       unsigned int *pixels = rtext -> pixels;
3313       unsigned char cr, cg, cb, ca;
3314       for ( py = 0; py < rtext -> h; py ++ ) {
3315         for ( px = 0; px < ( rtext -> w > COLS ? COLS : rtext -> w ); px++ ) {
3316
3317           SDL_GetRGBA ( pixels [ ( py * rtext -> pitch / 4 ) + px ],
3318                         rtext -> format, &cr, &cg, &cb, &ca );
3319
3320           if ( ca != 0 ) {
3321
3322             ph = pixelboard + ( /*y offset */ 30 * COLS ) + ( py * COLS ) + px /* / 2 */;
3323
3324             if ( *ph < 100 ) {
3325               *ph = 100;
3326             }
3327
3328             ca /= 5;
3329             if ( *ph + ca < 250 ) {
3330               *ph += ca;
3331             }
3332
3333           } // got a pixel?
3334
3335         } // x
3336       } // y
3337
3338     } // got text?
3339
3340     unsigned int runcount = 10;
3341     while ( runcount-- ) {
3342
3343       // clear display
3344       SDL_FillRect( sdl_realscreen, NULL /* whole */, 0 );
3345
3346       // render pixelboard
3347       unsigned int x, y;
3348       unsigned int c;
3349       for ( y = 0; y < ROWS; y++ ) {
3350         for ( x = 0; x < COLS; x++ ) {
3351
3352           if ( 1||pixelboard [ ( y * COLS ) + x ] ) {
3353
3354             // position
3355             r.x = x * ( PIXELW + MARGINW );
3356             r.y = y * ( PIXELH + MARGINH );
3357             r.w = PIXELW;
3358             r.h = PIXELH;
3359             // heat -> colour
3360             c = SDL_MapRGB ( sdl_realscreen -> format, 100 /* r */, 0 /* g */, pixelboard [ ( y * COLS ) + x ] );
3361             // render
3362             SDL_FillRect( sdl_realscreen, &r /* whole */, c );
3363
3364           }
3365
3366         } // x
3367       } // y
3368
3369       // cool pixels
3370       unsigned char *pc = pixelboard;
3371       for ( y = 0; y < ROWS; y++ ) {
3372         for ( x = 0; x < COLS; x++ ) {
3373
3374           if ( *pc > 10 ) {
3375             (*pc) -= 3;
3376           }
3377
3378           pc++;
3379         } // x
3380       } // y
3381
3382       // slide pixels upwards
3383       memmove ( pixelboard, pixelboard + COLS, ( COLS * ROWS ) - COLS );
3384
3385       // render actual readable text
3386       {
3387
3388         // display up to cursor
3389         SDL_Rect dest;
3390         unsigned int cdraw = 0;
3391         SDL_Surface *cs;
3392         char ctb [ 2 ];
3393
3394         if ( crevealed > 200 ) {
3395           cdraw = crevealed - 200;
3396         }
3397
3398         dest.x = 400;
3399         dest.y = 20;
3400
3401         for ( ; cdraw < crevealed; cdraw++ ) {
3402           ctb [ 0 ] = cbuffer [ cdraw ];
3403           ctb [ 1 ] = '\0';
3404           // move over or down
3405           if ( cbuffer [ cdraw ] == '\n' ) {
3406             // EOL
3407             dest.x = 400;
3408             dest.y += 14;
3409
3410             if ( dest.y > 450 ) {
3411               dest.y = 450;
3412             }
3413
3414           } else {
3415             // draw the char
3416             cs = TTF_RenderText_Blended ( g_tab_font, ctb, rtextc );
3417             if ( cs ) {
3418               SDL_BlitSurface ( cs, NULL /* all */, sdl_realscreen, &dest );
3419               SDL_FreeSurface ( cs );
3420               // over
3421               dest.x += cs -> w;
3422             }
3423           }
3424
3425         }
3426
3427         dest.w = 10;
3428         dest.h = 20;
3429         SDL_FillRect ( sdl_realscreen, &dest /* whole */, 220 );
3430
3431         // increment cursor to next character
3432         if ( cbuffer [ crevealed ] != '\0' ) {
3433           crevealed++;
3434         }
3435
3436       } // draw cursor text
3437