3 * aka "2wm" - too weak menu, two week menu, akin to twm
5 * Craig wants a super minimal menu ASAP before launch, so lets see what I can put together in 2 weeks with not much
6 * free time ;) I'd like to do a fuller ('tiny', but with plugin support and a decent expansion and customizing design..)
11 /* mmenu - This is the actual menu
12 * The goal of this app is to show a application picker screen of some sort, allow the user to perform some useful
13 * activities (such as set clock speed, say), and request an app to run, or shutdown, etc.
14 * To keep the memory footprint down, when invoking an application, the menu _exits_, and simply spits out
15 * an operation for mmwrapper to perform. In the case of no wrapper, the menu will just exit, which is handy for
20 * 1) determine app list (via pnd scan, .desktop scan, whatever voodoo)
21 * 2) show a menu, allow user to interact:
22 * a) user picks an application to run, or -> exit, pass shell run line to wrapper
23 * b) user requests menu shutdown -> exit, tell wrapper to exit as well
24 * c) user performsn some operation (set clock, copy files, whatever) -> probably stays within the menu
27 #include <stdio.h> /* for FILE etc */
28 #include <stdlib.h> /* for malloc */
29 #include <unistd.h> /* for unlink */
30 #include <limits.h> /* for PATH_MAX */
31 #include <sys/types.h>
33 #define __USE_GNU /* for strcasestr */
34 #include <string.h> /* for making ftw.h happy */
39 #include <signal.h> // for sigaction
42 #include "pnd_logger.h"
44 #include "pnd_utility.h"
46 #include "pnd_container.h"
47 #include "pnd_discovery.h"
48 #include "pnd_locate.h"
49 #include "pnd_device.h"
50 #include "pnd_pndfiles.h"
51 #include "../lib/pnd_pathiter.h"
52 #include "pnd_notify.h"
53 #include "pnd_dbusnotify.h"
55 #include "pnd_desktop.h"
58 #include "mmwrapcmd.h"
65 #define PNDLOCKNAME "pndnotifyd-disco.lock" /* from pndnotifyd */
67 pnd_box_handle g_active_apps = NULL;
68 unsigned int g_active_appcount = 0;
69 char g_username [ 128 ]; // since we have to wait for login (!!), store username here
70 pnd_conf_handle g_conf = 0;
71 pnd_conf_handle g_desktopconf = 0;
73 char *pnd_run_script = NULL;
74 unsigned char g_x11_present = 1; // >0 if X is present
75 unsigned char g_catmap = 0; // if 1, we're doing category mapping
76 unsigned char g_pvwcache = 0; // if 1, we're trying to do preview caching
77 unsigned char g_autorescan = 1; // default to auto rescan
79 pnd_dbusnotify_handle dbh = 0; // if >0, dbusnotify is active
80 pnd_notify_handle nh = 0; // if >0, inotify is active
82 char g_skin_selected [ 100 ] = "default";
83 char *g_skinpath = NULL; // where 'skin_selected' is located .. the fullpath including skin-dir-name
84 pnd_conf_handle g_skinconf = NULL;
86 void sigquit_handler ( int n );
87 unsigned char app_is_visible ( pnd_conf_handle h, char *uniqueid );
89 int main ( int argc, char *argv[] ) {
90 int logall = -1; // -1 means normal logging rules; >=0 means log all!
93 // boilerplate stuff from pndnotifyd and pndevmapperd
95 /* iterate across args
97 for ( i = 1; i < argc; i++ ) {
99 if ( argv [ i ][ 0 ] == '-' && argv [ i ][ 1 ] == 'l' ) {
101 if ( isdigit ( argv [ i ][ 2 ] ) ) {
102 unsigned char x = atoi ( argv [ i ] + 2 );
113 //printf ( "Unknown: %s\n", argv [ i ] );
114 printf ( "%s [-l##]\n", argv [ 0 ] );
115 printf ( "-l#\tLog-it; -l is 0-and-up (or all), and -l2 means 2-and-up (not all); l[0-3] for now. Log goes to /tmp/mmenu.log\n" );
116 printf ( "-f\tFull path of frontend to run\n" );
124 pnd_log_set_pretext ( "mmenu" );
125 pnd_log_set_flush ( 1 );
127 if ( logall == -1 ) {
128 // standard logging; non-daemon versus daemon
130 #if 1 // HACK: set debug level to high on desktop, but not on pandora; just a convenience while devving, until the conf file is read
132 if ( stat ( PND_DEVICE_BATTERY_GAUGE_PERC, &statbuf ) == 0 ) {
134 pnd_log_set_filter ( pndn_error );
136 pnd_log_set_filter ( pndn_debug );
145 f = fopen ( "/tmp/mmenu.log", "w" );
148 pnd_log_set_filter ( logall );
149 pnd_log_to_stream ( f );
150 pnd_log ( pndn_rem, "logall mode - logging to /tmp/mmenu.log\n" );
153 if ( logall == pndn_debug ) {
154 pnd_log_set_buried_logging ( 1 ); // log the shit out of it
155 pnd_log ( pndn_rem, "logall mode 0 - turned on buried logging\n" );
160 pnd_log ( pndn_rem, "%s built %s %s", argv [ 0 ], __DATE__, __TIME__ );
162 pnd_log ( pndn_rem, "log level starting as %u", pnd_log_get_filter() );
164 // wait for a user to be logged in - we should probably get hupped when a user logs in, so we can handle
165 // log-out and back in again, with SDs popping in and out between..
166 pnd_log ( pndn_rem, "Checking to see if a user is logged in\n" );
168 if ( pnd_check_login ( g_username, 127 ) ) {
171 pnd_log ( pndn_debug, " No one logged in yet .. spinning.\n" );
174 pnd_log ( pndn_rem, "Looks like user '%s' is in, continue.\n", g_username );
180 g_conf = pnd_conf_fetch_by_name ( MMENU_CONF, MMENU_CONF_SEARCHPATH );
183 pnd_log ( pndn_error, "ERROR: Couldn't fetch conf file '%s'!\n", MMENU_CONF );
184 emit_and_quit ( MM_QUIT );
187 // override mmenu conf via user preference conf
188 // first check /tmp location in case we're storing this-session prefs; if not
189 // found, go back to normal NAND copy in homedir
191 if ( stat ( CONF_PREF_TEMPPATH, &statbuf ) == 0 ) {
192 conf_merge_into ( CONF_PREF_TEMPPATH, g_conf );
194 conf_merge_into ( conf_determine_location ( g_conf ), g_conf );
196 conf_setup_missing ( g_conf );
198 // desktop conf for app finding preferences
199 g_desktopconf = pnd_conf_fetch_by_id ( pnd_conf_desktop, PND_CONF_SEARCHPATH );
201 if ( ! g_desktopconf ) {
202 pnd_log ( pndn_error, "ERROR: Couldn't fetch desktop conf file\n" );
203 emit_and_quit ( MM_QUIT );
206 /* set up quit signal handler
211 struct sigaction siggy;
212 siggy.sa_handler = sigquit_handler;
213 siggy.sa_mask = ss; /* implicitly blocks the origin signal */
214 siggy.sa_flags = SA_RESTART; /* don't need anything */
215 sigaction ( SIGQUIT, &siggy, NULL );
217 /* category conf file
220 char *locater = pnd_locate_filename ( pnd_conf_get_as_char ( g_conf, "categories.catmap_searchpath" ),
221 pnd_conf_get_as_char ( g_conf, "categories.catmap_confname" ) );
224 pnd_log ( pndn_rem, "Found category conf at '%s'\n", locater );
225 pnd_conf_handle h = pnd_conf_fetch_by_path ( locater );
227 // lets just merge the skin conf onto the regular conf, so it just magicly works
228 pnd_box_append ( g_conf, h );
231 pnd_log ( pndn_debug, "No additional category conf file found.\n" );
237 pnd_log_set_filter ( pnd_conf_get_as_int_d ( g_conf, "minimenu.loglevel", pndn_error ) );
243 if ( pnd_conf_get_as_char ( g_conf, "minimenu.x11_present_sh" ) ) {
244 FILE *fx = popen ( pnd_conf_get_as_char ( g_conf, "minimenu.x11_present_sh" ), "r" );
247 if ( fgets ( buffer, 100, fx ) ) {
248 if ( atoi ( buffer ) ) {
250 pnd_log ( pndn_rem, "X11 seems to be present [pid %u]\n", atoi(buffer) );
253 pnd_log ( pndn_rem, "X11 seems NOT to be present\n" );
257 pnd_log ( pndn_rem, "X11 seems NOT to be present\n" );
264 pnd_run_script = pnd_locate_filename ( pnd_conf_get_as_char ( g_conf, "minimenu.pndrun" ), "pnd_run.sh" );
266 if ( ! pnd_run_script ) {
267 pnd_log ( pndn_error, "ERROR: Couldn't locate pnd_run.sh!\n" );
268 emit_and_quit ( MM_QUIT );
271 pnd_run_script = strdup ( pnd_run_script ); // so we don't lose it next pnd_locate
273 pnd_log ( pndn_rem, "Found pnd_run.sh at '%s'\n", pnd_run_script );
276 if ( pnd_conf_get_as_int ( g_conf, "minimenu.auto_rescan" ) != PND_CONF_BADNUM ) {
277 g_autorescan = pnd_conf_get_as_int ( g_conf, "minimenu.auto_rescan" );
279 pnd_log ( pndn_debug, "application rescan is set to: %s\n", g_autorescan ? "auto" : "manual" );
281 // figure out what skin is selected (or default)
283 char *s = strdup ( pnd_conf_get_as_char ( g_conf, "minimenu.skin_selected" ) );
284 s = pnd_expand_tilde ( s );
285 if ( ( f = fopen ( s, "r" ) ) ) {
287 if ( fgets ( buffer, 100, f ) ) {
288 // see if that dir can be located
289 if ( strchr ( buffer, '\n' ) ) {
290 * strchr ( buffer, '\n' ) = '\0';
292 char *found = pnd_locate_filename ( pnd_conf_get_as_char ( g_conf, "minimenu.skin_searchpath" ), buffer );
294 strncpy ( g_skin_selected, buffer, 100 );
295 g_skinpath = strdup ( found );
297 pnd_log ( pndn_warning, "Couldn't locate skin named '%s' so falling back.\n", buffer );
305 pnd_log ( pndn_rem, "Skin is selected: '%s'\n", g_skin_selected );
307 pnd_log ( pndn_rem, "Skin falling back to: '%s'\n", g_skin_selected );
309 char *found = pnd_locate_filename ( pnd_conf_get_as_char ( g_conf, "minimenu.skin_searchpath" ),
312 g_skinpath = strdup ( found );
314 pnd_log ( pndn_error, "Couldn't locate skin named '%s'.\n", g_skin_selected );
315 emit_and_quit ( MM_QUIT );
319 pnd_log ( pndn_rem, "Skin path determined to be: '%s'\n", g_skinpath );
321 // lets see if this skin-path actually has a skin conf
323 char fullpath [ PATH_MAX ];
324 sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "minimenu.skin_confname" ) );
325 g_skinconf = pnd_conf_fetch_by_path ( fullpath );
328 // figure out skin path if we didn't get it already
329 if ( ! g_skinconf ) {
330 pnd_log ( pndn_error, "ERROR: Couldn't set up skin!\n" );
331 emit_and_quit ( MM_QUIT );
334 // lets just merge the skin conf onto the regular conf, so it just magicly works
335 pnd_box_append ( g_conf, g_skinconf );
337 // did user override the splash image?
338 char *splash = pnd_conf_get_as_char ( g_conf, "minimenu.force_wallpaper" );
340 // we've got a filename, presumably; lets see if it exists
342 if ( stat ( splash, &statbuf ) == 0 ) {
343 // file seems to exist, lets set our override to that..
344 pnd_conf_set_char ( g_conf, "graphics.IMG_BACKGROUND_800480", splash );
348 // attempt to set up UI
349 if ( ! ui_setup() ) {
350 pnd_log ( pndn_error, "ERROR: Couldn't set up the UI!\n" );
351 emit_and_quit ( MM_QUIT );
357 // store flag if we're doing preview caching or not
358 if ( pnd_conf_get_as_int_d ( g_conf, "previewpic.do_cache", 0 ) ) {
362 // set up static image cache
363 if ( ! ui_imagecache ( g_skinpath ) ) {
364 pnd_log ( pndn_error, "ERROR: Couldn't set up static UI image cache!\n" );
365 emit_and_quit ( MM_QUIT );
372 if ( pnd_conf_get_as_int_d ( g_conf, "categories.do_all_cat", 1 ) ) {
373 category_push ( g_x11_present ? CATEGORY_ALL " (X11)" : CATEGORY_ALL " (No X11)", NULL /* parent cat */, NULL /*app*/, 0, NULL /* fspath */, 1 /* visible */ );
376 // set up category mappings
377 if ( pnd_conf_get_as_int_d ( g_conf, "categories.map_on", 0 ) ) {
378 g_catmap = category_map_setup();
381 /* inhale applications, icons, categories, etc
387 if ( g_autorescan ) {
389 // set up notifications
390 dbh = pnd_dbusnotify_init();
391 pnd_log ( pndn_debug, "Setting up dbusnotify\n" );
392 //setup_notifications();
394 // create a timer thread, that will trigger us to check for SD insert notifications every once in awhile
395 ui_threaded_timer_create();
399 /* set speed to minimenu run-speed, now that we're all set up
401 #if 0 /* something crashes at high speed image caching.. */
402 int use_mm_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.use_mm_speed", 0 );
403 if ( use_mm_speed > 0 ) {
404 int mm_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.mm_speed", -1 );
405 if ( mm_speed > 50 && mm_speed < 800 ) {
407 snprintf ( buffer, 500, "sudo /usr/pandora/scripts/op_cpuspeed.sh %d", mm_speed );
410 } // do speed change?
414 while ( 1 ) { // forever!
416 // show the menu, or changes thereof
419 // wait for input or time-based events (like animations) and deal with inputs
420 ui_process_input ( dbh, nh );
427 void emit_and_quit ( char *s ) {
428 printf ( "%s\n", s );
429 // shutdown notifications
430 if ( g_autorescan ) {
433 pnd_dbusnotify_shutdown ( dbh );
436 pnd_notify_shutdown ( nh );
444 static unsigned int is_dir_empty ( char *fullpath ) {
445 DIR *d = opendir ( fullpath );
448 return ( 0 ); // not empty, since we don't know
451 struct dirent *de = readdir ( d );
455 if ( strcmp ( de -> d_name, "." ) == 0 ) {
457 } else if ( strcmp ( de -> d_name, ".." ) == 0 ) {
460 // something else came in, so dir must not be empty
470 return ( 1 ); // dir is empty
473 void applications_free ( void ) {
475 // free up all our category apprefs, but keep the preview and icon cache's..
478 // free up old disco_t
479 if ( g_active_apps ) {
480 pnd_disco_t *p = pnd_box_get_head ( g_active_apps );
483 n = pnd_box_get_next ( p );
484 pnd_disco_destroy ( p );
487 pnd_box_delete ( g_active_apps );
493 void applications_scan ( void ) {
495 // has user disabled pnd scanning, by chance?
496 if ( ! pnd_conf_get_as_int_d ( g_conf, "filesystem.do_pnd_disco", 1 ) ) {
497 goto dirbrowser_scan; // skip pnd's
501 ui_discoverscreen ( 1 /* clear screen */ );
503 // determine current app list, cache icons
504 // - ignore overrides for now
507 pnd_box_handle merge_apps = 0;
509 // boy I wish I built a plugin system here
512 // perform application discovery for pnd-files?
514 if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.disco_pnds", 1 ) ) {
517 if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.desktop_apps", 1 ) ) {
518 pnd_log ( pndn_debug, "Looking for pnd applications here: %s\n",
519 pnd_conf_get_as_char ( g_desktopconf, "desktop.searchpath" ) );
520 g_active_apps = pnd_disco_search ( pnd_conf_get_as_char ( g_desktopconf, "desktop.searchpath" ), NULL );
524 if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.menu_apps", 1 ) ) {
525 pnd_log ( pndn_debug, "Looking for pnd applications here: %s\n",
526 pnd_conf_get_as_char ( g_desktopconf, "menu.searchpath" ) );
527 merge_apps = pnd_disco_search ( pnd_conf_get_as_char ( g_desktopconf, "menu.searchpath" ), NULL );
532 if ( g_active_apps ) {
533 // the key from pnd_disco_search() is the _path_, so easy to look for duplicates
534 // this is pretty inefficient, being linked lists; perhaps should switch to hash tables when
535 // we expect thousands of apps.. or at least an index or something.
536 void *a = pnd_box_get_head ( merge_apps );
539 nexta = pnd_box_get_next ( a );
541 // if the key for the node is also found in active apps, toss out the merging one
542 if ( pnd_box_find_by_key ( g_active_apps, pnd_box_get_key ( a ) ) ) {
543 //fprintf ( stderr, "Merging app id '%s' is duplicate; discarding it.\n", pnd_box_get_key ( a ) );
544 pnd_box_delete_node ( merge_apps, a );
550 // got menu apps, and got desktop apps, merge
551 pnd_box_append ( g_active_apps, merge_apps );
553 // got menu apps, had no desktop apps, so just assign
554 g_active_apps = merge_apps;
559 char *aux_apps = NULL;
561 aux_apps = pnd_conf_get_as_char ( g_conf, "minimenu.aux_searchpath" );
562 if ( aux_apps && aux_apps [ 0 ] ) {
563 pnd_log ( pndn_debug, "Looking for pnd applications here: %s\n", aux_apps );
564 merge_apps = pnd_disco_search ( aux_apps, NULL );
569 if ( g_active_apps ) {
571 // LAME: snipped from above; should just catenate the 3 sets of searchpaths into a
572 // master searchpath, possibly removing duplicate paths _then_, and keep all this much
575 // the key from pnd_disco_search() is the _path_, so easy to look for duplicates
576 // this is pretty inefficient, being linked lists; perhaps should switch to hash tables when
577 // we expect thousands of apps.. or at least an index or something.
578 void *a = pnd_box_get_head ( merge_apps );
581 nexta = pnd_box_get_next ( a );
583 // if the key for the node is also found in active apps, toss out the merging one
584 if ( pnd_box_find_by_key ( g_active_apps, pnd_box_get_key ( a ) ) ) {
585 fprintf ( stderr, "Merging app id '%s' is duplicate; discarding it.\n", pnd_box_get_key ( a ) );
586 pnd_box_delete_node ( merge_apps, a );
592 pnd_box_append ( g_active_apps, merge_apps );
594 g_active_apps = merge_apps;
598 } // app discovery on pnd-files?
600 // perform app discovery on .desktop files?
602 if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.disco_dotdesktop", 0 ) ) {
605 pnd_log ( pndn_debug, "Checking pndnotifyd disco lock %s\n", PNDLOCKNAME );
607 // first, check if lock is 'old' -- maybe locker crashed, or if its old enough.. its just good, right?
608 time_t age = pnd_is_locked ( PNDLOCKNAME );
611 pnd_log ( pndn_debug, "Lock is all clear %s so no need to wait\n", PNDLOCKNAME );
613 } else if ( time ( NULL ) - age > pnd_conf_get_as_int_d ( g_conf, "minimenu.disco_lock_maxage_s", 120 ) ) {
614 // lock seems old, so who cares
615 pnd_log ( pndn_debug, "Lock is OLD so ignoring it: %s\n", PNDLOCKNAME );
618 // not too old, so lets wait.. we could be booting up!
620 int rv = pnd_wait_for_unlock ( PNDLOCKNAME,
621 pnd_conf_get_as_int_d ( g_conf, "minimenu.disco_lock_max", 20 ),
622 pnd_conf_get_as_int_d ( g_conf, "minimenu.disco_lock_usec_delta", 500000 ) );
624 pnd_log ( pndn_debug, "Waited for lock and is now clear %s\n", PNDLOCKNAME );
626 pnd_log ( pndn_debug, "Waited for lock and timed out %s .. proceeding anyway.\n", PNDLOCKNAME );
633 pnd_conf_get_as_char ( g_desktopconf, "desktop.dotdesktoppath" ),
634 pnd_conf_get_as_char ( g_desktopconf, "menu.dotdesktoppath" ),
635 pnd_conf_get_as_char ( g_conf, "minimenu.aux_searchpath" ),
636 //"/usr/share/applications",
639 char ddpath [ 1024 ];
640 unsigned int flags = PND_DOTDESKTOP_LIBPND_ONLY;
642 if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.disco_dotdesktop_all", 0 ) ) {
643 flags = 0; // get all
647 if ( ! g_active_apps ) {
648 g_active_apps = pnd_box_new ( "discovery-dotdesktop" );
651 // for each searchpath..
653 for ( i = 0; i < 5; i++ ) {
655 if ( ! chunks [ i ] ) {
659 DIR *d = opendir ( chunks [ i ] );
662 struct dirent *de = readdir ( d );
664 // for each filename found
667 if ( strcmp ( de -> d_name, "." ) == 0 ) {
669 } else if ( strcmp ( de -> d_name, ".." ) == 0 ) {
672 snprintf ( ddpath, 1024, "%s/%s", chunks [ i ], de -> d_name );
673 pnd_disco_t *p = pnd_parse_dotdesktop ( ddpath, flags );
676 pnd_disco_t *ai = pnd_box_allocinsert ( g_active_apps, ddpath, sizeof(pnd_disco_t) );
677 memmove ( ai, p, sizeof(pnd_disco_t) );
691 } // for each searchpath
693 } // app discovery in .desktops
696 g_active_appcount = pnd_box_get_size ( g_active_apps );
698 unsigned char maxwidth, maxheight;
699 maxwidth = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_width", 50 );
700 maxheight = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_height", 50 );
703 ui_cachescreen ( 1 /* clear screen */, NULL );
705 pnd_log ( pndn_debug, "Found pnd applications, and caching icons:\n" );
706 pnd_disco_t *iter = pnd_box_get_head ( g_active_apps );
707 unsigned int itercount = 0;
708 unsigned loadlater = pnd_conf_get_as_int_d ( g_conf, "minimenu.load_icons_later", 0 );
710 //pnd_log ( pndn_debug, " App: '%s'\n", IFNULL(iter->title_en,"No Name") );
714 printf ( "App %s\t%s\t Cat %s:%s:%s %s:%s:%s\n", iter -> title_en, iter -> unique_id,
715 iter -> main_category, iter -> main_category1, iter -> main_category2,
716 iter -> alt_category, iter -> alt_category1, iter -> alt_category2 );
719 // update cachescreen
720 // ... every 10 filenames, just to avoid slowing it too much
721 if ( loadlater == 0 && itercount % 10 == 0 ) {
722 ui_cachescreen ( 0 /* clear screen */, IFNULL(iter->title_en,"No Name") );
725 // if an ovr was flagged by libpnd, lets go inhale it just so we've got the
726 // notes handy, since notes are not handled by libpnd proper
727 pnd_conf_handle ovrh = 0;
728 if ( iter -> object_flags & PND_DISCO_FLAG_OVR ) {
729 char ovrfile [ PATH_MAX ];
731 sprintf ( ovrfile, "%s/%s", iter -> object_path, iter -> object_filename );
732 fixpxml = strcasestr ( ovrfile, PND_PACKAGE_FILEEXT );
733 strcpy ( fixpxml, PXML_SAMEPATH_OVERRIDE_FILEEXT );
735 ovrh = pnd_conf_fetch_by_path ( ovrfile );
739 pnd_log ( pndn_debug, "Found ovr file for %s # %u\n", iter -> object_filename, iter -> subapp_number );
744 // lets also check to see if this ovr is specifying category overrides; if so, we can trust those
745 // more than categories specified by pnd-packager.
748 snprintf ( ovrkey, 40, "Application-%u.maincategory", iter -> subapp_number );
749 if ( pnd_conf_get_as_char ( ovrh, ovrkey ) ) {
750 iter -> object_flags |= PND_DISCO_CUSTOM1;
751 //printf ( "App '%s' has main cat ovr %s\n", iter -> title_en, pnd_conf_get_as_char ( ovrh, ovrkey ) );
754 snprintf ( ovrkey, 40, "Application-%u.maincategorysub1", iter -> subapp_number );
755 if ( pnd_conf_get_as_char ( ovrh, ovrkey ) ) {
756 iter -> object_flags |= PND_DISCO_CUSTOM2;
757 //printf ( "App '%s' has sub cat ovr %s\n", iter -> title_en, pnd_conf_get_as_char ( ovrh, ovrkey ) );
764 // cache the icon, unless deferred
765 if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_icons_later", 0 ) == 0 ) {
767 // if app was from a pnd and has an icon-pos (we've already found where it is in the binary),
768 // OR its a .desktop and we've got a path
769 // THEN go try to cache/load the icon
770 if ( ( iter -> pnd_icon_pos ) ||
771 ( iter -> icon && iter -> object_flags & PND_DISCO_LIBPND_DD )
775 if ( ! cache_icon ( iter, maxwidth, maxheight ) ) {
776 pnd_log ( pndn_warning, " WARNING: Couldn't load icon: '%s'\n", IFNULL(iter->title_en,"No Name") );
783 // cache the preview --> SHOULD DEFER
784 if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_previews_now", 0 ) > 0 ) {
785 // load the preview pics now!
786 if ( iter -> preview_pic1 &&
787 ! cache_preview ( iter, pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_width", 200 ), pnd_conf_get_as_int_d ( g_conf, "previewpic.cell_height", 180 ) ) )
789 pnd_log ( pndn_warning, " Couldn't load preview pic: '%s' -> '%s'\n", IFNULL(iter->title_en,"No Name"), iter -> preview_pic1 );
793 // push the categories .. or suppress application
795 if ( ( pnd_pxml_get_x11 ( iter -> option_no_x11 ) != pnd_pxml_x11_required ) ||
796 ( pnd_pxml_get_x11 ( iter -> option_no_x11 ) == pnd_pxml_x11_required && g_x11_present == 1 )
800 if ( iter -> title_en == NULL || iter -> title_en [ 0 ] == '\0' ) {
801 // null title; just skip it.
804 // push to All category
805 // we do this first, so first category is always All
806 if ( pnd_conf_get_as_int_d ( g_conf, "categories.do_all_cat", 1 ) ) {
807 category_push ( g_x11_present ? CATEGORY_ALL " (X11)" : CATEGORY_ALL " (No X11)", NULL /* parent cat */, iter, ovrh, NULL /* fspath */, 1 /* visible */ );
810 // is this app suppressed? if not, show it in whatever categories the user is allowing
811 if ( iter -> unique_id && app_is_visible ( g_conf, iter -> unique_id ) ) {
814 pnd_log ( pndn_rem, "App %s [%s] cat %s %s %s alt %s %s %s\n",
815 iter -> unique_id, IFNULL(iter->title_en,"n/a"),
816 IFNULL(iter->main_category,"n/a"), IFNULL(iter->main_category1,"n/a"), IFNULL(iter->main_category2,"n/a"),
817 IFNULL(iter->alt_category,"n/a"), IFNULL(iter->alt_category1,"n/a"), IFNULL(iter->alt_category2,"n/a") );
821 category_meta_push ( iter -> main_category, NULL /* no parent cat */, iter, ovrh, cat_is_visible ( g_conf, iter -> main_category ), 1);
822 category_meta_push ( iter -> main_category1, iter -> main_category, iter, ovrh, cat_is_visible ( g_conf, iter -> main_category1 ), 0 );
823 category_meta_push ( iter -> main_category2, iter -> main_category, iter, ovrh, cat_is_visible ( g_conf, iter -> main_category2 ), 0 );
825 category_meta_push ( iter -> alt_category, NULL /* no parent cat */, iter, ovrh, cat_is_visible ( g_conf, iter -> alt_category ), 2 );
826 category_meta_push ( iter -> alt_category1, iter -> alt_category, iter, ovrh, cat_is_visible ( g_conf, iter -> alt_category1 ), 0 );
827 category_meta_push ( iter -> alt_category2, iter -> alt_category, iter, ovrh, cat_is_visible ( g_conf, iter -> alt_category2 ), 0 );
833 } // register with categories or filter out
836 iter = pnd_box_get_next ( iter );
842 // set up filesystem browser tabs
843 if ( pnd_conf_get_as_int_d ( g_conf, "filesystem.do_browser", 0 ) ) {
844 char *searchpath = pnd_conf_get_as_char ( g_conf, "filesystem.tab_searchpaths" );
849 c = strrchr ( buffer, '/' );
850 if ( c && (*(c+1)!='\0') ) {
856 // check if dir is empty; if so, skip it.
857 if ( ! is_dir_empty ( buffer ) ) {
858 category_push ( tabname /* tab name */, NULL /* parent cat */, NULL /* app */, 0 /* override */, buffer /* fspath */, 1 /* visible */ );
864 } // set up fs browser tabs
869 // publish desired categories
870 category_publish ( CFNORMAL, NULL );
872 // let deferred icon cache go now
876 pnd_log ( pndn_debug, "Applications scan done.\n" );
881 static char _vbuf [ 512 ];
882 unsigned char cat_is_visible ( pnd_conf_handle h, char *catname ) {
883 snprintf ( _vbuf, 500, "tabshow.%s", catname );
884 return ( pnd_conf_get_as_int_d ( g_conf, _vbuf, 1 ) ); // default to 'show' when unknown
887 unsigned char app_is_visible ( pnd_conf_handle h, char *uniqueid ) {
888 snprintf ( _vbuf, 500, "appshow.%s", uniqueid );
889 return ( pnd_conf_get_as_int_d ( g_conf, _vbuf, 1 ) ); // default to 'show' when unknown
892 void sigquit_handler ( int n ) {
893 pnd_log ( pndn_rem, "SIGQUIT received; graceful exit.\n" );
894 emit_and_quit ( MM_QUIT );
897 void setup_notifications ( void ) {
899 // figure out notify path
901 char *notifypath = NULL;
903 configpath = pnd_conf_query_searchpath();
905 pnd_conf_handle apph;
907 apph = pnd_conf_fetch_by_id ( pnd_conf_apps, configpath );
911 notifypath = pnd_conf_get_as_char ( apph, PND_APPS_NOTIFY_KEY );
913 if ( ! notifypath ) {
914 notifypath = PND_APPS_NOTIFYPATH;
919 // given notify path.. ripped from pndnotifyd :(
920 char *searchpath = notifypath;
922 // if this is first time through, we can just set it up; for subsequent times
923 // through, we need to close existing fd and re-open it, since we're too lame
924 // to store the list of watches and 'rm' them
927 pnd_notify_shutdown ( nh );
932 // set up a new set of notifies
934 nh = pnd_notify_init();
938 pnd_log ( pndn_rem, "INOTIFY failed to init.\n" );
943 pnd_log ( pndn_rem, "INOTIFY is up.\n" );
949 pnd_log ( pndn_rem, "Watching path '%s' and its descendents.\n", buffer );
950 pnd_notify_watch_path ( nh, buffer, PND_NOTIFY_RECURSE );
959 // Goal: normally menu will quit when an app is invoked, but there are cases when some folks
960 // may configure their system and want mmenu to live instead (save on restart time, don't care
961 // about RAM, using a multitasking tray/window manager setup...), so instead of 'exit and emit'
962 // here we just run the app directly and cross fingers!
963 void emit_and_run ( char *buffer ) {
965 // run the bloody thing
968 if ( ( f = fork() ) < 0 ) {
970 } else if ( f > 0 ) {
974 execl ( "/bin/sh", "/bin/sh", "-c", buffer + strlen(MM_RUN) + 1, (char*) NULL );
980 // this code was swiped from pnd_utility pnd_exec_no_wait_1 as it became a little too minimenu-specific to remain there
981 void exec_raw_binary ( char *fullpath ) {
984 if ( ( i = fork() ) < 0 ) {
985 printf ( "ERROR: Couldn't fork()\n" );
990 return; // parent process, don't care
993 // child process, do something
994 execl ( "/bin/sh", "/bin/sh", "-c", fullpath, (char*) NULL );
995 //execl ( fullpath, fullpath, (char*) NULL );
997 // error invoking something, and we're the child process, so just die before all hell breaks lose with us thinking we're the (second!) parent on return!
1000 // getting here is an error
1001 //printf ( "Error attempting to run %s\n", fullpath );