--- /dev/null
+/*
+ menu.c
+
+ Copyright (C) 2010-2019 Amf
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <time.h>
+#include <string.h>
+#include <libintl.h>
+#include <locale.h>
+
+#include "chroma.h"
+#include "menu.h"
+#include "level.h"
+#include "util.h"
+#include "xmlparser.h"
+
+int menu_levelentries(struct menu* pmenu, char *directory, int flags);
+void level_play(struct level* plevelgame);
+
+extern struct level* plevelcurrent;
+
+extern int options_debug;
+#ifdef XOR_COMPATIBILITY
+extern int options_xor_options;
+#endif
+#ifdef ENIGMA_COMPATIBILITY
+extern int options_enigma_options;
+#endif
+
+struct menu *menu_new(char *title)
+{
+ struct menu* pmenu;
+
+ pmenu = (struct menu*)malloc(sizeof(struct menu));
+
+ if(pmenu == NULL)
+ fatal(gettext("Out of memory in menu_new()"));
+
+ pmenu->title = (char *)malloc(strlen(title) + 1);
+
+ if(pmenu->title == NULL)
+ fatal(gettext("Out of memory in menu_new()"));
+
+ strcpy(pmenu->title, title);
+
+ pmenu->entry_first = NULL;
+ pmenu->entry_last = NULL;
+ pmenu->entry_selected = NULL;
+ pmenu->display_first = NULL;
+ pmenu->display_last = NULL;
+ pmenu->offset = 0;
+ pmenu->redraw = MENUREDRAW_ALL;
+ pmenu->logo = 0;
+
+ return pmenu;
+}
+
+void menu_delete(struct menu *pmenu)
+{
+ struct menuentry *pentry;
+ struct menuentry *pentrytmp;
+
+ pentry = pmenu->entry_first;
+
+ while(pentry != NULL)
+ {
+ pentrytmp = pentry;
+ pentry = pentry->next;
+
+ if(pentrytmp->text != NULL)
+ free(pentrytmp->text);
+ if(pentrytmp->text2 != NULL)
+ free(pentrytmp->text2);
+ if(pentrytmp->text3 != NULL)
+ free(pentrytmp->text3);
+ if(pentrytmp->text4 != NULL)
+ free(pentrytmp->text4);
+ if(pentrytmp->value != NULL)
+ free(pentrytmp->value);
+
+ free(pentrytmp);
+ }
+
+ if(pmenu->title != NULL)
+ free(pmenu->title);
+
+ free(pmenu);
+}
+
+void menu_unsort(struct menu *pmenu)
+{
+ struct menuentry* pentry;
+
+ if(pmenu == NULL)
+ return;
+
+ pentry = pmenu->entry_first;
+ while(pentry != NULL)
+ {
+ pentry->flags &= ~(MENU_SORT | MENU_TOPSORT);
+ pentry = pentry->next;
+ }
+}
+
+void menu_assignletters(struct menu *pmenu)
+{
+ struct menuentry* pentry;
+ struct menuentry* pentry_before;
+ char c;
+
+ if(pmenu == NULL)
+ return;
+
+ c = '1';
+
+ pentry = pmenu->entry_first;
+ while(pentry != NULL)
+ {
+ if(pentry->key == 0 && !(pentry->flags & (MENU_GREY | MENU_NOTE | MENU_SPACE)))
+ {
+ pentry_before = pmenu->entry_first;
+ while(pentry_before != NULL && pentry_before != pentry)
+ {
+ if(pentry_before->key == c)
+ {
+ c ++;
+
+ /* Valid keys are 1-9 A-P R-Z. Q is deliberately omitted. */
+ if(c == '9' + 1)
+ c = 'A';
+ if(c == 'Q')
+ c ++;
+ if(c == 'Z' + 1)
+ return;
+
+ pentry_before = pmenu->entry_first;
+ }
+ else
+ pentry_before = pentry_before ->next;
+ }
+ pentry->key = c;
+ }
+ pentry = pentry->next;
+ }
+}
+
+struct menuentry* menuentry_new(struct menu *pmenu, char *text, char key, int flags)
+{
+ return menuentry_newwithvalue(pmenu, text, key, flags, NULL);
+}
+
+struct menuentry* menuentry_newwithvalue(struct menu *pmenu, char *text, char key, int flags, char *value)
+{
+ struct menuentry* pentry;
+ struct menuentry* pentry_before;
+
+ pentry = (struct menuentry*)malloc(sizeof(struct menuentry));
+
+ if(pentry == NULL)
+ fatal(gettext("Out of memory in menuentry_newwithvalue()"));
+
+ if(flags & MENU_SORT)
+ {
+ pentry_before = pmenu->entry_first;
+ while(pentry_before != NULL)
+ {
+ if((pentry_before->flags & MENU_SORT) && (!(pentry_before->flags & MENU_TOPSORT)) && pentry_before->value != NULL)
+ {
+ if(strcmp(pentry_before->value, value) > 0)
+ break;
+ }
+ pentry_before = pentry_before->next;
+ }
+ }
+ else if(flags & MENU_TOPSORT)
+ {
+ pentry_before = pmenu->entry_first;
+ while(pentry_before != NULL)
+ {
+ if((pentry_before->flags & MENU_TOPSORT) && pentry_before->value != NULL)
+ {
+ if(strcmp(pentry_before->value, value) > 0)
+ break;
+ }
+
+ if(pentry_before->flags & MENU_SORT && !(pentry_before->flags & MENU_TOPSORT))
+ break;
+
+ pentry_before = pentry_before->next;
+ }
+ }
+ else
+ pentry_before = NULL;
+
+ /* If pentry_before is NULL, we add to the bottom of the list.
+ Otherwise, we add before pentry_before.
+ */
+ if(pentry_before == NULL)
+ {
+ if(pmenu->entry_first == NULL)
+ pmenu->entry_first = pentry;
+
+ pentry->previous = pmenu->entry_last;
+ pentry->next = NULL;
+
+ if(pmenu->entry_last != NULL)
+ pmenu->entry_last->next = pentry;
+
+ pmenu->entry_last = pentry;
+ }
+ else
+ {
+ if(pentry_before == pmenu->entry_first)
+ pmenu->entry_first = pentry;
+ pentry->previous = pentry_before->previous;
+ pentry->next = pentry_before;
+ if(pentry_before->previous != NULL)
+ pentry_before->previous->next = pentry;
+ pentry_before->previous = pentry;
+ }
+
+ pentry->text = (char *)malloc(strlen(text) + 1);
+
+ if(pentry->text == NULL)
+ fatal(gettext("Out of memory in menuentry_newwithvalue()"));
+
+ strcpy(pentry->text, text);
+
+ pentry->redraw = 0;
+
+ pentry->flags = flags;
+
+ pentry->key = key;
+
+ pentry->value = NULL;
+ if(value != NULL)
+ {
+ pentry->value = (char *)malloc(strlen(value) + 1);
+
+ if(pentry->value == NULL)
+ fatal(gettext("Out of memory in menuentry_newwithvalue()"));
+
+ strcpy(pentry->value, value);
+ }
+
+ pentry->text2 = NULL;
+ pentry->text3 = NULL;
+ pentry->text4 = NULL;
+
+ return pentry;
+}
+
+void menuentry_value(struct menuentry* pentry, char *value)
+{
+ if(pentry->value != NULL)
+ free(pentry->value);
+
+ pentry->value = (char *)malloc(strlen(value) + 1);
+
+ if(pentry->value == NULL)
+ fatal(gettext("Out of memory in menuentry_value()"));
+
+ strcpy(pentry->value, value);
+}
+
+void menuentry_text(struct menuentry* pentry, char *text)
+{
+ if(pentry->text != NULL)
+ free(pentry->text);
+
+ pentry->text = (char *)malloc(strlen(text) + 1);
+
+ if(pentry->text == NULL)
+ fatal(gettext("Out of memory in menuentry_text()"));
+
+ strcpy(pentry->text, text);
+}
+
+void menuentry_extratext(struct menuentry* pentry, char *text2, char *text3, char *text4)
+{
+ if(pentry->text2 != NULL)
+ free(pentry->text2);
+ if(pentry->text3 != NULL)
+ free(pentry->text3);
+ if(pentry->text4 != NULL)
+ free(pentry->text4);
+
+ if(text2 != NULL)
+ {
+ pentry->text2 = (char *)malloc(strlen(text2) + 1);
+ if(pentry->text2 == NULL)
+ fatal(gettext("Out of memory in menuentry_extratext()"));
+
+ strcpy(pentry->text2, text2);
+ }
+ else
+ pentry->text2 = NULL;
+
+ if(text3 != NULL)
+ {
+ pentry->text3 = (char *)malloc(strlen(text3) + 1);
+ if(pentry->text3 == NULL)
+ fatal(gettext("Out of memory in menuentry_extratext()"));
+
+ strcpy(pentry->text3, text3);
+ }
+ else
+ pentry->text3 = NULL;
+
+ if(text4 != NULL)
+ {
+ pentry->text4 = (char *)malloc(strlen(text4) + 1);
+ if(pentry->text4 == NULL)
+ fatal(gettext("Out of memory in menuentry_extratext()"));
+
+ strcpy(pentry->text4, text4);
+ }
+ else
+ pentry->text4 = NULL;
+}
+
+void menuentry_delete(struct menu* pmenu, struct menuentry* pentry)
+{
+ struct menuentry* pentry_replace;
+
+ pentry_replace = pentry->next;
+ if(pentry_replace == NULL)
+ pentry_replace = pentry->previous;
+
+ if(pmenu->entry_first == pentry)
+ pmenu->entry_first = pentry_replace;
+ if(pmenu->display_first == pentry)
+ pmenu->display_first = pentry_replace;
+ if(pmenu->entry_last == pentry)
+ pmenu->entry_last = pentry_replace;
+ if(pmenu->entry_selected == pentry)
+ pmenu->entry_selected = pentry_replace;
+ if(pentry->previous != NULL)
+ pentry->previous->next = pentry->next;
+ if(pentry->next != NULL)
+ pentry->next->previous = pentry->previous;
+
+ if(pentry->text != NULL)
+ free(pentry->text);
+ if(pentry->text2 != NULL)
+ free(pentry->text2);
+ if(pentry->text3 != NULL)
+ free(pentry->text3);
+ if(pentry->text4 != NULL)
+ free(pentry->text4);
+ if(pentry->value != NULL)
+ free(pentry->value);
+
+ free(pentry);
+}
+
+int menu_levelselector(char *directory_levels, char *chosen, char *title, int flags)
+{
+ struct menu* pmenu;
+ struct level* plevel;
+ int flags_child;
+ int result;
+ char directory[FILENAME_MAX];
+
+ pmenu = menu_new(title);
+
+ if(flags & LEVELMENU_RETURN)
+ menuentry_new(pmenu, gettext("Return to previous menu"), 'Q', 0);
+
+ if(flags & LEVELMENU_NEW)
+ menuentry_new(pmenu, gettext("Save as new position"), 'S', 0);
+
+ if(flags & LEVELMENU_CREATE)
+ menuentry_new(pmenu, gettext("Create new level"), 'C', 0);
+
+ if(flags & LEVELMENU_IMPORT)
+ {
+ getfilename("", directory, 0, LOCATION_DOCUMENTS);
+ if(isdirectory(directory))
+ menuentry_newwithvalue(pmenu, gettext("Import a position"), 'I', 0, directory);
+ }
+
+ if(flags & LEVELMENU_SAVED)
+ {
+ getfilename("saved", directory, 0, LOCATION_LOCAL);
+ if(isdirectory(directory))
+ menuentry_newwithvalue(pmenu, gettext("Saved Positions"), 'S', MENU_BOLD, directory);
+ }
+
+ if(flags & LEVELMENU_SOLVED)
+ {
+ getfilename("solved", directory, 0, LOCATION_LOCAL);
+ if(isdirectory(directory))
+ menuentry_newwithvalue(pmenu, gettext("Solved Positions"), 'O', MENU_BOLD, directory);
+ }
+
+ if(flags & LEVELMENU_MAIN)
+ {
+ getfilename("construct", directory, 0, LOCATION_LOCAL);
+ if(isdirectory(directory))
+ menuentry_newwithvalue(pmenu, gettext("Levels under Construction"), 'C', MENU_BOLD, directory);
+ }
+
+ /* Separator only if needed */
+ if(pmenu->entry_first != NULL)
+ menuentry_new(pmenu, "", 0, MENU_TOPSORT | MENU_SPACE);
+
+ if(flags & LEVELMENU_DELETE)
+ menuentry_new(pmenu, gettext("[DELETE] to delete a position"), 0, MENU_NOTE | MENU_CENTRE);
+
+ if(flags & LEVELMENU_MAIN)
+ {
+ getfilename("levels", directory, 0, LOCATION_SYSTEM);
+ if(menu_levelentries(pmenu, directory, flags))
+ menuentry_newwithvalue(pmenu, "", 0, MENU_SORT | MENU_SPACE, "");
+
+ menu_unsort(pmenu);
+
+ /* Separator only if needed */
+ if(pmenu->entry_last != NULL && !(pmenu->entry_last->flags & MENU_SPACE))
+ menuentry_newwithvalue(pmenu, "", 0, MENU_SPACE, "");
+
+ getfilename("levels", directory, 0, LOCATION_LOCAL);
+ if(menu_levelentries(pmenu, directory, flags))
+ menuentry_newwithvalue(pmenu, "", 0, MENU_SORT | MENU_SPACE, "");
+ }
+ else
+ {
+ if(menu_levelentries(pmenu, directory_levels, flags))
+ menuentry_newwithvalue(pmenu, "", 0, MENU_SORT | MENU_SPACE, "");
+ }
+
+ menu_assignletters(pmenu);
+
+ while(1)
+ {
+ result = menu_process(pmenu);
+
+ if(result == MENU_QUIT)
+ {
+ if(chosen != NULL)
+ strcpy(chosen, "");
+ break;
+ }
+
+ if(result == MENU_SELECT)
+ {
+ if(pmenu->entry_selected->key == '+' && flags & LEVELMENU_FILTER)
+ {
+ result = menu_levelselector(directory_levels, chosen, title, flags & ~LEVELMENU_FILTER);
+ if(result == MENU_SELECT)
+ break;
+ }
+ else if(pmenu->entry_selected->value != NULL)
+ {
+ if(isfile(pmenu->entry_selected->value))
+ {
+ if(flags & LEVELMENU_GAME)
+ {
+ plevel = level_load(pmenu->entry_selected->value, 0);
+ if(plevel != NULL)
+ level_play(plevel);
+ /* plevel is deleted by level_play */
+ }
+ else
+ {
+ if(chosen != NULL)
+ strcpy(chosen, pmenu->entry_selected->value);
+ break;
+ }
+ }
+ else if(isdirectory(pmenu->entry_selected->value))
+ {
+ flags_child = flags & (LEVELMENU_NEW | LEVELMENU_DELETE | LEVELMENU_FILENAMES | LEVELMENU_MOVES | LEVELMENU_GAME | LEVELMENU_FILTER);
+ flags_child |= LEVELMENU_RETURN;
+
+ /* Fix flags for "saved", "solved" and "construct" */
+ if(pmenu->entry_selected->key == 'S')
+ flags_child |= LEVELMENU_MOVES | LEVELMENU_DELETE;
+ if(pmenu->entry_selected->key == 'C')
+ flags_child |= LEVELMENU_MOVES | LEVELMENU_DELETE;
+ if(pmenu->entry_selected->key == 'O')
+ flags_child |= LEVELMENU_MOVES | LEVELMENU_DELETE;
+
+ result = menu_levelselector(pmenu->entry_selected->value, chosen, pmenu->entry_selected->text, flags_child);
+
+ if(result == MENU_SELECT)
+ break;
+
+ result = MENU_NULL;
+ }
+ }
+ else
+ {
+ if(chosen != NULL)
+ strcpy(chosen, "");
+
+ if(pmenu->entry_selected->key == 'Q')
+ result = MENU_QUIT;
+
+ break;
+ }
+ }
+
+ if(result == MENU_DELETE)
+ {
+ if(pmenu->entry_selected->value != NULL)
+ unlink(pmenu->entry_selected->value);
+ menuentry_delete(pmenu, pmenu->entry_selected);
+ }
+ }
+
+ menu_delete(pmenu);
+
+ return result;
+}
+
+int menu_levelentries(struct menu* pmenu, char *directory, int flags)
+{
+ DIR *pdir;
+ struct dirent *dentry;
+ struct menuentry* pentry;
+ struct level* plevel;
+ struct stat filestat;
+ int flags_child;
+ int submenus;
+ int subfiles;
+ int state;
+ int hidden;
+ int filtered;
+
+ char text_date[256];
+ char text_moves[256];
+ char text_stars[256];
+ char *text_title;
+ char *text_subtitle;
+
+ char filename[FILENAME_MAX];
+ char titlefilename[FILENAME_MAX];
+
+ struct parser* pparser;
+
+ submenus = 0;
+ subfiles = 0;
+ filtered = 0;
+
+ pdir = opendir(directory);
+
+ if(pdir == NULL)
+ return 0;
+
+ while((dentry = readdir(pdir)) != NULL)
+ {
+ if(strcmp(dentry->d_name, ".") == 0)
+ continue;
+ if(strcmp(dentry->d_name, "..") == 0)
+ continue;
+
+ if(dentry->d_name[0] == '.')
+ continue;
+
+ sprintf(filename, "%s%s%s", directory, "/", dentry->d_name);
+
+ if(isfile(filename) && strlen(filename) > 7 && strcmp(filename + strlen(filename) - 7, ".chroma") == 0)
+ {
+ plevel = level_load(filename, 1);
+
+ if(plevel != NULL)
+ {
+ flags_child = MENU_SORT;
+ if(flags & (LEVELMENU_MOVES | LEVELMENU_FILENAMES))
+ flags_child |= MENU_DOUBLE;
+ if(flags & LEVELMENU_DELETE)
+ flags_child |= MENU_DELETABLE;
+
+ if(plevel->title == NULL || strcmp(plevel->title, "") == 0)
+ pentry = menuentry_newwithvalue(pmenu, gettext("[untitled level]"), 0, flags_child, filename);
+ else
+ {
+ if(strncmp(plevel->title, "chroma", 6) == 0)
+ pentry = menuentry_newwithvalue(pmenu, gettext(plevel->title), 0, flags_child, filename);
+ else
+ pentry = menuentry_newwithvalue(pmenu, plevel->title, 0, flags_child, filename);
+ }
+
+ if(plevel->stars_exploded)
+ sprintf(text_stars, gettext("%d lost"), plevel->stars_exploded);
+ else
+ sprintf(text_stars, "%d / %d", plevel->stars_caught, plevel->stars_total);
+ if(plevel->flags & LEVELFLAG_SOLVED && !(plevel->flags & LEVELFLAG_FAILED))
+ sprintf(text_stars, gettext("solved"));
+
+ if(plevel->flags & LEVELFLAG_FAILED)
+ sprintf(text_moves, gettext("failed"));
+ else
+ sprintf(text_moves, gettext("%d moves"), plevel->moves);
+
+ if(!stat(filename, &filestat))
+ {
+ sprintf(text_date, "%s", ctime(&filestat.st_mtime));
+ if(strlen(text_date) > 0)
+ text_date[strlen(text_date) - 1] = 0;
+ }
+ else
+ strcpy(text_date, "");
+
+ if(flags & LEVELMENU_FILENAMES)
+ menuentry_extratext(pentry, NULL, text_date, dentry->d_name);
+ else if(flags & LEVELMENU_MOVES)
+ menuentry_extratext(pentry, text_stars, text_date, text_moves);
+ else
+ {
+ /* Not really needed except for development */
+ if(plevel->flags & LEVELFLAG_SOLVED && !(plevel->flags & LEVELFLAG_FAILED))
+ menuentry_extratext(pentry, gettext("solved"), NULL, NULL);
+ }
+
+ if((flags & LEVELMENU_FILTER) && plevelcurrent != NULL)
+ {
+ if((plevelcurrent->title != NULL && strcmp(plevelcurrent->title, pentry->text) != 0)
+ || (plevelcurrent->title == NULL && plevel->title != NULL))
+ {
+ filtered ++;
+ menuentry_delete(pmenu, pentry);
+ continue;
+ }
+ }
+
+#ifdef XOR_COMPATIBILITY
+ if(plevel->mode == MODE_XOR)
+ options_xor_options = 1;
+#endif
+#ifdef ENIGMA_COMPATIBILITY
+ if(plevel->mode == MODE_ENIGMA)
+ options_enigma_options = 1;
+#endif
+ subfiles ++;
+ }
+
+ level_delete(plevel);
+ }
+ else if(isdirectory(filename))
+ {
+ flags_child = MENU_TOPSORT | MENU_BOLD;
+ if(flags & (LEVELMENU_MOVES | LEVELMENU_FILENAMES))
+ flags_child |= MENU_DOUBLE;
+
+ /* Read the title information from set.chroma, if it exists */
+ snprintf(titlefilename, FILENAME_MAX, "%s/%s", filename, "set.chroma");
+ text_title = NULL;
+ text_subtitle = NULL;
+
+ hidden = 0;
+
+ pparser = parser_new(titlefilename);
+
+ enum {
+ LEVELSETPARSER_END,
+ LEVELSETPARSER_OUTSIDE,
+ LEVELSETPARSER_CHROMA
+ };
+
+ state = LEVELSETPARSER_OUTSIDE;
+
+ while(state != LEVELSETPARSER_END)
+ {
+ switch(parser_parse(pparser))
+ {
+ case PARSER_END:
+ state = LEVELSETPARSER_END;
+ break;
+
+ case PARSER_ELEMENT_START:
+ break;
+
+ case PARSER_ELEMENT_END:
+ switch(state)
+ {
+ case LEVELSETPARSER_CHROMA:
+ /* We only read the file's header here */
+ if(parser_match(pparser, 0, "head"))
+ state = LEVELSETPARSER_END;
+ break;
+ }
+ break;
+
+ case PARSER_CONTENT:
+ switch(state)
+ {
+ case LEVELSETPARSER_CHROMA:
+ if(parser_match(pparser, 1, "title"))
+ {
+ text_title = malloc(strlen(parser_text(pparser, 0)) + 1);
+ if(text_title == NULL)
+ fatal(gettext("Out of memory in menu_levelentries()"));
+ strcpy(text_title, parser_text(pparser, 0));
+ }
+ if(parser_match(pparser, 1, "subtitle"))
+ {
+ text_subtitle = malloc(strlen(parser_text(pparser, 0)) + 1);
+ if(text_title == NULL)
+ fatal(gettext("Out of memory in menu_levelentries()"));
+ strcpy(text_subtitle, parser_text(pparser, 0));
+ }
+ break;
+ }
+ break;
+
+ case PARSER_ATTRIBUTE:
+ switch(state)
+ {
+ case LEVELSETPARSER_OUTSIDE:
+ if(parser_match(pparser, 2, "chroma") && parser_match(pparser, 1, "type"))
+ {
+ if(parser_match(pparser, 0, "set"))
+ state = LEVELSETPARSER_CHROMA;
+ }
+ break;
+
+ case LEVELSETPARSER_CHROMA:
+ if(parser_match(pparser, 2, "chroma") && parser_match(pparser, 1, "hidden"))
+ {
+ if(parser_match(pparser, 0, "yes"))
+ hidden = 1;
+ }
+ break;
+ }
+ break;
+
+ case PARSER_ERROR:
+ state = LEVELSETPARSER_END;
+ break;
+ }
+ }
+
+ parser_delete(pparser);
+
+ if(!hidden || options_debug & DEBUG_HIDDEN)
+ {
+ if(text_title != NULL)
+ {
+ if(strncmp(text_title, "chroma", 6) == 0)
+ pentry = menuentry_newwithvalue(pmenu, gettext(text_title), 0, flags_child | (text_subtitle != NULL ? MENU_DOUBLE : 0), filename);
+ else
+ pentry = menuentry_newwithvalue(pmenu, text_title, 0, flags_child | (text_subtitle != NULL ? MENU_DOUBLE : 0), filename);
+
+ }
+ else
+ pentry = menuentry_newwithvalue(pmenu, dentry->d_name, 0, flags_child, filename);
+
+ if(flags & LEVELMENU_FILENAMES)
+ menuentry_extratext(pentry, NULL, NULL, dentry->d_name);
+ else
+ {
+ if(text_title != NULL && strncmp(text_title, "chroma", 6) == 0)
+ menuentry_extratext(pentry, NULL, NULL, gettext(text_subtitle));
+ else
+ menuentry_extratext(pentry, NULL, NULL, text_subtitle);
+ }
+ if(text_title != NULL)
+ free(text_title);
+ if(text_subtitle != NULL)
+ free(text_subtitle);
+
+ submenus ++;
+ }
+ }
+ }
+
+ closedir(pdir);
+
+ if(filtered != 0)
+ {
+ if(submenus != 0 || subfiles != 0)
+ menuentry_new(pmenu, "", 0, MENU_SPACE);
+ pentry = menuentry_new(pmenu, gettext("Show positions for other levels"), '+', 0);
+ sprintf(text_date, filtered == 1 ? gettext("(%d other)") : gettext("(%d others)"), filtered);
+ menuentry_extratext(pentry, text_date, NULL, NULL);
+ }
+
+ if(submenus !=0 && subfiles != 0)
+ return 1;
+ else
+ return 0;
+
+}
+
~sgtatham / chroma-debian.git / blobdiff