12 #include "pnd_logger.h"
14 #include "pnd_container.h"
15 #include "pnd_discovery.h"
16 #include "../lib/pnd_pathiter.h"
21 #include "freedesktop_cats.h"
23 // all categories known -- visible, hidden, subcats, whatever.
24 pnd_box_handle m_categories = NULL;
25 unsigned int m_categorycount = 0;
27 // all categories being published right now -- a subset copied from m_categories
28 mm_category_t *g_categories [ MAX_CATS ];
29 unsigned char g_categorycount;
32 mm_catmap_t g_catmaps [ MAX_CATS ];
33 unsigned char g_catmapcount = 0;
35 extern pnd_conf_handle g_conf;
37 void category_init ( void ) {
38 m_categories = pnd_box_new ( "Schrodinger's cat" );
42 unsigned char category_push ( char *catname, pnd_disco_t *app, pnd_conf_handle ovrh, char *fspath, unsigned char visiblep ) {
45 // check category list; if found, append app to the end of it.
46 // if not found, add it to the category list and plop the app in there.
47 // app's are just app-refs, which contain links to the disco-t list -- thus removal is only in one place, and
48 // an app can be in multiple categories if we like..
51 // find or create category
54 if ( ( c = pnd_box_find_by_key ( m_categories, catname ) ) ) {
55 // category was found..
57 // category wasn't found..
58 //pnd_log ( PND_LOG_DEFAULT, "New category '%s'\n", catname );
59 c = pnd_box_allocinsert ( m_categories, catname, sizeof(mm_category_t) );
60 c -> catname = strdup ( catname );
62 c -> catflags = CFNORMAL;
64 c -> catflags = CFHIDDEN;
69 c -> fspath = strdup ( fspath );
76 return ( 1 ); // create cat, but skip app
79 // alloc and populate appref
81 mm_appref_t *ar = malloc ( sizeof(mm_appref_t) );
86 bzero ( ar, sizeof(mm_appref_t) );
91 // plug it into category
92 // and sort it on insert!
94 ar -> next = c -> refs;
97 // if no refs at all, or new guy has no title, just stick it in at head
98 if ( c -> refs && ar -> ref -> title_en ) {
99 mm_appref_t *iter = c -> refs;
100 mm_appref_t *last = NULL;
104 if ( iter -> ref -> title_en ) {
105 if ( cat_sort_score ( c, ar, iter ) < 0 ) {
106 // new guy is smaller than the current guy!
110 // since new guy must have a name by here, we're bigger than any guy who does not have a name
119 // smaller than the current guy, so stitch in
124 ar -> next = c -> refs;
128 // we're the biggest, just append to last
133 ar -> next = c -> refs;
142 int cat_sort_score ( mm_category_t *cat, mm_appref_t *s1, mm_appref_t *s2 ) {
144 // are we in a directory browser, or looking at pnd-files?
145 if ( cat -> fspath ) {
148 return ( 0 ); // equal
150 } else if ( s1 -> ref -> object_type == pnd_object_type_directory &&
151 s2 -> ref -> object_type == pnd_object_type_directory )
153 // both are directories, be nice
154 return ( strcmp ( s1 -> ref -> title_en, s2 -> ref -> title_en ) );
155 } else if ( s1 -> ref -> object_type == pnd_object_type_directory &&
156 s2 -> ref -> object_type != pnd_object_type_directory )
158 return ( -1 ); // dir on the left is earlier than file on the right
159 } else if ( s1 -> ref -> object_type != pnd_object_type_directory &&
160 s2 -> ref -> object_type == pnd_object_type_directory )
162 return ( 1 ); // dir on the right is earlier than file on the left
165 return ( strcmp ( s1 -> ref -> title_en, s2 -> ref -> title_en ) );
170 return ( strcasecmp ( s1 -> ref -> title_en, s2 -> ref -> title_en ) );
173 void category_dump ( void ) {
175 // WHY AREN'T I SORTING ON INSERT?
178 mm_category_t *iter = pnd_box_get_head ( m_categories );
179 unsigned int counter = 0;
183 pnd_log ( PND_LOG_DEFAULT, "Category %u: '%s' * %u\n", counter, iter -> catname, iter -> refcount );
184 mm_appref_t *ar = iter -> refs;
187 pnd_log ( PND_LOG_DEFAULT, " Appref %s\n", IFNULL(ar -> ref -> title_en,"No Name") );
191 iter = pnd_box_get_next ( iter );
198 void category_freeall ( void ) {
199 mm_category_t *c, *cnext;
200 mm_appref_t *iter, *next;
202 c = pnd_box_get_head ( m_categories );
205 cnext = pnd_box_get_next ( c );
218 if ( c -> catname ) {
219 free ( c -> catname );
224 free ( c -> fspath );
228 pnd_box_delete_node ( m_categories, c );
237 unsigned char category_map_setup ( void ) {
239 char *searchpath = pnd_box_get_head ( g_conf );
241 if ( ! searchpath ) {
245 // look through conf for useful keys
246 while ( searchpath ) {
247 char *k = pnd_box_get_key ( searchpath );
249 // does this key look like a category mapping key?
250 if ( strncasecmp ( k, "categories.@", 12 ) == 0 ) {
253 // iterate across 'words' in v, assigning catmaps to them
256 //pnd_log ( pndn_debug, "target(%s) from(%s)\n", k, buffer );
258 category_push ( k, NULL, 0, NULL /* fspath */, 1 );
259 g_catmaps [ g_catmapcount ].target = pnd_box_find_by_key ( m_categories, k );
260 g_catmaps [ g_catmapcount ].from = strdup ( buffer );
266 } // if key looks like catmap
268 searchpath = pnd_box_get_next ( searchpath );
269 } // while each conf key
274 mm_category_t *category_map_query ( char *cat ) {
277 for ( i = 0; i < g_catmapcount; i++ ) {
278 if ( strcasecmp ( g_catmaps [ i ].from, cat ) == 0 ) {
279 return ( g_catmaps [ i ].target );
286 unsigned char category_meta_push ( char *catname, char *parentcatname, pnd_disco_t *app, pnd_conf_handle ovrh, unsigned char visiblep ) {
288 char catnamebuffer [ 512 ] = "";
291 return ( 1 ); // fine, just nada
294 //fprintf ( stderr, "meta push: '%s'\n", catname );
296 // push bad categories into Other (if we're not targeting All right now)
297 if ( pnd_conf_get_as_int_d ( g_conf, "categories.good_cats_only", 1 ) ) {
300 if ( strncmp ( catname, "All ", 4 ) != 0 ) {
302 // if this is a parent cat..
303 if ( catname && ! parentcatname ) {
305 // if bad, shove it to Other
306 if ( ! freedesktop_check_cat ( catname ) ) {
307 parentcatname = NULL;
308 catname = BADCATNAME;
309 visiblep = cat_is_visible ( g_conf, catname );
312 } else if ( catname && parentcatname ) {
315 // if parent is bad, then we probably already pushed it over, so don't do it again.
316 // if its parent is okay, but subcat is bad, push it to other. (ie: lets avoid duplication in Other)
317 if ( ! freedesktop_check_cat ( parentcatname ) ) {
321 } else if ( ! freedesktop_check_cat ( catname ) ) {
322 parentcatname = NULL;
323 catname = BADCATNAME;
324 visiblep = cat_is_visible ( g_conf, catname );
327 } // parent or child cat?
333 // if invisible, and a parent category name is known, prepend it for ease of use
334 if ( ! visiblep && parentcatname ) {
335 snprintf ( catnamebuffer, 500, "%s.%s", parentcatname, catname );
336 catname = catnamebuffer;
339 // do we honour cat mapping at all?
340 if ( pnd_conf_get_as_int_d ( g_conf, "categories.map_on", 0 ) ) {
342 // is this guy mapped?
343 cat = category_map_query ( catname );
346 category_push ( cat -> catname, app, ovrh, NULL /* fspath */, visiblep );
350 // not mapped.. but default?
351 if ( pnd_conf_get_as_int_d ( g_conf, "categories.map_default_on", 0 ) ) {
352 char *def = pnd_conf_get_as_char ( g_conf, "categories.map_default_cat" );
354 category_push ( def, app, ovrh, NULL /* fspath */, visiblep );
359 } // cat map is desired?
361 // not default, just do it
362 category_push ( catname, app, ovrh, NULL /* fspath */, visiblep );
367 //fprintf ( stderr, "cat meta-push : vis[%30s,%d b] : tally; vis %d invis %d\n", catname, visiblep, g_categorycount, _categories_inviscount );
372 unsigned char category_fs_restock ( mm_category_t *cat ) {
374 if ( ! cat -> fspath ) {
375 return ( 1 ); // not a filesystem browser tab
378 // clear any existing baggage
382 mm_appref_t *iter = cat -> refs, *next;
391 if ( cat -> disco ) {
392 pnd_disco_t *p = pnd_box_get_head ( cat -> disco );
395 n = pnd_box_get_next ( p );
396 pnd_disco_destroy ( p );
399 pnd_box_delete ( cat -> disco );
402 // rescan the filesystem
405 //pnd_log ( pndn_debug, "Restocking cat %s with path %s\n", cat -> catname, cat -> fspath );
408 if ( ( d = opendir ( cat -> fspath ) ) ) {
409 struct dirent *de = readdir ( d );
414 cat -> disco = pnd_box_new ( cat -> catname );
419 char fullpath [ PATH_MAX ];
420 sprintf ( fullpath, "%s/%s", cat -> fspath, de -> d_name );
421 int statret = stat ( fullpath, &buffy );
423 // if file is executable somehow or another
425 buffy.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)
428 // determine unique-id
429 sprintf ( uid, "%d", (int) de -> d_ino );
432 switch ( de -> d_type ) {
435 if ( strcmp ( de -> d_name, "." ) == 0 ) {
436 // ignore ".", but ".." is fine
438 disco = pnd_box_allocinsert ( cat -> disco, uid, sizeof(pnd_disco_t) );
439 disco -> object_type = pnd_object_type_directory; // suggest to Grid that its a dir
444 disco = pnd_box_allocinsert ( cat -> disco, uid, sizeof(pnd_disco_t) );
445 disco -> object_type = pnd_object_type_unknown; // suggest to Grid that its a file
450 // found a directory or executable?
452 // register with current category
453 disco -> unique_id = strdup ( uid );
454 disco -> title_en = strdup ( de -> d_name );
455 disco -> object_flags = PND_DISCO_GENERATED;
456 disco -> object_path = strdup ( cat -> fspath );
457 disco -> object_filename = strdup ( de -> d_name );
458 category_push ( cat -> catname, disco, 0 /* no ovr */, NULL /* fspath already set */, 1 /* visible */ );
459 // if a override icon exists, cache it up
460 cache_icon ( disco, pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_width", 50 ),
461 pnd_conf_get_as_int_d ( g_conf, "grid.icon_max_height", 50 ) );
476 static int catname_cmp ( const void *p1, const void *p2 ) {
477 //mm_category_t *c1 = (mm_category_t*) p1;
478 //mm_category_t *c2 = (mm_category_t*) p2;
479 mm_category_t *c1 = *( (mm_category_t**) p1 );
480 mm_category_t *c2 = *( (mm_category_t**) p2 );
482 if ( ( isalnum ( c1 -> catname [ 0 ] ) ) && ( ! isalnum ( c1 -> catname [ 1 ] ) ) ) {
484 } else if ( ( ! isalnum ( c1 -> catname [ 0 ] ) ) && ( isalnum ( c1 -> catname [ 1 ] ) ) ) {
486 } else if ( ( ! isalnum ( c1 -> catname [ 0 ] ) ) && ( ! isalnum ( c1 -> catname [ 1 ] ) ) ) {
490 int i = strcasecmp ( c1 -> catname, c2 -> catname );
491 //printf ( "cat name compare %p %s to %p %s = %d\n", p1, c1 -> catname, p2, c2 -> catname, i );
496 void category_sort ( void ) {
497 // we probably don't want to sort tab categories, since the user may have specified an ordering
498 // But we can sort invisi-cats, to make them easier to find, and ordered by parent category
501 qsort ( _categories_invis, _categories_inviscount, sizeof(mm_category_t), catname_cmp );
505 qsort ( g_categories, g_categorycount, sizeof(mm_category_t*), catname_cmp );
511 void category_publish ( unsigned int filter_mask, char *param ) {
512 unsigned char interested;
514 // clear published categories
515 memset ( g_categories, '\0', sizeof(mm_category_t*) * MAX_CATS );
518 // figure out the start
519 mm_category_t *iter = pnd_box_get_head ( m_categories );
521 // for each category we know...
526 // is this category desired?
527 if ( filter_mask == CFALL ) {
529 } else if ( iter -> catflags == filter_mask ) {
534 // set us up the bomb; notice that we're just duplicating the pointers, not making
535 // any new data here; none of this should ever be free'd!
536 g_categories [ g_categorycount ] = iter;
541 iter = pnd_box_get_next ( iter );
547 for ( i = 0; i < g_categorycount; i++ ) {
548 printf ( "Unsorted cat %d %p: %s\n", i, &(g_categories [ i ]), g_categories [ i ] -> catname );
552 // sort published categories
558 unsigned int category_count ( unsigned int filter_mask ) {
559 mm_category_t *iter = pnd_box_get_head ( m_categories );
560 unsigned int count = 0;
562 // for each category we know...
565 // is this category desired?
566 if ( iter -> catflags == filter_mask ) {
571 iter = pnd_box_get_next ( iter );
577 int category_index ( char *catname ) {
580 for ( i = 0; i < g_categorycount; i++ ) {
582 if ( strcasecmp ( g_categories [ i ] -> catname, catname ) == 0 ) {