minimenu/mmenu.c

   1
   2 /* minimenu
   3  * aka "2wm" - too weak menu, two week menu, akin to twm
   4  *
   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..)
   7  * but later, baby!
   8  *
   9  */
  10
  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
  16  * debugging.
  17  */
  18
  19 /* mmenu lifecycle:
  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
  25  */
  26
  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>
  32 #include <sys/stat.h>
  33 #define __USE_GNU /* for strcasestr */
  34 #include <string.h> /* for making ftw.h happy */
  35 #include <strings.h>
  36 #include <ctype.h>
  37 #include <sys/wait.h>
  38 #include <dirent.h>
  39 #include <signal.h> // for sigaction
  40
  41 #include "pnd_logger.h"
  42 #include "pnd_pxml.h"
  43 #include "pnd_utility.h"
  44 #include "pnd_conf.h"
  45 #include "pnd_container.h"
  46 #include "pnd_discovery.h"
  47 #include "pnd_locate.h"
  48 #include "pnd_device.h"
  49 #include "pnd_pndfiles.h"
  50 #include "../lib/pnd_pathiter.h"
  51 #include "pnd_notify.h"
  52 #include "pnd_dbusnotify.h"
  53 #include "pnd_apps.h"
  54 #include "pnd_desktop.h"
  55
  56 #include "mmenu.h"
  57 #include "mmwrapcmd.h"
  58 #include "mmapps.h"
  59 #include "mmcache.h"
  60 #include "mmcat.h"
  61 #include "mmui.h"
  62 #include "mmconf.h"
  63
  64 pnd_box_handle g_active_apps = NULL;
  65 unsigned int g_active_appcount = 0;
  66 char g_username [ 128 ]; // since we have to wait for login (!!), store username here
  67 pnd_conf_handle g_conf = 0;
  68 pnd_conf_handle g_desktopconf = 0;
  69
  70 char *pnd_run_script = NULL;
  71 unsigned char g_x11_present = 1; // >0 if X is present
  72 unsigned char g_catmap = 0; // if 1, we're doing category mapping
  73 unsigned char g_pvwcache = 0; // if 1, we're trying to do preview caching
  74 unsigned char g_autorescan = 1; // default to auto rescan
  75
  76 pnd_dbusnotify_handle dbh = 0; // if >0, dbusnotify is active
  77 pnd_notify_handle nh = 0; // if >0, inotify is active
  78
  79 char g_skin_selected [ 100 ] = "default";
  80 char *g_skinpath = NULL; // where 'skin_selected' is located .. the fullpath including skin-dir-name
  81 pnd_conf_handle g_skinconf = NULL;
  82
  83 void sigquit_handler ( int n );
  84 unsigned char app_is_visible ( pnd_conf_handle h, char *uniqueid );
  85
  86 int main ( int argc, char *argv[] ) {
  87   int logall = -1; // -1 means normal logging rules; >=0 means log all!
  88   int i;
  89
  90   // boilerplate stuff from pndnotifyd and pndevmapperd
  91
  92   /* iterate across args
  93    */
  94   for ( i = 1; i < argc; i++ ) {
  95
  96     if ( argv [ i ][ 0 ] == '-' && argv [ i ][ 1 ] == 'l' ) {
  97
  98       if ( isdigit ( argv [ i ][ 2 ] ) ) {
  99         unsigned char x = atoi ( argv [ i ] + 2 );
 100         if ( x >= 0 &&
 101              x < pndn_none )
 102         {
 103           logall = x;
 104         }
 105       } else {
 106         logall = 0;
 107       }
 108
 109     } else {
 110       //printf ( "Unknown: %s\n", argv [ i ] );
 111       printf ( "%s [-l##]\n", argv [ 0 ] );
 112       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" );
 113       printf ( "-f\tFull path of frontend to run\n" );
 114       exit ( 0 );
 115     }
 116
 117   } // for
 118
 119   /* enable logging?
 120    */
 121   pnd_log_set_pretext ( "mmenu" );
 122   pnd_log_set_flush ( 1 );
 123
 124   if ( logall == -1 ) {
 125     // standard logging; non-daemon versus daemon
 126
 127 #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
 128     struct stat statbuf;
 129     if ( stat ( PND_DEVICE_BATTERY_GAUGE_PERC, &statbuf ) == 0 ) {
 130       // on pandora
 131       pnd_log_set_filter ( pndn_error );
 132     } else {
 133       pnd_log_set_filter ( pndn_debug );
 134     }
 135 #endif
 136
 137     pnd_log_to_stdout();
 138
 139   } else {
 140     FILE *f;
 141
 142     f = fopen ( "/tmp/mmenu.log", "w" );
 143
 144     if ( f ) {
 145       pnd_log_set_filter ( logall );
 146       pnd_log_to_stream ( f );
 147       pnd_log ( pndn_rem, "logall mode - logging to /tmp/mmenu.log\n" );
 148     }
 149
 150     if ( logall == pndn_debug ) {
 151       pnd_log_set_buried_logging ( 1 ); // log the shit out of it
 152       pnd_log ( pndn_rem, "logall mode 0 - turned on buried logging\n" );
 153     }
 154
 155   } // logall
 156
 157   pnd_log ( pndn_rem, "%s built %s %s", argv [ 0 ], __DATE__, __TIME__ );
 158
 159   pnd_log ( pndn_rem, "log level starting as %u", pnd_log_get_filter() );
 160
 161   // wait for a user to be logged in - we should probably get hupped when a user logs in, so we can handle
 162   // log-out and back in again, with SDs popping in and out between..
 163   pnd_log ( pndn_rem, "Checking to see if a user is logged in\n" );
 164   while ( 1 ) {
 165     if ( pnd_check_login ( g_username, 127 ) ) {
 166       break;
 167     }
 168     pnd_log ( pndn_debug, "  No one logged in yet .. spinning.\n" );
 169     sleep ( 2 );
 170   } // spin
 171   pnd_log ( pndn_rem, "Looks like user '%s' is in, continue.\n", g_username );
 172
 173   /* conf files
 174    */
 175
 176   // mmenu conf
 177   g_conf = pnd_conf_fetch_by_name ( MMENU_CONF, MMENU_CONF_SEARCHPATH );
 178
 179   if ( ! g_conf ) {
 180     pnd_log ( pndn_error, "ERROR: Couldn't fetch conf file '%s'!\n", MMENU_CONF );
 181     emit_and_quit ( MM_QUIT );
 182   }
 183
 184   // override mmenu conf via user preference conf
 185   conf_merge_into ( conf_determine_location ( g_conf ), g_conf );
 186   conf_setup_missing ( g_conf );
 187
 188   // desktop conf for app finding preferences
 189   g_desktopconf = pnd_conf_fetch_by_id ( pnd_conf_desktop, PND_CONF_SEARCHPATH );
 190
 191   if ( ! g_desktopconf ) {
 192     pnd_log ( pndn_error, "ERROR: Couldn't fetch desktop conf file\n" );
 193     emit_and_quit ( MM_QUIT );
 194   }
 195
 196   /* set up quit signal handler
 197    */
 198   sigset_t ss;
 199   sigemptyset ( &ss );
 200
 201   struct sigaction siggy;
 202   siggy.sa_handler = sigquit_handler;
 203   siggy.sa_mask = ss; /* implicitly blocks the origin signal */
 204   siggy.sa_flags = SA_RESTART; /* don't need anything */
 205   sigaction ( SIGQUIT, &siggy, NULL );
 206
 207   /* category conf file
 208    */
 209   {
 210     char *locater = pnd_locate_filename ( pnd_conf_get_as_char ( g_conf, "categories.catmap_searchpath" ),
 211                                           pnd_conf_get_as_char ( g_conf, "categories.catmap_confname" ) );
 212
 213     if ( locater ) {
 214       pnd_log ( pndn_rem, "Found category conf at '%s'\n", locater );
 215       pnd_conf_handle h = pnd_conf_fetch_by_path ( locater );
 216       if ( h ) {
 217         // lets just merge the skin conf onto the regular conf, so it just magicly works
 218         pnd_box_append ( g_conf, h );
 219       }
 220     } else {
 221       pnd_log ( pndn_debug, "No additional category conf file found.\n" );
 222     }
 223
 224   } // cat conf
 225
 226   // redo log filter
 227   pnd_log_set_filter ( pnd_conf_get_as_int_d ( g_conf, "minimenu.loglevel", pndn_error ) );
 228
 229   /* setup
 230    */
 231
 232   // X11?
 233   if ( pnd_conf_get_as_char ( g_conf, "minimenu.x11_present_sh" ) ) {
 234     FILE *fx = popen ( pnd_conf_get_as_char ( g_conf, "minimenu.x11_present_sh" ), "r" );
 235     char buffer [ 100 ];
 236     if ( fx ) {
 237       if ( fgets ( buffer, 100, fx ) ) {
 238         if ( atoi ( buffer ) ) {
 239           g_x11_present = 1;
 240           pnd_log ( pndn_rem, "X11 seems to be present [pid %u]\n", atoi(buffer) );
 241         } else {
 242           g_x11_present = 0;
 243           pnd_log ( pndn_rem, "X11 seems NOT to be present\n" );
 244         }
 245       } else {
 246           g_x11_present = 0;
 247           pnd_log ( pndn_rem, "X11 seems NOT to be present\n" );
 248       }
 249       pclose ( fx );
 250     }
 251   } // x11?
 252
 253   // pnd_run.sh
 254   pnd_run_script = pnd_locate_filename ( pnd_conf_get_as_char ( g_conf, "minimenu.pndrun" ), "pnd_run.sh" );
 255
 256   if ( ! pnd_run_script ) {
 257     pnd_log ( pndn_error, "ERROR: Couldn't locate pnd_run.sh!\n" );
 258     emit_and_quit ( MM_QUIT );
 259   }
 260
 261   pnd_run_script = strdup ( pnd_run_script ); // so we don't lose it next pnd_locate
 262
 263   pnd_log ( pndn_rem, "Found pnd_run.sh at '%s'\n", pnd_run_script );
 264
 265   // auto rescan?
 266   if ( pnd_conf_get_as_int ( g_conf, "minimenu.auto_rescan" ) != PND_CONF_BADNUM ) {
 267     g_autorescan = pnd_conf_get_as_int ( g_conf, "minimenu.auto_rescan" );
 268   }
 269   pnd_log ( pndn_debug, "application rescan is set to: %s\n", g_autorescan ? "auto" : "manual" );
 270
 271   // figure out what skin is selected (or default)
 272   FILE *f;
 273   char *s = strdup ( pnd_conf_get_as_char ( g_conf, "minimenu.skin_selected" ) );
 274   s = pnd_expand_tilde ( s );
 275   if ( ( f = fopen ( s, "r" ) ) ) {
 276     char buffer [ 100 ];
 277     if ( fgets ( buffer, 100, f ) ) {
 278       // see if that dir can be located
 279       if ( strchr ( buffer, '\n' ) ) {
 280         * strchr ( buffer, '\n' ) = '\0';
 281       }
 282       char *found = pnd_locate_filename ( pnd_conf_get_as_char ( g_conf, "minimenu.skin_searchpath" ), buffer );
 283       if ( found ) {
 284         strncpy ( g_skin_selected, buffer, 100 );
 285         g_skinpath = strdup ( found );
 286       } else {
 287         pnd_log ( pndn_warning, "Couldn't locate skin named '%s' so falling back.\n", buffer );
 288       }
 289     }
 290     fclose ( f );
 291   }
 292   free ( s );
 293
 294   if ( g_skinpath ) {
 295     pnd_log ( pndn_rem, "Skin is selected: '%s'\n", g_skin_selected );
 296   } else {
 297     pnd_log ( pndn_rem, "Skin falling back to: '%s'\n", g_skin_selected );
 298
 299     char *found = pnd_locate_filename ( pnd_conf_get_as_char ( g_conf, "minimenu.skin_searchpath" ),
 300                                         g_skin_selected );
 301     if ( found ) {
 302       g_skinpath = strdup ( found );
 303     } else {
 304       pnd_log ( pndn_error, "Couldn't locate skin named '%s'.\n", g_skin_selected );
 305       emit_and_quit ( MM_QUIT );
 306     }
 307
 308   }
 309   pnd_log ( pndn_rem, "Skin path determined to be: '%s'\n", g_skinpath );
 310
 311   // lets see if this skin-path actually has a skin conf
 312   {
 313     char fullpath [ PATH_MAX ];
 314     sprintf ( fullpath, "%s/%s", g_skinpath, pnd_conf_get_as_char ( g_conf, "minimenu.skin_confname" ) );
 315     g_skinconf = pnd_conf_fetch_by_path ( fullpath );
 316   }
 317
 318   // figure out skin path if we didn't get it already
 319   if ( ! g_skinconf ) {
 320     pnd_log ( pndn_error, "ERROR: Couldn't set up skin!\n" );
 321     emit_and_quit ( MM_QUIT );
 322   }
 323
 324   // lets just merge the skin conf onto the regular conf, so it just magicly works
 325   pnd_box_append ( g_conf, g_skinconf );
 326
 327   // did user override the splash image?
 328   char *splash = pnd_conf_get_as_char ( g_conf, "minimenu.force_wallpaper" );
 329   if ( splash ) {
 330     // we've got a filename, presumably; lets see if it exists
 331     struct stat statbuf;
 332     if ( stat ( splash, &statbuf ) == 0 ) {
 333       // file seems to exist, lets set our override to that..
 334       pnd_conf_set_char ( g_conf, "graphics.IMG_BACKGROUND_800480", splash );
 335     }
 336   }
 337
 338   // attempt to set up UI
 339   if ( ! ui_setup() ) {
 340     pnd_log ( pndn_error, "ERROR: Couldn't set up the UI!\n" );
 341     emit_and_quit ( MM_QUIT );
 342   }
 343
 344   // show load screen
 345   ui_loadscreen();
 346
 347   // store flag if we're doing preview caching or not
 348   if ( pnd_conf_get_as_int_d ( g_conf, "previewpic.do_cache", 0 ) ) {
 349     g_pvwcache = 1;
 350   }
 351
 352   // set up static image cache
 353   if ( ! ui_imagecache ( g_skinpath ) ) {
 354     pnd_log ( pndn_error, "ERROR: Couldn't set up static UI image cache!\n" );
 355     emit_and_quit ( MM_QUIT );
 356   }
 357
 358   // init categories
 359   category_init();
 360
 361   // create all cat
 362   if ( pnd_conf_get_as_int_d ( g_conf, "categories.do_all_cat", 1 ) ) {
 363     category_push ( g_x11_present ? CATEGORY_ALL "    (X11)" : CATEGORY_ALL "   (No X11)", NULL /* parent cat */, NULL /*app*/, 0, NULL /* fspath */, 1 /* visible */ );
 364   }
 365
 366   // set up category mappings
 367   if ( pnd_conf_get_as_int_d ( g_conf, "categories.map_on", 0 ) ) {
 368     g_catmap = category_map_setup();
 369   }
 370
 371   /* inhale applications, icons, categories, etc
 372    */
 373   applications_scan();
 374
 375   /* actual work now
 376    */
 377   if ( g_autorescan ) {
 378
 379     // set up notifications
 380     dbh = pnd_dbusnotify_init();
 381     pnd_log ( pndn_debug, "Setting up dbusnotify\n" );
 382     //setup_notifications();
 383
 384     // create a timer thread, that will trigger us to check for SD insert notifications every once in awhile
 385     ui_threaded_timer_create();
 386
 387   } // set up rescan
 388
 389   /* set speed to minimenu run-speed, now that we're all set up
 390    */
 391 #if 0 /* something crashes at high speed image caching.. */
 392   int use_mm_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.use_mm_speed", 0 );
 393   if ( use_mm_speed > 0 ) {
 394     int mm_speed = pnd_conf_get_as_int_d ( g_conf, "minimenu.mm_speed", -1 );
 395     if ( mm_speed > 50 && mm_speed < 800 ) {
 396       char buffer [ 512 ];
 397       snprintf ( buffer, 500, "sudo /usr/pandora/scripts/op_cpuspeed.sh %d", mm_speed );
 398       system ( buffer );
 399     }
 400   } // do speed change?
 401 #endif
 402
 403   // do it!
 404   while ( 1 ) { // forever!
 405
 406     // show the menu, or changes thereof
 407     ui_render();
 408
 409     // wait for input or time-based events (like animations) and deal with inputs
 410     ui_process_input ( dbh, nh );
 411
 412   } // while
 413
 414   return ( 0 );
 415 }
 416
 417 void emit_and_quit ( char *s ) {
 418   printf ( "%s\n", s );
 419   // shutdown notifications
 420   if ( g_autorescan ) {
 421
 422     if ( dbh ) {
 423       pnd_dbusnotify_shutdown ( dbh );
 424     }
 425     if ( nh ) {
 426       pnd_notify_shutdown ( nh );
 427     }
 428
 429   }
 430
 431   exit ( 0 );
 432 }
 433
 434 static unsigned int is_dir_empty ( char *fullpath ) {
 435   DIR *d = opendir ( fullpath );
 436
 437   if ( ! d ) {
 438     return ( 0 ); // not empty, since we don't know
 439   }
 440
 441   struct dirent *de = readdir ( d );
 442
 443   while ( de ) {
 444
 445     if ( strcmp ( de -> d_name, "." ) == 0 ) {
 446       // irrelevent
 447     } else if ( strcmp ( de -> d_name, ".." ) == 0 ) {
 448       // irrelevent
 449     } else {
 450       // something else came in, so dir must not be empty
 451       closedir ( d );
 452       return ( 0 );
 453     }
 454
 455     de = readdir ( d );
 456   }
 457
 458   closedir ( d );
 459
 460   return ( 1 ); // dir is empty
 461 }
 462
 463 void applications_free ( void ) {
 464
 465   // free up all our category apprefs, but keep the preview and icon cache's..
 466   category_freeall();
 467
 468   // free up old disco_t
 469   if ( g_active_apps ) {
 470     pnd_disco_t *p = pnd_box_get_head ( g_active_apps );
 471     pnd_disco_t *n;
 472     while ( p ) {
 473       n = pnd_box_get_next ( p );
 474       pnd_disco_destroy ( p );
 475       p = n;
 476     }
 477     pnd_box_delete ( g_active_apps );
 478   }
 479
 480   return;
 481 }
 482
 483 void applications_scan ( void ) {
 484
 485   // has user disabled pnd scanning, by chance?
 486   if ( ! pnd_conf_get_as_int_d ( g_conf, "filesystem.do_pnd_disco", 1 ) ) {
 487     goto dirbrowser_scan; // skip pnd's
 488   }
 489
 490   // show disco screen
 491   ui_discoverscreen ( 1 /* clear screen */ );
 492
 493   // determine current app list, cache icons
 494   // - ignore overrides for now
 495
 496   g_active_apps = 0;
 497   pnd_box_handle merge_apps = 0;
 498
 499   // boy I wish I built a plugin system here
 500   //
 501
 502   // perform application discovery for pnd-files?
 503   //
 504   if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.disco_pnds", 1 ) ) {
 505
 506     // desktop apps?
 507     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.desktop_apps", 1 ) ) {
 508       pnd_log ( pndn_debug, "Looking for pnd applications here: %s\n",
 509                 pnd_conf_get_as_char ( g_desktopconf, "desktop.searchpath" ) );
 510       g_active_apps = pnd_disco_search ( pnd_conf_get_as_char ( g_desktopconf, "desktop.searchpath" ), NULL );
 511     }
 512
 513     // menu apps?
 514     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.menu_apps", 1 ) ) {
 515       pnd_log ( pndn_debug, "Looking for pnd applications here: %s\n",
 516                 pnd_conf_get_as_char ( g_desktopconf, "menu.searchpath" ) );
 517       merge_apps = pnd_disco_search ( pnd_conf_get_as_char ( g_desktopconf, "menu.searchpath" ), NULL );
 518     }
 519
 520     // merge lists
 521     if ( merge_apps ) {
 522       if ( g_active_apps ) {
 523         // the key from pnd_disco_search() is the _path_, so easy to look for duplicates
 524         // this is pretty inefficient, being linked lists; perhaps should switch to hash tables when
 525         // we expect thousands of apps.. or at least an index or something.
 526         void *a = pnd_box_get_head ( merge_apps );
 527         void *nexta = NULL;
 528         while ( a ) {
 529           nexta = pnd_box_get_next ( a );
 530
 531           // if the key for the node is also found in active apps, toss out the merging one
 532           if ( pnd_box_find_by_key ( g_active_apps, pnd_box_get_key ( a ) ) ) {
 533             //fprintf ( stderr, "Merging app id '%s' is duplicate; discarding it.\n", pnd_box_get_key ( a ) );
 534             pnd_box_delete_node ( merge_apps, a );
 535           }
 536
 537           a = nexta;
 538         }
 539
 540         // got menu apps, and got desktop apps, merge
 541         pnd_box_append ( g_active_apps, merge_apps );
 542       } else {
 543         // got menu apps, had no desktop apps, so just assign
 544         g_active_apps = merge_apps;
 545       }
 546     }
 547
 548     // aux apps?
 549     char *aux_apps = NULL;
 550     merge_apps = 0;
 551     aux_apps = pnd_conf_get_as_char ( g_conf, "minimenu.aux_searchpath" );
 552     if ( aux_apps && aux_apps [ 0 ] ) {
 553       pnd_log ( pndn_debug, "Looking for pnd applications here: %s\n", aux_apps );
 554       merge_apps = pnd_disco_search ( aux_apps, NULL );
 555     }
 556
 557     // merge aux apps
 558     if ( merge_apps ) {
 559       if ( g_active_apps ) {
 560
 561         // LAME: snipped from above; should just catenate the 3 sets of searchpaths into a
 562         // master searchpath, possibly removing duplicate paths _then_, and keep all this much
 563         // more efficient
 564
 565         // the key from pnd_disco_search() is the _path_, so easy to look for duplicates
 566         // this is pretty inefficient, being linked lists; perhaps should switch to hash tables when
 567         // we expect thousands of apps.. or at least an index or something.
 568         void *a = pnd_box_get_head ( merge_apps );
 569         void *nexta = NULL;
 570         while ( a ) {
 571           nexta = pnd_box_get_next ( a );
 572
 573           // if the key for the node is also found in active apps, toss out the merging one
 574           if ( pnd_box_find_by_key ( g_active_apps, pnd_box_get_key ( a ) ) ) {
 575             fprintf ( stderr, "Merging app id '%s' is duplicate; discarding it.\n", pnd_box_get_key ( a ) );
 576             pnd_box_delete_node ( merge_apps, a );
 577           }
 578
 579           a = nexta;
 580         }
 581
 582         pnd_box_append ( g_active_apps, merge_apps );
 583       } else {
 584         g_active_apps = merge_apps;
 585       }
 586     }
 587
 588   } // app discovery on pnd-files?
 589
 590   // perform app discovery on .desktop files?
 591   //
 592   if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.disco_dotdesktop", 0 ) ) {
 593     char *chunks[5] = {
 594       pnd_conf_get_as_char ( g_desktopconf, "desktop.dotdesktoppath" ),
 595       pnd_conf_get_as_char ( g_desktopconf, "menu.dotdesktoppath" ),
 596       //"/usr/share/applications",
 597       NULL
 598     };
 599     char ddpath [ 1024 ];
 600     unsigned int flags = PND_DOTDESKTOP_LIBPND_ONLY;
 601
 602     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.disco_dotdesktop_all", 0 ) ) {
 603       flags = 0; // get all
 604     }
 605
 606     // app box?
 607     if ( ! g_active_apps ) {
 608       g_active_apps = pnd_box_new ( "discovery-dotdesktop" );
 609     }
 610
 611     // for each searchpath..
 612     unsigned char i;
 613     for ( i = 0; i < 5; i++ ) {
 614
 615       if ( ! chunks [ i ] ) {
 616         break;
 617       }
 618
 619       DIR *d = opendir ( chunks [ i ] );
 620
 621       if ( d ) {
 622         struct dirent *de = readdir ( d );
 623
 624         // for each filename found
 625         while ( de ) {
 626
 627           if ( strcmp ( de -> d_name, "." ) == 0 ) {
 628             // irrelevent
 629           } else if ( strcmp ( de -> d_name, ".." ) == 0 ) {
 630             // irrelevent
 631           } else {
 632             snprintf ( ddpath, 1024, "%s/%s", chunks [ i ], de -> d_name );
 633             pnd_disco_t *p = pnd_parse_dotdesktop ( ddpath, flags );
 634             if ( p ) {
 635               pnd_disco_t *ai = pnd_box_allocinsert ( g_active_apps, ddpath, sizeof(pnd_disco_t) );
 636               memmove ( ai, p, sizeof(pnd_disco_t) );
 637             }
 638           }
 639
 640           // next!
 641           de = readdir ( d );
 642         }
 643
 644         closedir ( d );
 645
 646       } // for each dir
 647
 648     } // for each searchpath
 649
 650   } // app discovery in .desktops
 651
 652   // do it
 653   g_active_appcount = pnd_box_get_size ( g_active_apps );
 654
 655   unsigned char maxwidth, maxheight;
 656   maxwidth = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_width", 50 );
 657   maxheight = pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_height", 50 );
 658
 659   // show cache screen
 660   ui_cachescreen ( 1 /* clear screen */, NULL );
 661
 662   pnd_log ( pndn_debug, "Found pnd applications, and caching icons:\n" );
 663   pnd_disco_t *iter = pnd_box_get_head ( g_active_apps );
 664   unsigned int itercount = 0;
 665   unsigned loadlater = pnd_conf_get_as_int_d ( g_conf, "minimenu.load_icons_later", 0 );
 666   while ( iter ) {
 667     //pnd_log ( pndn_debug, "  App: '%s'\n", IFNULL(iter->title_en,"No Name") );
 668
 669     // update cachescreen
 670     // ... every 5 filenames, just to avoid slowing it too much
 671     if ( loadlater == 0 && itercount % 5 == 0 ) {
 672       ui_cachescreen ( 0 /* clear screen */, IFNULL(iter->title_en,"No Name") );
 673     }
 674
 675     // if an ovr was flagged by libpnd, lets go inhale it just so we've got the
 676     // notes handy, since notes are not handled by libpnd proper
 677     pnd_conf_handle ovrh = 0;
 678     if ( iter -> object_flags & PND_DISCO_FLAG_OVR ) {
 679       char ovrfile [ PATH_MAX ];
 680       char *fixpxml;
 681       sprintf ( ovrfile, "%s/%s", iter -> object_path, iter -> object_filename );
 682       fixpxml = strcasestr ( ovrfile, PND_PACKAGE_FILEEXT );
 683       strcpy ( fixpxml, PXML_SAMEPATH_OVERRIDE_FILEEXT );
 684
 685       ovrh = pnd_conf_fetch_by_path ( ovrfile );
 686
 687 #if 0
 688       if ( ovrh ) {
 689         pnd_log ( pndn_debug, "Found ovr file for %s # %u\n", iter -> object_filename, iter -> subapp_number );
 690       }
 691 #endif
 692
 693       if ( ovrh ) {
 694         // lets also check to see if this ovr is specifying category overrides; if so, we can trust those
 695         // more than categories specified by pnd-packager.
 696         char ovrkey [ 41 ];
 697
 698         snprintf ( ovrkey, 40, "Application-%u.maincategory", iter -> subapp_number );
 699         if ( pnd_conf_get_as_char ( ovrh, ovrkey ) ) {
 700           iter -> object_flags |= PND_DISCO_CUSTOM1;
 701           //printf ( "App '%s' has main cat ovr %s\n", iter -> title_en, pnd_conf_get_as_char ( ovrh, ovrkey ) );
 702         }
 703
 704         snprintf ( ovrkey, 40, "Application-%u.maincategorysub1", iter -> subapp_number );
 705         if ( pnd_conf_get_as_char ( ovrh, ovrkey ) ) {
 706           iter -> object_flags |= PND_DISCO_CUSTOM2;
 707           //printf ( "App '%s' has sub cat ovr %s\n", iter -> title_en, pnd_conf_get_as_char ( ovrh, ovrkey ) );
 708         }
 709
 710       } // got ovr loaded/
 711
 712     } // ovr
 713
 714     // cache the icon, unless deferred
 715     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_icons_later", 0 ) == 0 ) {
 716
 717       // if app was from a pnd and has an icon-pos (we've already found where it is in the binary),
 718       // OR its a .desktop and we've got a path
 719       // THEN go try to cache/load the icon
 720       if ( ( iter -> pnd_icon_pos ) ||
 721            ( iter -> icon && iter -> object_flags & PND_DISCO_CUSTOM1 )
 722          )
 723       {
 724
 725         if ( ! cache_icon ( iter, maxwidth, maxheight ) ) {
 726           pnd_log ( pndn_warning, "  WARNING: Couldn't load icon: '%s'\n", IFNULL(iter->title_en,"No Name") );
 727         }
 728
 729       }
 730
 731     }
 732
 733     // cache the preview --> SHOULD DEFER
 734     if ( pnd_conf_get_as_int_d ( g_conf, "minimenu.load_previews_now", 0 ) > 0 ) {
 735       // load the preview pics now!
 736       if ( iter -> preview_pic1 &&
 737            ! 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 ) ) )
 738       {
 739         pnd_log ( pndn_warning, "  Couldn't load preview pic: '%s' -> '%s'\n", IFNULL(iter->title_en,"No Name"), iter -> preview_pic1 );
 740       }
 741     } // preview now?
 742
 743     // push the categories .. or suppress application
 744     //
 745     if ( ( pnd_pxml_get_x11 ( iter -> option_no_x11 ) != pnd_pxml_x11_required ) ||
 746          ( pnd_pxml_get_x11 ( iter -> option_no_x11 ) == pnd_pxml_x11_required && g_x11_present == 1 )
 747        )
 748     {
 749
 750       if ( iter -> title_en == NULL || iter -> title_en [ 0 ] == '\0' ) {
 751         // null title; just skip it.
 752       } else {
 753
 754         // push to All category
 755         // we do this first, so first category is always All
 756         if ( pnd_conf_get_as_int_d ( g_conf, "categories.do_all_cat", 1 ) ) {
 757           category_push ( g_x11_present ? CATEGORY_ALL "    (X11)" : CATEGORY_ALL "   (No X11)", NULL /* parent cat */, iter, ovrh, NULL /* fspath */, 1 /* visible */ );
 758         } // all?
 759
 760         // is this app suppressed? if not, show it in whatever categories the user is allowing
 761         if ( iter -> unique_id && app_is_visible ( g_conf, iter -> unique_id ) ) {
 762
 763 #if 0
 764           pnd_log ( pndn_rem, "App %s [%s] cat %s %s %s alt %s %s %s\n",
 765                     iter -> unique_id, IFNULL(iter->title_en,"n/a"),
 766                     IFNULL(iter->main_category,"n/a"), IFNULL(iter->main_category1,"n/a"), IFNULL(iter->main_category2,"n/a"),
 767                     IFNULL(iter->alt_category,"n/a"), IFNULL(iter->alt_category1,"n/a"), IFNULL(iter->alt_category2,"n/a") );
 768 #endif
 769
 770           // main categories
 771           category_meta_push ( iter -> main_category, NULL /* no parent cat */, iter, ovrh, cat_is_visible ( g_conf, iter -> main_category ), 1);
 772           category_meta_push ( iter -> main_category1, iter -> main_category, iter, ovrh, cat_is_visible ( g_conf, iter -> main_category1 ), 0 );
 773           category_meta_push ( iter -> main_category2, iter -> main_category, iter, ovrh, cat_is_visible ( g_conf, iter -> main_category2 ), 0 );
 774           // alt categories
 775           category_meta_push ( iter -> alt_category, NULL /* no parent cat */, iter, ovrh, cat_is_visible ( g_conf, iter -> alt_category ), 2 );
 776           category_meta_push ( iter -> alt_category1, iter -> alt_category, iter, ovrh, cat_is_visible ( g_conf, iter -> alt_category1 ), 0 );
 777           category_meta_push ( iter -> alt_category2, iter -> alt_category, iter, ovrh, cat_is_visible ( g_conf, iter -> alt_category2 ), 0 );
 778
 779         } // app is visible?
 780
 781       } // has title?
 782
 783     } // register with categories or filter out
 784
 785     // next
 786     iter = pnd_box_get_next ( iter );
 787     itercount++;
 788   } // while
 789
 790  dirbrowser_scan:
 791
 792   // set up filesystem browser tabs
 793   if ( pnd_conf_get_as_int_d ( g_conf, "filesystem.do_browser", 0 ) ) {
 794     char *searchpath = pnd_conf_get_as_char ( g_conf, "filesystem.tab_searchpaths" );
 795
 796     SEARCHPATH_PRE
 797     {
 798       char *c, *tabname;
 799       c = strrchr ( buffer, '/' );
 800       if ( c && (*(c+1)!='\0') ) {
 801         tabname = c;
 802       } else {
 803         tabname = buffer;
 804       }
 805
 806       // check if dir is empty; if so, skip it.
 807       if ( ! is_dir_empty ( buffer ) ) {
 808         category_push ( tabname /* tab name */, NULL /* parent cat */, NULL /* app */, 0 /* override */, buffer /* fspath */, 1 /* visible */ );
 809       }
 810
 811     }
 812     SEARCHPATH_POST
 813
 814   } // set up fs browser tabs
 815
 816   // dump categories
 817   //category_dump();
 818
 819   // publish desired categories
 820   category_publish ( CFNORMAL, NULL );
 821
 822   // let deferred icon cache go now
 823   ui_post_scan();
 824
 825   // log completion
 826   pnd_log ( pndn_debug, "Applications scan done.\n" );
 827
 828   return;
 829 }
 830
 831 static char _vbuf [ 512 ];
 832 unsigned char cat_is_visible ( pnd_conf_handle h, char *catname ) {
 833   snprintf ( _vbuf, 500, "tabshow.%s", catname );
 834   return ( pnd_conf_get_as_int_d ( g_conf, _vbuf, 1 ) ); // default to 'show' when unknown
 835 }
 836
 837 unsigned char app_is_visible ( pnd_conf_handle h, char *uniqueid ) {
 838   snprintf ( _vbuf, 500, "appshow.%s", uniqueid );
 839   return ( pnd_conf_get_as_int_d ( g_conf, _vbuf, 1 ) ); // default to 'show' when unknown
 840 }
 841
 842 void sigquit_handler ( int n ) {
 843   pnd_log ( pndn_rem, "SIGQUIT received; graceful exit.\n" );
 844   emit_and_quit ( MM_QUIT );
 845 }
 846
 847 void setup_notifications ( void ) {
 848
 849   // figure out notify path
 850   char *configpath;
 851   char *notifypath = NULL;
 852
 853   configpath = pnd_conf_query_searchpath();
 854
 855   pnd_conf_handle apph;
 856
 857   apph = pnd_conf_fetch_by_id ( pnd_conf_apps, configpath );
 858
 859   if ( apph ) {
 860
 861     notifypath = pnd_conf_get_as_char ( apph, PND_APPS_NOTIFY_KEY );
 862
 863     if ( ! notifypath ) {
 864       notifypath = PND_APPS_NOTIFYPATH;
 865     }
 866
 867   }
 868
 869   // given notify path.. ripped from pndnotifyd :(
 870   char *searchpath = notifypath;
 871
 872   // if this is first time through, we can just set it up; for subsequent times
 873   // through, we need to close existing fd and re-open it, since we're too lame
 874   // to store the list of watches and 'rm' them
 875 #if 1
 876   if ( nh ) {
 877     pnd_notify_shutdown ( nh );
 878     nh = 0;
 879   }
 880 #endif
 881
 882   // set up a new set of notifies
 883   if ( ! nh ) {
 884     nh = pnd_notify_init();
 885   }
 886
 887   if ( ! nh ) {
 888     pnd_log ( pndn_rem, "INOTIFY failed to init.\n" );
 889     exit ( -1 );
 890   }
 891
 892 #if 0
 893   pnd_log ( pndn_rem, "INOTIFY is up.\n" );
 894 #endif
 895
 896   SEARCHPATH_PRE
 897   {
 898
 899     pnd_log ( pndn_rem, "Watching path '%s' and its descendents.\n", buffer );
 900     pnd_notify_watch_path ( nh, buffer, PND_NOTIFY_RECURSE );
 901
 902   }
 903   SEARCHPATH_POST
 904
 905   return;
 906 }
 907
 908 // for Pleng
 909 // Goal: normally menu will quit when an app is invoked, but there are cases when some folks
 910 // may configure their system and want mmenu to live instead (save on restart time, don't care
 911 // about RAM, using a multitasking tray/window manager setup...), so instead of 'exit and emit'
 912 // here we just run the app directly and cross fingers!
 913 void emit_and_run ( char *buffer ) {
 914
 915   // run the bloody thing
 916   int f;
 917
 918   if ( ( f = fork() ) < 0 ) {
 919     // error forking
 920   } else if ( f > 0 ) {
 921     // parent
 922   } else {
 923     // child, do it
 924     execl ( "/bin/sh", "/bin/sh", "-c", buffer + strlen(MM_RUN) + 1, (char*) NULL );
 925   }
 926
 927   return;
 928 }
 929
 930 // this code was swiped from pnd_utility pnd_exec_no_wait_1 as it became a little too minimenu-specific to remain there
 931 void exec_raw_binary ( char *fullpath ) {
 932   int i;
 933
 934   if ( ( i = fork() ) < 0 ) {
 935     printf ( "ERROR: Couldn't fork()\n" );
 936     return;
 937   }
 938
 939   if ( i ) {
 940     return; // parent process, don't care
 941   }
 942
 943   // child process, do something
 944   execl ( "/bin/sh", "/bin/sh", "-c", fullpath, (char*) NULL );
 945   //execl ( fullpath, fullpath, (char*) NULL );
 946
 947   // 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!
 948   exit ( -1 );
 949
 950   // getting here is an error
 951   //printf ( "Error attempting to run %s\n", fullpath );
 952
 953   return;
 954 }