easydoneitCTui

edCore.c (135248B)

---

 #include "libsheepyObject.h"
 #include "shpPackages/ini/src/ini.h"
 #include "edCore.h"
 
 /** @package edi_core
  *  Core module
  */
 
 /** user_interface is initialized in start() and changes the behavior of some functions to allow a functional user interface design. The default is not used, start() is always called before using edi_core.
  * Values: 'cli', 'web'
  */
 static char *user_interface       = NULL;
 
 /** path to easydoneit.ini
  * used in edi desktop
  */
 static char *inipath = NULL;
 smallDictt *ini      = NULL;
 
 char *data_location               = NULL;
 static char *data_location_tasks  = NULL;
 static char *data_location_groups = NULL;
 static char *data_location_tree   = NULL;
 
 char *saved_data_location         = NULL;
 
 /** Available databases */
 static smallArrayt *databases     = NULL;
 
 /** list selected databases */
 static smallDictt *selected_d     = NULL;
 smallArrayt *selected             = NULL;
 static smallArrayt *selected_path = NULL;
 /** default database where tasks are created */
 static char *default_add_in       = NULL;
 
 /** add new tasks in 'bottom' of group or 'top' of group */
 char *add_top_or_bottom           = NULL;
 
 /** Autlink groups (array of tids) */
 static smallArrayt *autolink      = NULL;
 
 /** list of groups for edi ls -L, -La and -Lx (array of tids) */
 static smallArrayt *list_of_groups = NULL;
 
 /** characters for task ids */
 #define ID_BASE_DF ",0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
 static char *ID_BASE              = ID_BASE_DF;
 static char *ID_BASE_STRING       = ID_BASE_DF;
 /** Length of order id in groups */
 #define ORDER_ID_LENGTH 8
 size_t BASE                       = sizeof(ID_BASE_DF)-1;
 
 char *TASK_STATUS[]               = {"  Active",
                                      "    Done",
                                      " Ongoing",
                                      " Pending",
                                      "Inactive",
                                      "    Void",
                                      NULL};
 char **TASK_STATUS_TRIM           = NULL;
 
 /** Sort order for sort_task_attributes function, ongoing, active, pending, done, inactive, void */
 static u8 SORT_TASK_ORDER[]       = {2,0,3,1,4,5};
 
 /* TODO remove unused - static char *LIST_OPTIONS[]       = {"tids", */
 /*                                      "positions", */
 /*                                      "html"}; */
 static char *list_option          =  "tids";
 
 char *STATUS_FILTER_STATES[]      = {"enable","disable"};
 
 /** enables all status filters */
 smallArrayt *status_filters = NULL;
 
 /** status filter dictionary, initialized after loading ini file */
 smallDictt *status_filters_d= NULL;
 
 /** colors (default) */
 //static i16 no_color[4]            = {-1,-1,-1,255};
 //static i16 status_fgColors[6][4]  = {{0,0,0,255},{0,255,0,255},{255,128,0,255},{255,0,0,255},{192,192,192,255},{0,0,0,255}};
 static smallArrayt *no_color         = NULL;
 static smallArrayt *status_fgColors  = NULL;
 static smallDictt *status_fgColors_d = NULL;
 /** no background color by default */
 //static i16 status_bgColors[6][4]  = {{-1,-1,-1,255}};
 static smallArrayt *status_bgColors  = NULL;
 static smallDictt *status_bgColors_d = NULL;
 
 /** text editor in terminal - easydoneit.ini [settings] EDITOR */
 static char *editor               = "vi";
 
 /** Agenda generated by edi.in_cli */
 static smallArrayt *agenda        = NULL;
 
 /** user name */
 static char *user                 = NULL;
 
 /** user email */
 static char *email                = NULL;
 
 /** bookmarks */
 smallArrayt *bookmarks            = NULL;
 
 /** stats for statistics function */
 static smallDictt *stats          = NULL;
 
 /** total number of tasks for statistics function */
 static u64 stats_total            = 0;
 
 /** creation dates of tasks in statistics, used to find out oldest task */
 static smallArrayt *stats_creation_dates = NULL;
 
 /** timely state changes and creation dates
  * Type: dict of dict of integers
  * keys are dates
  * each dates is a dictionary with STATS_OVERTIME_KEYS keys
  * each key is the amount for states and creation
  */
 static smallDictt *stats_overtime = NULL;
 
 /** timely state changes and creation dates */
 //STATS_OVERTIME_KEYS  = [TASK_STATUS[i] for i in range(len(TASK_STATUS))] + ['Creation']
 
 /* Group directory, cache result to speed up color functions */
 static smallArrayt *group_directory_file_list = NULL;
 
 
 
 static char *html_header = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n\
 <html>\n\
   <head>\n\
     <meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\">\n\
     <title>Tasks</title>\n\
     <style type=\"text/css\">\n\
       .subject {text-align: left}\n\
       .plannedStartDateTime {text-align: right}\n\
       .priority {text-align: right}\n\
       .inactive {color: #5E5E5E}\n\
       .late {color: #A020F0}\n\
       .active {color: #000000}\n\
       .duesoon {color: #FF8000}\n\
       .overdue {color: #FF0000}\n\
       .completed {color: #037700}\n\
 \n\
       body {\n\
           color: #333;\n\
           background-color: white;\n\
           font: 11px verdana, arial, helvetica, sans-serif;\n\
       }\n\
 \n\
       /* Styles for the title and table caption */\n\
       h1, caption {\n\
           text-align: center;\n\
           font-size: 18px;\n\
           font-weight: 900;\n\
           color: #778;\n\
       }\n\
 \n\
       /* Styles for the whole table */\n\
       #table {\n\
           border-collapse: collapse;\n\
           border: 2px solid #ebedff;\n\
           margin: 10px;\n\
           padding: 0;\n\
       }\n\
 \n\
       /* Styles for the header row */\n\
       .header {\n\
           font: bold 12px/14px verdana, arial, helvetica, sans-serif;\n\
           color: #07a;\n\
           background-color: #ebedff;\n\
       }\n\
 \n\
       /* Mark the column that is sorted on */\n\
       #sorted {\n\
           text-decoration: underline;\n\
       }\n\
 \n\
       /* Styles for a specific column */\n\
       .subject {\n\
           font-weight: bold;\n\
       }\n\
 \n\
       /* Styles for regular table cells */\n\
       td {\n\
           padding: 5px;\n\
           border: 2px solid #ebedff;\n\
       }\n\
 \n\
       /* Styles for table header cells */\n\
       th {\n\
           padding: 5px;\n\
           border: 2px solid #ebedff;\n\
       }\n\
 \n\
     </style>\n\
   </head>\n\
   <body>\n\
   <h1>Tasks</h1>\n\
     <table border=\"1\" id=\"table\">\n\
       <thead>\n\
         <tr class=\"header\">\n\
           <th class=\"subject\" scope=\"col\">Subject</th>\n\
           <th class=\"description\" scope=\"col\">Description</th>\n\
         </tr>\n\
       </thead>\n\
       <tbody>";
 
 static char *html_footer = "      </tbody>\n\
     </table>\n\
   </body>\n\
 </html>";
 
 
 
 
 
 ////////////
 // MACROS
 ////////////
 
 /**
  * generate task path in var
  * tid is the task identity, should be declared in the context
  */
 #define genTaskPath(var, path)\
 	sprintf(var, "%s/" path, generate_task_path(tid));
 
 /**
  * declare var and generate path in easydoneit database
  * var is a local string
  * path is literal string representing a path in the task: "fgColor"
  */
 #define createTaskPath(var, path)\
 	char var[8192];\
 	genTaskPath(var, path)
 
 ////////////
 // MACROS END
 ////////////
 
 
 
 
 // git support
 void keepDir(char *path) {
 	FILE *f;
 	f = fopen(path, "w");
 	free(path);
 	fclose(f);
 }
 
 int mkdirFree(char *path) {
 	int r;
 	r = mkdirParents(path);
 	free(path);
 	return r;
 }
 
 int copyFree(char *s, char *d) {
 	int r;
 	r = copy(s, d);
 	freeManyS(s,d);
 	return r;
 }
 
 /** initializes path to data.
  * creates directories<br>
  * creates root group and task<br>
  * @ingroup EDI_CORE
  */
 void init(void) {
 	// Set global variables
 	smallArrayt *ts = allocG(rtSmallArrayt);
 	fromArrayG(ts, TASK_STATUS, 0);
 
 	status_filters_d     = allocG(rtSmallDictt);
 	zipG(status_filters_d, ts, status_filters);
 	//logVarG(status_filters_d);
 	status_fgColors_d    = allocG(rtSmallDictt);
 	zipG(status_fgColors_d, ts, status_fgColors);
 	//logVarG(status_fgColors_d);
 	status_bgColors_d    = allocG(rtSmallDictt);
 	zipG(status_bgColors_d, ts, status_bgColors);
 	//logVarG(status_bgColors_d);
 	terminateG(ts);
 
 	data_location_tasks  = appendG(data_location, "/tasks");
 	data_location_groups = appendG(data_location, "/groups");
 	data_location_tree   = appendG(data_location, "/tree");
 
 	if (not fileExistsG(data_location_tasks)) {
 		mkdirParentsG(data_location_tasks);
 		mkdirParentsG(data_location_groups);
 		mkdirParentsG(data_location_tree);
 		// git support
 		keepDir(appendG(data_location_tree, "/.keepDir"));
 		mkdirFree(appendG(data_location_groups, "/root"));
 
 		// Create root description in tasks
 		char *task_path = appendG(data_location_tasks, "/root");
 		mkdirParentsG(task_path);
 		// copy root description from script directory
 		char *d = shDirname(getProgPath());
 		copyFree(appendG(d, "/root.txt"), appendG(task_path, "/description.txt"));
 		free(d);
 
 		// Create status
 		char **l = NULL;
 		pushG(&l, TASK_STATUS[TASK_STATUS_VOID]);
 		char *tmp =  appendG(task_path, "/status");
 		writeFileG(l, tmp);
 		freeG(l);
 		free(task_path);
 	}
 
 	// git support - when a new database is created, the group folder is empty and not saved in git
 	// create the group folder when the database is a cloned git with missing group folder
 	if (not fileExistsG(data_location_groups)) {
 		mkdirParentsG(data_location_groups);
 	}
 	if (not fileExistsG(data_location_tree)) {
 		mkdirParentsG(data_location_tree);
 	}
 }
 
 /** log actions in database - data_location/log.txt
  * @param[in] s string without user name and timestamp
  * @ingroup EDI_CORE
  */
 void edi_log(const char *s) {
 	char *fn = appendG(data_location, "/log.txt");
 	FILE *f = fopen(fn, "a");
 	if (!f) {
 		goto retn;
 	}
 
 	char *sT = trimG(s);
 	// get current time
 	char *t  = timeToS(time(0));
 	fprintf(f, "%s - %s <%s> - %s\n", t, user, email, sT);
 	freeManyS(sT, t);
 	fclose(f);
 retn:
 	free(fn);
 }
 
 /** string returned from select_database */
 static char result_select_database[8192];
 
 /** select location database
  * @param[in] location database name
  * @ingroup EDI_CORE
  */
 const char *select_database(char *location) {
 
 	if (hasG(selected_d, location)) {
 		freeManyS(data_location, data_location_tasks, data_location_groups, data_location_tree);
 		data_location        = getNDupG(selected_d, rtChar, location);
 
 		data_location_tasks  = appendG(data_location, "/tasks");
 		data_location_groups = appendG(data_location, "/groups");
 		data_location_tree   = appendG(data_location, "/tree");
 
 		if (not fileExists(data_location)) {
 			strcpy(result_select_database, data_location);
 			strcat(result_select_database, " is unreachable");
 		}
 		else {
 			result_select_database[0] = 0;
 		}
 	}
 	else {
 		strcpy(result_select_database, location);
 		strcat(result_select_database, " is not found in the configuration (.easydoneit.ini)");
 	}
 	return result_select_database;
 }
 
 /** Mix foreground colors from task, groups and default colors.
  * @return color array
  * @param[in] tid task id
  * @ingroup EDI_CORE
  * Collect all defined colors in link groups.
  * For each group, the group gets the first color defined in the tree<br>
  * compute average color
  */
 smallArrayt *mix_fgcolors(const char *tid) {
 	// mix colors
 	// collect all defined colors in groups to root
 	createAllocateSmallArray(colors);
 	createAllocateSmallArray(color);
 	// root has no parent group, dont search parent group color
 	if (not eqG(tid, "root")) {
 		// find all groups - link and parent group
 		char taskPath[8192];
 		createAllocateSmallArray(groups);
 		if (is_linked(tid)) {
 			genTaskPath(taskPath, "groups/");
 			groups = readDirG(rtSmallArrayt, taskPath);
 		}
 		else {
 			pushG(groups, (char*)find_group_containing_task(tid));
 		}
 
 		// walk parent groups until a color or root is found
 		while (lenG(groups)) {
 			enum {search, found_color};
 			int status_color = search;
 			sprintf(taskPath, "%s/fgColor", generate_task_path(getG(groups, rtChar, 0)));
 			if (fileExists(taskPath)) {
 				createAllocateSmallString(f);
 				readFileG(f, taskPath);
 				smallArrayt *c  = splitG(f, ",");
 				// convert c strings to int
 				enumerateSmallArray(c, CP, ci) {
 					castS(cp, CP);
 					setG(c, ci, parseIntG(cp));
 					finishG(cp);
 				}
 				terminateG(f);
 				// -1 means no_color, mix colors
 				if (getG(c, rtI64 ,0) != -1) {
 					pushNFreeG(colors, c);
 					status_color = found_color;
 				}
 				else {
 					// c is not a color
 					terminateG(c);
 				}
 			}
 			if (status_color == search) {
 				char *parent_group = (char *) find_group_containing_task(getG(groups, rtChar, 0));
 				if (eqG(parent_group, "error")) {
 					// break infinite loop when there is an error in the database
 					break;
 				}
 				if (not eqG(parent_group, "root")) {
 					pushG(groups, parent_group);
 				}
 			}
 			delG(groups, 0, 1);
 		}
 		terminateG(groups);
 
 		// compute average color
 		if (lenG(colors)) {
 			pushG(color, 0);pushG(color, 0);pushG(color, 0);pushG(color, 0);
 			forEachSmallArray(colors, C) {
 				cast(smallArrayt*, c, C);
 				range(i, lenG(c)) {
 					*getG(color, rtI32P, i) += getG(c, rtI32, i);
 				}
 				finishG(C);
 			}
 			size_t colorCount = lenG(colors);
 			range(i, lenG(color)) {
 				*getG(color, rtI32P, i) /= colorCount;
 			}
 		}
 	}
 	if (not lenG(colors)) {
 		// no defined colors, use default color for status
 		char *task_status = (char *)get_status(tid);
 		terminateG(color);
 		color                   = getNDupG(status_fgColors_d, rtSmallArrayt, task_status);
 	}
 	terminateG(colors);
 	return color;
 }
 
 /** get color for task tid
  * @return color array
  *# @param[in] tid task id
  * @ingroup EDI_CORE
  * when no color is set, mix colors from groups or use defaults
  */
 smallArrayt *get_forground_color(const char *tid) {
 	//color = no_color
 	smallArrayt *color = NULL;
 	createTaskPath(fgPath, "fgColor");
 
 	if (fileExists(fgPath)) {
 		createAllocateSmallArray(color);
 		createAllocateSmallString(f);
 		readFileG(f, fgPath);
 		smallArrayt *c  = splitG(f, ",");
 		// convert c strings to int
 		forEachSmallArray(c, CP) {
 			castS(cp, CP);
 			pushG(color, parseIntG(cp));
 			finishG(cp);
 		}
 		terminateManyG(f, c);
 		// -1 means no_color, mix colors
 		if (getG(color, rtI64 ,0) != -1) {
 			terminateG(color);
 			color = mix_fgcolors(tid);
 		}
 	}
 	else {
 		color   = mix_fgcolors(tid);
 	}
 	if (not color) {
 		color = dupG(no_color);
 	}
 	return color;
 }
 
 /** set color for task tid
  * @param[in] tid task id
  * @param[in] color_s color array
  * @ingroup EDI_CORE
  */
 void set_forground_color(const char *tid , const char *color_s) {
 	createTaskPath(fgPath, "fgColor");
 	writeFileG(color_s, fgPath);
 	sprintf(fgPath, "set foreground color in %s to %s", tid,color_s);
 	edi_log(fgPath);
 }
 
 /** remove foreground color for task tid
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 void remove_foreground_color(const char *tid) {
 	createTaskPath(fgPath, "fgColor");
 	if (fileExists(fgPath)) {
 		rmAllG(fgPath);
 	}
 }
 
 /** Mix background colors from task, groups and default colors.
  * @return color array
  * @param[in] tid task id
  * @ingroup EDI_CORE
  * Collect all defined colors in link groups.
  * For each group, the group gets the first color defined in the tree<br>
  * compute average color
  */
 smallArrayt *mix_bgcolors(const char *tid) {
 	// mix colors
 	// collect all defined colors in groups to root
 	createAllocateSmallArray(colors);
 	createAllocateSmallArray(color);
 	// root has no parent group, dont search parent group color
 	if (not eqG(tid, "root")) {
 		// find all groups - link and parent group
 		char taskPath[8192];
 		createAllocateSmallArray(groups);
 		if (is_linked(tid)) {
 			genTaskPath(taskPath, "groups/");
 			groups = readDirG(rtSmallArrayt, taskPath);
 		}
 		else {
 			pushG(groups, (char*)find_group_containing_task(tid));
 		}
 
 		// walk parent groups until a color or root is found
 		while (lenG(groups)) {
 			enum {search, found_color};
 			int status_color = search;
 			sprintf(taskPath, "%s/bgColor", generate_task_path(getG(groups, rtChar, 0)));
 			if (fileExists(taskPath)) {
 				createAllocateSmallString(f);
 				readFileG(f, taskPath);
 				smallArrayt *c  = splitG(f, ",");
 				// convert c strings to int
 				enumerateSmallArray(c, CP, ci) {
 					castS(cp, CP);
 					setG(c, ci, parseIntG(cp));
 					finishG(cp);
 				}
 				terminateG(f);
 				// -1 means no_color, mix colors
 				if (getG(c, rtI64 ,0) != -1) {
 					pushNFreeG(colors, c);
 					status_color = found_color;
 				}
 				else {
 					// c is not a color
 					terminateG(c);
 				}
 			}
 			if (status_color == search) {
 				char *parent_group = (char *) find_group_containing_task(getG(groups, rtChar, 0));
 				if (eqG(parent_group, "error")) {
 					// break infinite loop when there is an error in the database
 					break;
 				}
 				if (not eqG(parent_group, "root")) {
 					pushG(groups, parent_group);
 				}
 			}
 			delG(groups, 0, 1);
 		}
 		terminateG(groups);
 
 		// compute average color
 		if (lenG(colors)) {
 			pushG(color, 0);pushG(color, 0);pushG(color, 0);pushG(color, 0);
 			forEachSmallArray(colors, C) {
 				cast(smallArrayt*, c, C);
 				range(i, lenG(c)) {
 					*getG(color, rtI32P, i) += getG(c, rtI32, i);
 				}
 				finishG(C);
 			}
 			size_t colorCount = lenG(colors);
 			range(i, lenG(color)) {
 				*getG(color, rtI32P, i) /= colorCount;
 			}
 		}
 	}
 	if (not lenG(colors)) {
 		// no defined colors, use default color for status
 		char *task_status = (char *)get_status(tid);
 		terminateG(color);
 		color                   = getNDupG(status_bgColors_d, rtSmallArrayt, task_status);
 	}
 	return color;
 }
 
 /** get color for task tid
  * @return color array
  * @param[in] tid task id
  * @ingroup EDI_CORE
  * when no color is set, mix colors from groups or use defaults
  */
 smallArrayt *get_background_color(const char *tid) {
 	//color = no_color
 	smallArrayt *color = NULL;
 	createTaskPath(bgPath, "bgColor");
 
 	if (fileExists(bgPath)) {
 		createAllocateSmallArray(color);
 		createAllocateSmallString(f);
 		readFileG(f, bgPath);
 		smallArrayt *c  = splitG(f, ",");
 		// convert c strings to int
 		forEachSmallArray(c, CP) {
 			castS(cp, CP);
 			pushG(color, parseIntG(cp));
 			finishG(cp);
 		}
 		terminateManyG(f, c);
 		// -1 means no_color, mix colors
 		if (getG(color, rtI64 ,0) != -1) {
 			terminateG(color);
 			color = mix_bgcolors(tid);
 		}
 	}
 	else {
 		color   = mix_bgcolors(tid);
 	}
 	if (not color) {
 		color = dupG(no_color);
 	}
 	return color;
 }
 
 /** set color for task tid
  * @return color array
  * @param[in] tid task id
  * @param[in] color_s color array
  * @ingroup EDI_CORE
  */
 void set_background_color(const char *tid, const char *color_s) {
 	createTaskPath(bgPath, "bgColor");
 	writeFileG(color_s, bgPath);
 	sprintf(bgPath, "set background color in %s to %s", tid,color_s);
 	edi_log(bgPath);
 }
 
 /** remove background color for task tid
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 void remove_background_color(const char *tid) {
 	createTaskPath(bgPath, "bgColor");
 	if (fileExists(bgPath)) {
 		rmAllG(bgPath);
 	}
 }
 
 /** string returned from color_to_hex FF22AA */
 static char return_color_to_hex[7];
 
 /** converts color to hex format
  * @return color hex string
  * @param[in] color color array
  * @ingroup EDI_CORE
  */
 const char *color_to_hex(smallArrayt *color) {
 	createAllocateSmallArray(c);
 	forEachSmallArray(color, N) {
 		cast(smallIntt *, n, N);
 		if (getG(n, rtI64, unusedV) == -1) {
 			// -1 is no color, white
 			pushG(c, 255);
 		}
 		else {
 			pushNFreeG(c, dupG(n));
 		}
 		finishG(n);
 	}
 	sprintf(return_color_to_hex, "%02x%02x%02x", getG(c, rtI64, 0), getG(c, rtI64, 1), getG(c, rtI64, 2));
 	terminateG(c);
 	return return_color_to_hex;
 }
 
 
 /** string returned from generate_task_path */
 static char result_generate_task_path[8192];
 
 /** filesystem path for task in database tasks
  * @return path
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 const char *generate_task_path(const char *tid) {
 	sprintf(result_generate_task_path, "%s/%s", data_location_tasks, tid);
 	return result_generate_task_path;
 }
 
 /** string returned from generate_group_path */
 static char result_generate_group_path[8192];
 
 /** filesystem path for group in database groups
  * @return path
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 const char *generate_group_path(const char *tid) {
 	sprintf(result_generate_group_path, "%s/%s/", data_location_groups, tid);
 	return result_generate_group_path;
 }
 
 
 static char return_get_status[64];
 
 /** get status for tid
  * @return status string
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 const char *get_status(const char *tid) {
 	// open status file
 	createTaskPath(statusPath, "status");
 	createAllocateSmallString(status);
 	if (!readFileG(status, statusPath)) {
 		goto except;
 	}
 	if (lenG(status) > 63) {
 		// the status is too long, this is wrong
 		goto except;
 	}
 	strcpy(return_get_status, ssGet(status));
 	terminateG(status);
 	return return_get_status;
 except:
 	printf("%s is an invalid task.", generate_task_path(tid));
 	return TASK_STATUS[TASK_STATUS_VOID];
 }
 
 /** returns s
  * @return s
  * @param[in] tid task id
  * @param[in] s task title string
  * @ingroup EDI_CORE
  * Replaces generate_task_string_with_tid in GUI
  */
 smallStringt *passThroughTitle(const char *tid, smallStringt *s) {
 	return dupG(s);
 }
 
 /** creates a string with task id, status and string parameter
  * @return string
  * @param[in] tid task id
  * @param[in] s task title string
  * @ingroup EDI_CORE
  * Displays a task depending on edi_core.list_option
  */
 smallStringt *generate_task_string_with_tid(const char *tid, smallStringt *s) {
 	const char *status = get_status(tid);
 	smallStringt *r = NULL;
 	if (eqG(list_option, "tids")) {
 		// %*s to dynamically adjust id length
 		r = formatO("%" stringifyExpr(ID_LENGTH) "s - %s -   %s", tid, status, ssGet(s));
 	}
 	if (eqG(list_option, "positions")) {
 		if (is_this_task_a_group(tid)) {
 			// print tid for groups in the list
 			r = formatO("%" stringifyExpr(ID_LENGTH) "s - %s -   %s", tid, status, ssGet(s));
 		}
 		else {
 			// hide tids for normal tasks
 			r = formatO("%" stringifyExpr(ID_LENGTH) "s - %s -   %s", "", status, ssGet(s));
 		}
 	}
 	if (eqG(list_option, "md")) {
 		// print title and description
 		createTaskPath(taskPath, "description.txt");
 		createAllocateSmallArray(description);
 		readFileG(description, taskPath);
 		// remove title line
 		delG(description, 0 ,1);
 
 		// add <br> for long titles
 		smallStringt *j = joinG(description, "\n");
 		r = formatO("\n---\n#%s<br>\n%s", ssGet(s), ssGet(j));
 		terminateManyG(description, j);
 	}
 /* 	if list_option = 'rst' */
 /* 		# print title and description */
 /* 		f             = open generate_task_path(tid)+os.sep+'description.txt' */
 /* 		# remove title line */
 /* 		description_l = f readlines[1:] */
 /* 		f close */
 /*  */
 /* 		# convert urls to link */
 /* 		NOBRACKET = r'[^\]\[]*' */
 /* 		BRK = ( r'\[(' */
 /* 			+ (NOBRACKET + r'(\[')*6 */
 /* 			+ (NOBRACKET+ r'\])*')*6 */
 /* 			+ NOBRACKET + r')\]' ) */
 /* 		NOIMG = r'(?<!\!)' */
 /* 		LINK_RE = NOIMG + BRK + \ */
 /* 		r'''\(\s*(<.*?>|((?:(?:\(.*?\))|[^\(\)]))*?)\s*((['"])(.*?)\12\s*)?\)''' */
 /* 		# [text](url) or [text](<url>) or [text](url "title") */
 /*  */
 /* 		compiled_re = re.compile("^(.*?)%s(.*?)$" % LINK_RE, re.DOTALL | re.UNICODE) */
 /*  */
 /* 		for line_index,l in enumerate(description_l) */
 /* 			if 'http' in l */
 /* 				try */
 /* 					match      = compiled_re.match(l) */
 /* 					url        = match.group(9) */
 /* 					text       = match.group(2) */
 /* 					before_url = match.group(1) */
 /* 					#title      = match.group(13) */
 /* 					after_url  = match.group(14) */
 /*  */
 /* 					# added a space after text because rst complains when there is no space before < */
 /* 					# delimiting the url */
 /* 					l = '%s`%s <%s>`_%s'% (before_url, text, url, after_url) */
 /* 				except */
 /* 					# not used, information */
 /* 					link_status = 'WARNING: the link is not in format [title](url)' */
 /* 			description_l[line_index] = l */
 /*  */
 /* 		description   = ''.join(description_l) */
 /*  */
 /* 		tid           = ' ' */
 /* 		# remove position and type (GROUP, LINK) from title */
 /* 		title         = s[11:] lstrip */
 /* 		r             = '%s\n'%title + '='*len(title) + '\n%s\n\n'%description */
 /* 	if list_option = 'html' */
 /* 		#<tr bgcolor="#FEFFCC"> */
 /* 		#  <td class="subject">          <font color="#000000">t1</font></td> */
 /* 		#  <td class="description">          <font color="#000000">&nbsp;</font></td> */
 /* 		#</tr> */
 /* #:define read_description */
 /* 		# convert < to &lt; and > &gt; to ignore html tags in title line */
 /* 		s             = s.replace('<','&lt;').replace('>','&gt;') */
 /* 		f             = open generate_task_path(tid)+os.sep+'description.txt' */
 /* 		# remove title line, convert < to &lt; and > &gt; to ignore html tags */
 /* 		description_l = ['%s<br>'%i rstrip.replace('<','&lt;').replace('>','&gt;') for i in f readlines[1:]] */
 /* 		f close */
 /*  */
 /* 		# convert urls to link */
 /* 		NOBRACKET = r'[^\]\[]*' */
 /* 		BRK = ( r'\[(' */
 /* 			+ (NOBRACKET + r'(\[')*6 */
 /* 			+ (NOBRACKET+ r'\])*')*6 */
 /* 			+ NOBRACKET + r')\]' ) */
 /* 		NOIMG = r'(?<!\!)' */
 /* 		LINK_RE = NOIMG + BRK + \ */
 /* 		r'''\(\s*(<.*?>|((?:(?:\(.*?\))|[^\(\)]))*?)\s*((['"])(.*?)\12\s*)?\)''' */
 /* 		# [text](url) or [text](<url>) or [text](url "title") */
 /*  */
 /* 		compiled_re = re.compile("^(.*?)%s(.*?)$" % LINK_RE, re.DOTALL | re.UNICODE) */
 /*  */
 /* 		for line_index,l in enumerate(description_l) */
 /* 			if 'http' in l */
 /* 				try */
 /* 					match      = compiled_re.match(l) */
 /* 					url        = match.group(9) */
 /* 					text       = match.group(2) */
 /* 					before_url = match.group(1) */
 /* 					#title      = match.group(13) */
 /* 					after_url  = match.group(14) */
 /*  */
 /* 					l = '%s<a href="%s">%s</a>%s'% (before_url, url, text, after_url) */
 /* 				except */
 /* 					# not used, information */
 /* 					link_status = 'WARNING: the link is not in format [title](url)' */
 /* 			description_l[line_index] = l */
 /*  */
 /* 		description   = '\n'.join(description_l) */
 /* #:end */
 /*  */
 /* 		if is_this_task_a_group(tid) and user_interface = 'web' */
 /* 			subject       = '<a href="edi_web.py?tid=%s">%s -   %s</a>'%(tid,status,s) */
 /* 		else */
 /* 			subject       = '%s -   %s'%(status,s) */
 /* 		fg            = color_to_hex(get_forground_color(tid)) */
 /* 		bg            = color_to_hex(get_background_color(tid)) */
 /* 		r='        <tr bgcolor="#%s">\n          <td class="subject">          <font color="#%s">%s</font></td>\n          <td class="description">          <font color="#%s">%s</font></td>\n        </tr>' % (bg, fg, subject, fg, description) */
 	return r;
 }
 
 /** creates a string with task id, status and string parameter
  * @return list of strings
  * @param[in] tid task id
  * @param[in] s task title string
  * @ingroup EDI_CORE
  * Displays a group depending on edi_core.list_option
  */
 smallStringt *generate_group_string_with_tid (const char *tid, smallStringt *s) {
 	const char *status = get_status(tid);
 	smallStringt *r = NULL;
 	if ((eqG(list_option, "tids")) or (eqG(list_option, "positions"))) {
 		// %*s to dynamically adjust id length
 		r = formatO("%" stringifyExpr(ID_LENGTH) "s - %s -   %s", tid, status, ssGet(s));
 	}
 /* 	if list_option = 'md' */
 /* 		tid         = ' ' */
 /* 		# print group title only */
 /* 		r           = '#%s'%s.replace('  0 - GROUP','') */
 /* 		if agenda */
 /* 			r += '\n---\n# Agenda\n%s' % '\n\n'.join(agenda) */
 /* 	if list_option = 'rst' */
 /* 		tid         = ' ' */
 /* 		# print group title only */
 /* 		title       = s.replace('  0 - GROUP','') */
 /* 		r           = '='*len(title) + '\n%s\n'%title + '='*len(title) + '\n\n' */
 /* 		if agenda */
 /* 			r += 'Agenda\n======\n%s\n\n' % '\n'.join(agenda) */
 /* 		else */
 /* 			r += '\n.. contents::\n\n' */
 /* 	if list_option = 'html' */
 /* 		#<tr bgcolor="#FEFFCC"> */
 /* 		#  <td class="subject">          <font color="#000000">t1</font></td> */
 /* 		#  <td class="description">          <font color="#000000">&nbsp;</font></td> */
 /* 		#</tr> */
 /* 		# display description in html */
 /* #:read_description */
 /*  */
 /* 		subject     = '%s - %s'%(status, s) */
 /* 		fg          = color_to_hex(get_forground_color(tid)) */
 /* 		bg          = color_to_hex(get_background_color(tid)) */
 /* 		r='        <tr bgcolor="#%s">\n          <td class="subject">          <font color="#%s">%s</font></td>\n          <td class="description">          <font color="#%s">%s</font></td>\n        </tr>' % (bg, fg, subject, fg, description) */
 	return r;
 }
 
 /** determines if task is a group
  * @return empty string or 'this task is a group'
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 bool is_this_task_a_group(const char *tid) {
 	// Identify if task is a group
 	bool is_a_group     = false;
 	// list groups
 	smallArrayt *groups = readDirDirG(rtSmallArrayt, data_location_groups);
 	if (binarySearchG(groups, tid) != -1) {
 		is_a_group = true;
 	}
 	terminateG(groups);
 	return is_a_group;
 }
 
 /** get task title
  * @return first line of task description
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 smallStringt *get_task_title(const char *tid) {
 	createTaskPath(task_path, "description.txt");
 	createAllocateSmallArray(f);
 	readFileG(f, task_path);
 	smallStringt *r = getNDupG(f, rtSmallStringt, 0);
 	terminateG(f);
 	if (not r) {
 		// empty description, return empty string
 		r = allocG("");
 	}
 	return r;
 }
 
 /** get creation date
  * @return array of date string and unix time
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 smallArrayt *get_creation_date(const char *tid) {
 	createAllocateSmallArray(r);
 	// Figure out creation time and modification times for description and status
 	createTaskPath(task_path, "ctime.txt");
 	if (not fileExists(task_path)) {
 		pushG(r, "Not available");
 		pushG(r, 0);
 	}
 	else {
 		createAllocateSmallString(task_ctime);
 		readFileG(task_ctime, task_path);
 		pushG(r, task_ctime);
 		struct tm tm;
 		if (not strptime(ssGet(task_ctime), "%Y-%m-%d %H:%M", &tm)) {
 			// string time failed to parse
 			pushG(r, 0);
 		}
 		else {
 			time_t t = mktime(&tm);
 			pushG(r, (i64) t);
 		}
 		finishG(task_ctime);
 	}
 	return r;
 }
 
 /** get media
  * @return media file name
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 smallArrayt *get_media(const char *tid) {
 	createAllocateSmallArray(r);
 	createTaskPath(task_path, "media");
 	if (fileExists(task_path)) {
 		smallArrayt *files = readDirG(rtSmallArrayt, task_path);
 		smallStringt *fn = getG(files, rtSmallStringt, 0);
 		smallArrayt *spl = splitG(fn, ".");
 		pushG(r, getG(spl, rtChar, 0));
 		pushNFreeG(r, catS(task_path, "/", getG(files, rtChar, 0)));
 		terminateManyG(files, fn, spl);
 	}
 	else {
 		pushG(r, "None");
 	}
 	return r;
 }
 
 /** remove media
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 void remove_media(const char *tid) {
 	createTaskPath(task_path, "media");
 	if (fileExists(task_path)) {
 		rmAll(task_path);
 	}
 }
 
 
 /** set media, one media file per task
  * @return media array [media type (sound, image), file name]
  * @param[in] tid task id
  * @param[in] filename media file to copy to task
  * @ingroup EDI_CORE
  */
 smallArrayt *set_media(const char *tid, const char *filename) {
 	createAllocateSmallArray(r);
 
 	createTaskPath(task_path, "media");
 	char *fn  = trimG(filename);
 	if (endsWithG(fn, "wav")) {
 		//#:define create_media_folder
 		if (not fileExists(task_path)) {
 			// create media folder
 			mkdirParentsG(task_path);
 		}
 		//#:end
 		else {
 			// media exists, check type
 			smallArrayt *files = readDirG(rtSmallArrayt, task_path);
 			if (not endsWithG(getG(files, rtChar, 0), "wav")) {
 				smallStringt *s = formatO("%s is not a sound.", tid);
 				pushNFreeG(r, s);
 				terminateG(files);
 				goto end;
 			}
 			terminateG(files);
 		}
 		// sound file
 		char fp[8192];
 		sprintf(fp, "%s/sound.wav", task_path);
 		copy(filename, fp);
 		pushG(r, "sound.wav");
 	}
 	if (endsWithG(fn, "jpg")) {
 		//#:create_media_folder
 		if (not fileExists(task_path)) {
 			// create media folder
 			mkdirParentsG(task_path);
 		}
 		else {
 			// media exists, check type
 			smallArrayt *files = readDirG(rtSmallArrayt, task_path);
 			if (not endsWithG(getG(files, rtChar, 0), "jpg")) {
 				smallStringt *s = formatO("%s is not an image.", tid);
 				pushNFreeG(r, s);
 				terminateG(files);
 				goto end;
 			}
 			terminateG(files);
 		}
 		// image file
 		char fp[8192];
 		sprintf(fp, "%s/image.jpg", task_path);
 		copy(filename, fp);
 		pushG(r, "image.jpg");
 	}
 end:
 	free(fn);
 	if (not lenG(r)) {
 		smallStringt *s = formatO("%s is not a supported media file.", filename);
 		pushNFreeG(r, s);
 	}
 	else {
 		char log[8192];
 		sprintf(log, "added media %s in task %s", filename, tid);
 		edi_log(log);
 	}
 	return r;
 }
 
 /** get attachments
  * @return attachment file names
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 smallArrayt *get_attachments(const char *tid) {
 	smallArrayt *r;
 	createTaskPath(task_path, "attachments/");
 	if (fileExists(task_path)) {
 		// list files in attachments folder and prepend task_path
 		// r holds the paths to the attachments
 		r = readDirAllG(rtSmallArrayt, task_path);
 		enumerateSmallArray(r, F, i) {
 			castS(f, F);
 			prependG(f, task_path);
 			setNFreePG(r, i, f);
 		}
 	}
 	else {
 		initiateG(&r);
 		pushG(r, "None");
 	}
 	return r;
 }
 
 /** remove attachments
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 void remove_attachments(const char *tid) {
 	createTaskPath(task_path, "attachments");
 	if (fileExists(task_path)) {
 		rmAll(task_path);
 	}
 }
 
 
 /** set attachments
  * @return attachment file names
  * @param[in] tid task id
  * @param[in] array of filenames
  *  @ingroup EDI_CORE
  *
  * With *, set_attachments copies multiple files at once
  */
 smallArrayt *set_attachments(const char *tid, smallArrayt *filenames) {
 	createTaskPath(task_path, "attachments/");
 	if (not fileExists(task_path)) {
 		// create attachment folder
 		mkdirParentsG(task_path);
 	}
 
 	createAllocateSmallArray(r);
 	forEachSmallArray(filenames, FN) {
 		castS(fn, FN);
 		if (not copyG(fn,task_path)) goto except;
 		char log[8192];
 		sprintf(log, "added attachment %s in task %s", ssGet(fn), tid);
 		edi_log(log);
 		// Remove path from fn, keep only filename
 		char *s = basename(ssGet(fn));
 		pushNFreeG(r, appendG(task_path, s));
 		goto end;
 		except:
 			pushNFreeG(r, appendG("Failed to copy ", ssGet(fn)));
 		end:
 		finishG(fn);
 	}
 	return r;
 }
 
 /** sort task attributes (ls in edi cli)
  * @return sorted task list by state
  * @param[in] result from list_group
  * @ingroup EDI_CORE
  */
 smallArrayt *sort_task_attributes(smallArrayt *task_attributes) {
 	createAllocateSmallArray(r);
 	// Keep head group on top
 	smallDictt *d = getG(task_attributes, rtSmallDictt, 0);
 	if (eqG(getG(d, rtChar, "head"), "head group")) {
 		pushNFreeG(r, dupG(d));
 		delG(task_attributes, 0, 1);
 	}
 	finishG(d);
 	range(s, COUNT_ELEMENTS(SORT_TASK_ORDER)) {
 		forEachSmallArray(task_attributes, T) {
 			cast(smallDictt *, t, T);
 			if (eqG(getG(t, rtChar, "status"), TASK_STATUS[s])) {
 				pushG(r, T);
 			}
 			finishG(T);
 		}
 	}
 	return r;
 }
 
 /** sort function for sorting an array of tasks by date from newest to oldest
  * @return compare result
  * @param[in] result from list_group
  * @ingroup EDI_CORE
  */
 int sortdatefunc(smallDictt *x, smallDictt *y) {
 	i64 xv = getG(x, rtI64, "ctime");
 	i64 yv = getG(y, rtI64, "ctime");
 
 	if (xv == yv) return 0;
 	if (yv > xv) return 1;
 	else return -1;
 }
 
 /** sort task attributes (ls in edi cli)
  * @return sorted task list by date
  * @param[in] result from list_group
  * @ingroup EDI_CORE
  */
 smallArrayt *sort_task_attributes_by_date(smallArrayt *task_attributes) {
 	createAllocateSmallArray(r);
 	// Keep head group on top
 	smallDictt *d = getG(task_attributes, rtSmallDictt, 0);
 	if (eqG(getG(d, rtChar, "head"), "head group")) {
 		pushNFreeG(r, dupG(d));
 		delG(task_attributes, 0, 1);
 	}
 	finishG(d);
 	// -1 to exclude the empty line
 	smallArrayt *a = copyRngG(task_attributes, 0, -1);
 	//TODO a.sort(sortdatefunc)
 	//print task_attributes
 	appendNSmashG(r, a);
 	pushNFreeG(r, getG(task_attributes, rtBaset, -1));
 	return r;
 }
 
 /** Get task item in list_group format
  * @return r dictionary representing a task like the items returned by the list_group function
  * @param[in] tid task id
  * @ingroup EDI_CORE
  * for edi desktop
  */
 smallDictt *get_task_in_list_group_format(const char *tid) {
 	createAllocateSmallDict(r);
 	setG(r, "head", "element");
 	setG(r, "tid", tid);
 	char *group = "     ";
 	if (is_this_task_a_group(tid)) {
 		group = "GROUP";
 	}
 	if (is_linked(tid)) {
 		group = " LINK";
 	}
 	setG(r, "group", group);
 	// figure out position in group
 	i64 current_position = -1;
 	const char *group_path    = generate_group_path(find_group_containing_task(tid));
 	smallArrayt *lGroups = readDirDirG(rtSmallArrayt, group_path);
 	enumerateSmallArray(lGroups, FN, n) {
 		castS(fn, FN);
 		if (hasG(fn, tid)) {
 			// found tid in list
 			// position in list
 			smallStringt *posS = copyRngG(fn, 0 , ORDER_ID_LENGTH);
 			current_position = baseconvert_to_dec(ssGet(posS));
 			terminateG(posS);
 			break;
 		}
 		finishG(fn);
 	}
 	setG(r, "position", current_position);
 	// store title line
 	createTaskPath(task_path, "description.txt");
 	FILE *f = fopen(task_path, "r");
 	setNFreeG(r, "title", trimG(readLineG(rtSmallStringt, f)));
 	fclose(f);
 	setG(r, "status", get_status(tid));
 	smallArrayt *cd = get_creation_date(tid);
 	setG(r, "ctime", getG(cd, rtI64, 1));
 	terminateManyG(lGroups, cd);
 	return r;
 }
 
 /** list id - status - group - first line from description
  * @return list of tasks and groups title
  * @param[in] tid task id
  * @ingroup EDI_CORE
  * items in groups have the format 'ORDER_ID''TASK_ID'<br>
  * task 0 is group tittle<br>
  *<br>
  * result array elements:<br>
  * {head :string, tid :string, position :value, group :string, title :string, status :string}<br>
  * head tells if the element is a group title.<br>
  *<br>
  * example:<br>
  *fTTB1KRWfDpoSR1_ -   Active -   GROUP Motivational Interviewing<br>
  *62ZvFA_q0pCZFr0Y -   Active -         news<br>
  */
 smallArrayt *list_group(const char *tid) {
 	createAllocateSmallArray(result);
 	// list visible groups only
 	const char *task_status = get_status(tid);
 	if (getG(status_filters_d, rtI32, task_status) == ENABLE) {
 		// List task titles in group
 		const char *group_path  = generate_group_path(tid);
 
 		// List groups to indicate when a task is a group
 		// Identify if task is a group
 		smallArrayt *groups = readDirDirG(rtSmallArrayt, data_location_groups);
 		// End Identify if task is a group
 
 		// print items in tid in order
 		smallArrayt *tasksInGroup = readDirG(rtSmallArrayt, group_path);
 		enumerateSmallArray(tasksInGroup, FN, n) {
 			castS(fnp, FN);
 			smallStringt *fn = allocG(basename(ssGet(fnp)));
 			if (lenG(fn) != ORDER_ID_LENGTH+ID_LENGTH) {
 				// verify filename format in groups, cifs creates temporary files, ignore them
 				printf("EDI_ERROR: Database inconsistent, delete file - rm %s%s\n", group_path, ssGet(fn));
 			}
 			else {
 				// print position in list
 				smallStringt *posS = copyRngG(fn, 0 , ORDER_ID_LENGTH);
 				i64 current_position = baseconvert_to_dec(ssGet(posS));
 				terminateG(posS);
 
 				// Identify if task is a group
 				// Remove order_id, keep task id only
 				char *group = "     ";
 				if (hasG(groups, ssGet(fn)+ORDER_ID_LENGTH)) {
 					group = "GROUP";
 				}
 				if (is_linked(ssGet(fn)+ORDER_ID_LENGTH)) {
 					group = " LINK";
 				}
 				// End Identify if task is a group
 				// Get task title
 				// Remove order_id, keep task id only
 				char task_path[8192];
 				sprintf(task_path, "%s/description.txt", generate_task_path(ssGet(fn)+ORDER_ID_LENGTH));
 				FILE *f = fopen(task_path, "r");
 				// Remove order_id, keep task id only
 				const char *task_status = get_status(ssGet(fn)+ORDER_ID_LENGTH);
 				if ((not n) and (not eqG(tid, "root"))) {
 					// First task is group title
 					// filter status, keep task if status filter is enabled
 					if (getG(status_filters_d, rtI32, task_status) == ENABLE) {
 						createAllocateSmallDict(task_d);
 						setG(task_d, "head", "head group");
 						setG(task_d, "tid", ssGet(fn)+ORDER_ID_LENGTH);
 						setG(task_d, "position", current_position);
 						setG(task_d, "group", group);
 						setNFreeG(task_d, "title", trimG(readLineG(rtSmallStringt, f)));
 						setG(task_d, "status", get_status(ssGet(fn)+ORDER_ID_LENGTH));
 						smallArrayt *cd = get_creation_date(ssGet(fn)+ORDER_ID_LENGTH);
 						setG(task_d, "ctime", getG(cd, rtI64, 1));
 						terminateG(cd);
 						pushNFreeG(result, task_d);
 					}
 				}
 				else {
 					// filter status, keep task if status filter is enabled
 					if (getG(status_filters_d, rtI32, task_status) == ENABLE) {
 						createAllocateSmallDict(task_d);
 						setG(task_d, "head", "element");
 						setG(task_d, "tid", ssGet(fn)+ORDER_ID_LENGTH);
 						setG(task_d, "position", current_position);
 						setG(task_d, "group", group);
 						setNFreeG(task_d, "title", trimG(readLineG(rtSmallStringt, f)));
 						setG(task_d, "status", get_status(ssGet(fn)+ORDER_ID_LENGTH));
 						smallArrayt *cd = get_creation_date(ssGet(fn)+ORDER_ID_LENGTH);
 						setG(task_d, "ctime", getG(cd, rtI64, 1));
 						terminateG(cd);
 						pushNFreeG(result, task_d);
 					}
 				}
 				fclose(f);
 			}
 			terminateG(fn);
 			finishG(fnp);
 		}
 		terminateManyG(groups, tasksInGroup);
 		createAllocateSmallDict(task_d);
 		setG(task_d, "head", "empty line");
 		setG(task_d, "tid", "");
 		setG(task_d, "position", 0);
 		setG(task_d, "group", "");
 		setG(task_d, "title", "");
 		setG(task_d, "status", "");
 		setG(task_d, "ctime", 0);
 		pushNFreeG(result, task_d);
 	}
 	return result;
 }
 
 smallArrayt *listBookmarks(void) {
 	createAllocateSmallArray(result);
 
 	// check if there are bookmarks
 	if (not eqG(getG(bookmarks, rtChar, 0), "")) {
 
 		enumerateSmallArray(bookmarks, FN, n) {
 			castS(fn, FN);
 
 			// print position in list
 			i64 current_position = n;
 
 			// setup database
 			save_edi_core_data_location();
 			setup_data_location_for_tid(ssGet(fn));
 
 			// Identify if task is a group
 			// Remove order_id, keep task id only
 			char *group = "     ";
 			if (is_this_task_a_group(ssGet(fn))) {
 				group = "GROUP";
 			}
 			if (is_linked(ssGet(fn))) {
 				group = " LINK";
 			}
 			// End Identify if task is a group
 			// Get task title
 			char task_path[8192];
 			sprintf(task_path, "%s/description.txt", generate_task_path(ssGet(fn)));
 			FILE *f = fopen(task_path, "r");
 			const char *task_status = get_status(ssGet(fn));
 			// filter status, keep task if status filter is enabled
 			if (getG(status_filters_d, rtI32, task_status) == ENABLE) {
 				createAllocateSmallDict(task_d);
 				setG(task_d, "head", "element");
 				setG(task_d, "tid", ssGet(fn));
 				setG(task_d, "position", current_position);
 				setG(task_d, "group", group);
 				setNFreeG(task_d, "title", trimG(readLineG(rtSmallStringt, f)));
 				setG(task_d, "status", get_status(ssGet(fn)));
 				smallArrayt *cd = get_creation_date(ssGet(fn));
 				setG(task_d, "ctime", getG(cd, rtI64, 1));
 				terminateG(cd);
 				pushNFreeG(result, task_d);
 			}
 			fclose(f);
 			restore_edi_core_data_location();
 			finishG(fn);
 		}
 	}
 	createAllocateSmallDict(task_d);
 	setG(task_d, "head", "empty line");
 	setG(task_d, "tid", "");
 	setG(task_d, "position", 0);
 	setG(task_d, "group", "");
 	setG(task_d, "title", "");
 	setG(task_d, "status", "");
 	setG(task_d, "ctime", 0);
 	pushNFreeG(result, task_d);
 	return result;
 }
 
 /** lists all items in the tid group
  * @return list of tasks and groups title
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 smallArrayt *list_tree(const char *tid) {
 	createAllocateSmallArray(result);
 	// walk_group is the list of groups to visit. FIFO
 	createAllocateSmallArray(walk_group);
 	pushG(walk_group, tid);
 	// the while loop goes through all the group that are found
 	while (lenG(walk_group)) {
 		// list visible groups only
 		const char *task_status = get_status(getG(walk_group, rtChar, 0));
 		if (getG(status_filters_d, rtI32, task_status) == ENABLE) {
 			// list items in first group
 			smallArrayt *tasks = readDirG(rtSmallArrayt, generate_group_path(getG(walk_group, rtChar, 0)));
 			appendNSmashG(result,  list_group(getG(walk_group, rtChar, 0)));
 
 			// add group found in first group
 			forEachSmallArray(tasks, T) {
 				castS(t, T);
 				// Check tasks that are not title task in a group
 				if (not eqG(ssGet(t)+ORDER_ID_LENGTH, getG(walk_group, rtChar, 0)) and is_this_task_a_group(ssGet(t)+ORDER_ID_LENGTH)) {
 					pushG(walk_group, ssGet(t)+ORDER_ID_LENGTH);
 				}
 				finishG(t);
 			}
 			terminateG(tasks);
 		}
 
 		// remove first group to list items in next group
 		delG(walk_group, 0, 1);
 	}
 	terminateG(walk_group);
 	return result;
 }
 
 /** string returned from generate_id */
 static char return_generate_id[ID_LENGTH+1];
 
 /** generates a random task id
  * @return new task id
  * @ingroup EDI_CORE
  */
 const char *generate_id(void) {
 	return_generate_id[ID_LENGTH] = 0;
 
 	randomUrandomOpen();
 	range(i, ID_LENGTH) {
 		return_generate_id[i] = ID_BASE[randomChoice(BASE)];
 	}
 	return return_generate_id;
 }
 
 /** string returned from baseconvert */
 static char return_baseconvert[ORDER_ID_LENGTH+1];
 
 /** converts decimal number to BASE (base 65)
  * @return string representing a number in base BASE
  * @param[in] n integer
  * @ingroup EDI_CORE
  */
 const char *baseconvert(i64 n) {
 	if (n < 0) {
 		return_baseconvert[0] = 0;
 	}
 	else {
 		return_baseconvert[ORDER_ID_LENGTH] = 0;
 		u8 i = ORDER_ID_LENGTH-1;
 		while (1) {
 			i64 r = n % BASE;
 			return_baseconvert[i] = ID_BASE[r];
 			i--;
 			n = n / BASE;
 			if (n == 0)
 				break;
 		}
 		rangeDown(j, i+1) {
 			return_baseconvert[j] = ID_BASE[0];
 		}
 	}
 	return return_baseconvert;
 }
 
 /** converts BASE number to decimal
  * @return n integer
  * @param[in] n string representing a number in base BASE
  * @ingroup EDI_CORE
  */
 i64 baseconvert_to_dec(const char *n) {
 	i64 r     = 0;
 	i64 power = 1;
 	rangeDown(digit, lenG(n)) {
 		int i = 0;
 		range(a, BASE) {
 			if (ID_BASE_STRING[a] == getG(n, unusedV, digit)) {
 				break;
 			}
 			i++;
 		}
 		r     += i * power;
 		power *= BASE;
 	}
 	return r;
 }
 
 /** string returned from add_task_to_group_folder */
 static char return_add_task_to_group_folder[8192];
 
 /** add task to group folder in database groups
  * @param[in] tid task id
  * @param[in] group task id
  * @ingroup EDI_CORE
  * Tasks are added at the top or bottom of the list.
  */
 const char *add_task_to_group_folder(const char *tid, const char *group) {
 	// Create an entry in group
 	smallArrayt *tasks = NULL;
 	const char *order_id;
 	tasks = readDirG(rtSmallArrayt, generate_group_path(group));
 	// Add +1 to last order_id to have the task last in the list
 	if (tasks and (lenG(tasks) > 0)) {
 		if ((lenG(tasks) == 1) or (eqG(add_top_or_bottom, "bottom"))) {
 			// add tasks in bottom
 			char *s              = copyRngG(getG(tasks, rtChar, -1), 0, ORDER_ID_LENGTH);
 			order_id = baseconvert(baseconvert_to_dec(s)+1);
 			free(s);
 		}
 		else {
 			// add tasks on top
 			// temporary orderid #
 			char orderid_and_tid[ORDER_ID_LENGTH + ID_LENGTH + 1];
 			range(i, ORDER_ID_LENGTH) {
 				orderid_and_tid[i] = '#';
 			}
 			strcat(orderid_and_tid, tid);
 			i64 to_pos;
 			if (eqG(group, "root")) {
 				to_pos = 0;
 			}
 			else {
 				// add new tasks after group title
 				to_pos = 1;
 			}
 
 			injectSG(tasks, to_pos, orderid_and_tid);
 
 			// Move tasks
 			const char *path = generate_group_path(group);
 			enumerateSmallArray(tasks, T, n) {
 				castS(t, T);
 				if (n == to_pos) {
 					// set orderid on top
 					order_id = baseconvert(n);
 				}
 				else {
 					char src[8192];
 					sprintf(src, "%s/%s", path, ssGet(t));
 					char dst[8192];
 					sprintf(dst, "%s/%s%s", path, baseconvert(n), ssGet(t)+ORDER_ID_LENGTH);
 					shRename(src, dst);
 				}
 				finishG(t);
 			}
 		}
 	}
 	else {
 		// start at 0 when group is empty
 		order_id = baseconvert(0);
 	}
 
 	sprintf(return_add_task_to_group_folder, "%s/%s%s", generate_group_path(group), order_id, tid);
 	// remove double slash that can come up
 	char *tmp = return_add_task_to_group_folder;
 	iUniqSlash(tmp);
 	FILE *f = fopen(return_add_task_to_group_folder, "w");
 	fclose(f);
 
 	// return return_add_task_to_group_folder to easily add new tasks to group_directory_file_list and save time
 	return return_add_task_to_group_folder;
 }
 
 /** creates a task and opens vi
  * @param[in] group task id
  * @ingroup EDI_CORE
  */
 const char *create_task(const char *group) {
 	// Open text editor
 	// create task in tasks folder
 	//#:define create_task_part1
 	const char *tid =  generate_id();
 
 	// Save text in tasks
 	const char *task_path  = generate_task_path(tid);
 	mkdirParentsG(task_path);
 	//#:end
 	// create an empty file (for windows and mac osx)
 	createTaskPath(dPath, "description.txt");
 	FILE *f = fopen(dPath, "w");
 	fclose(f);
 	if (hasG(editor, "echo TEST")) {
 		// use os.system to be able to run edi cli unittests
 		//char *c = catG(editor, dPath);
 		char *c = catS("echo TEST > ", dPath);
 		systemNFreeG(c);
 	}
 	else {
 		// use subprocess.call to wait until the editor is closed (Windows and Mac OSX) because the task is deleted when the description is empty
 		// create a list [command,param1,param2,task file] to allow options on command line to start the editor
 		smallStringt *ss      = allocG(editor);
 		smallArrayt *editor_l = splitG(ss, "/");
 		terminateG(ss);
 		// after last os.sep there is the command name and the option. Do this because there can be spaces in the path to the command
 		ss                    = getG(editor_l, rtSmallStringt, -1);
 		smallArrayt *options  = splitG(ss, " ");
 		finishG(ss);
 		setNFreeG(editor_l, -1, getNDupG(options, rtBaset, 0));
 		delG(options, 0, 1);
 		createAllocateSmallArray(command_line);
 		ss                    = joinG(editor_l, "/");
 		terminateG(editor_l);
 		pushG(command_line, ss);
 		appendNSmashG(command_line, options);
 		rallocG(ss, dPath);
 		pushNFreeG(command_line, ss);
 		ss = joinG(command_line, " ");
 		terminateG(command_line);
 		systemNFreeG(ss);
 	}
 	if (not fileExists(dPath)) {
 		// file doesnt exist, abort task creation
 		rmAllG(task_path);
 		return "no new task, the description is empty";
 	}
 
 	// Save creation time
 	//#:define save_task_creation_time
 	time_t t = getModificationTimeG(dPath);
 	char *s  = timeToS(t);
 	genTaskPath(dPath, "ctime.txt");
 	writeFileG(s, dPath);
 	free(s);
 	//#:end
 
 	// create status, active by default
 	//#:define create_task_part2
 	// Create status
 	genTaskPath(dPath, "status");
 	writeFileG(TASK_STATUS[TASK_STATUS_ACTIVE], dPath);
 
 	const char *tid_in_groups_path = add_task_to_group_folder(tid, group);
 
 	if (lenG(group_directory_file_list)) {
 		pushG(group_directory_file_list, tid_in_groups_path);
 	}
 
 	// autolink
 	if (autolink) {
 		forEachSmallArray(autolink, G) {
 			castS(g, G);
 			if (is_this_task_a_group(ssGet(g))) {
 				// link to groups existing in current database
 				add_task_reference_to_a_group(tid, g);
 			}
 			finishG(g);
 		}
 	}
 	//#:end
 	sprintf(dPath, "created %s in group %s", tid, group);
 	edi_log(dPath);
 	return tid;
 }
 
 /** create task and copy text file
  * @param[in] group task id
  * @param[in] text_file filename of text file to copy
  * @ingroup EDI_CORE
  */
 const char *add_task(const char *group, const char *text_file) {
 	//#:create_task_part1
 	const char *tid =  generate_id();
 
 	// Save text in tasks
 	const char *task_path  = generate_task_path(tid);
 	mkdirParentsG(task_path);
 	createTaskPath(dPath, "description.txt");
 	copy(text_file, dPath);
 	//#:save_task_creation_time
 	time_t t = getModificationTimeG(dPath);
 	char *s  = timeToS(t);
 	genTaskPath(dPath, "ctime.txt");
 	writeFileG(s, dPath);
 	free(s);
 	//#:create_task_part2
 	// Create status
 	genTaskPath(dPath, "status");
 	writeFileG(TASK_STATUS[TASK_STATUS_ACTIVE], dPath);
 
 	const char *tid_in_groups_path = add_task_to_group_folder(tid, group);
 
 	if (lenG(group_directory_file_list)) {
 		pushG(group_directory_file_list, tid_in_groups_path);
 	}
 
 	// autolink
 	if (autolink) {
 		forEachSmallArray(autolink, G) {
 			castS(g, G);
 			if (is_this_task_a_group(ssGet(g))) {
 				// link to groups existing in current database
 				add_task_reference_to_a_group(tid, g);
 			}
 			finishG(g);
 		}
 	}
 	sprintf(dPath, "created %s in group %s", tid, group);
 	edi_log(dPath);
 	return tid;
 }
 
 /** create task with description text
  * @param[in] group task id
  * @param[in] text string
  * @ingroup EDI_CORE
  */
 const char *add_text(const char *group, smallStringt *text) {
 	//#:create_task_part1
 	const char *tid =  generate_id();
 
 	// Save text in tasks
 	const char *task_path  = generate_task_path(tid);
 	mkdirParentsG(task_path);
 	createTaskPath(dPath, "description.txt");
 	writeFileG(text, dPath);
 	//#:save_task_creation_time
 	time_t t = getModificationTimeG(dPath);
 	char *s  = timeToS(t);
 	genTaskPath(dPath, "ctime.txt");
 	writeFileG(s, dPath);
 	free(s);
 	//#:create_task_part2
 	// Create status
 	genTaskPath(dPath, "status");
 	writeFileG(TASK_STATUS[TASK_STATUS_ACTIVE], dPath);
 
 	const char *tid_in_groups_path = add_task_to_group_folder(tid, group);
 
 	if (lenG(group_directory_file_list)) {
 		pushG(group_directory_file_list, tid_in_groups_path);
 	}
 
 	// autolink
 	if (autolink) {
 		forEachSmallArray(autolink, G) {
 			castS(g, G);
 			if (is_this_task_a_group(ssGet(g))) {
 				// link to groups existing in current database
 				add_task_reference_to_a_group(tid, g);
 			}
 			finishG(g);
 		}
 	}
 	sprintf(dPath, "created %s in group %s", tid, group);
 	edi_log(dPath);
 	return tid;
 }
 
 /** create task and copy text file, filename is task title
  * @param[in] group task id
  * @param[in] text_file filename of text file to copy
  * @ingroup EDI_CORE
  */
 const char *add_task_and_filename(const char *group, const char *text_file) {
 	const char *tid = add_task(group,text_file);
 
 	// Add file name on first line
 	createTaskPath(dPath, "description.txt");
 	createAllocateSmallArray(f);
 	readFileG(f, dPath);
 	char *s = basename(text_file);
 	prependG(f, s);
 	writeFileG(f, dPath);
 	terminateG(f);
 	return tid;
 }
 
 /** string returned from add_many_tasks_array */
 static char return_add_many_tasks_array[100];
 
 /** create many tasks from a text array
  * @param[in] group task id
  * @param[in] text_array text array to copy
  * @ingroup EDI_CORE
  * Used directly in Easydoneit Desktop
  */
 const char *add_many_tasks_array(const char *group, smallArrayt *text_array) {
 	return_add_many_tasks_array[0]  = 0;
 
 	// Copy a task to text string
 	// Remove '#' from first line, first character position
 	// Add task to database
 	createAllocateSmallString(text);
 	i64 number_of_tasks = 0;
 	enum {START, WRITING_TASK};
 	i8 status           = START;
 	forEachSmallArray(text_array, L) {
 		castS(l, L);
 		if (eqG(l, "---")) {
 			if (status != START) {
 				// add task to database
 				add_text(group,text);
 				number_of_tasks++;
 			}
 			emptyG(text);
 			status = START;
 		}
 		else {
 			if ((status == START) and (ssGet(l)[0] == '#')) {
 				delG(l, 0, 1);
 			}
 			appendNSmashG(text, dupG(l));
 			status = WRITING_TASK;
 		}
 		finishG(l);
 	}
 
 	if (status == WRITING_TASK) {
 		// add task to database
 		add_text(group,text);
 		number_of_tasks++;
 	}
 	terminateG(text);
 
 	sprintf(return_add_many_tasks_array, "created %ld tasks in group %s", number_of_tasks, group);
 	edi_log(return_add_many_tasks_array);
 	return return_add_many_tasks_array;
 }
 
 /** create many tasks from a text file
  * @param[in] group task id
  * @param[in] text_file filename of text file to copy
  * @ingroup EDI_CORE
  */
 const char *add_many_tasks(const char *group, const char *text_file) {
 
 	// load file and call add_many_tasks_array
 	createAllocateSmallArray(text_array);
 	readFileG(text_array, text_file);
 	const char *r = add_many_tasks_array(group, text_array);
 	terminateG(text_array);
 	return r;
 }
 
 /** string returned from add_many_one_line_tasks_array */
 static char return_add_many_one_line_tasks_array[100];
 
 /** create many one line tasks from a text array
  * @param[in] group task id
  * @param[in] text_array text array to copy
  * @ingroup EDI_CORE
  * Used directly in Easydoneit Desktop
  */
 const char *add_many_one_line_tasks_array(const char *group, smallArrayt *text_array) {
 	return_add_many_one_line_tasks_array[0] = 0;
 
 	i64 number_of_tasks = 0;
 	forEachSmallArray(text_array, L) {
 		castS(l, L);
 		trimG(l);
 		add_text(group,l);
 		number_of_tasks++;
 		finishG(l);
 	}
 
 	sprintf(return_add_many_one_line_tasks_array, "created %ld tasks in group %s", number_of_tasks,group);
 	edi_log(return_add_many_one_line_tasks_array);
 	return return_add_many_one_line_tasks_array;
 }
 
 /** create many one line tasks from a text file
  * @param[in] group task id
  * @param[in] text_file filename of text file to copy
  * @ingroup EDI_CORE
  */
 const char *add_many_one_line_tasks(const char *group, const char *text_file) {
 
 	createAllocateSmallArray(text_array);
 	readFileG(text_array, text_file);
 	const char *r = add_many_one_line_tasks_array(group, text_array);
 	terminateG(text_array);
 	return r;
 }
 
 /** string returned from add_many_groups_from_text_array */
 static char return_add_many_groups_from_text_array[100];
 
 /** create group from text array
  * @param[in] group task id
  * @param[in] text_array with group structure
  * @ingroup EDI_CORE
  * Used directly in Easydoneit Desktop
  */
 const char *add_many_groups_from_text_array(const char *group, smallArrayt *text_array) {
 	return_add_many_groups_from_text_array[0] = 0;
 
 	i64 number_of_tasks = 0;
 	createAllocateSmallArray(group_stack);
 	pushG(group_stack, group);
 	forEachSmallArray(text_array, L) {
 		castS(l, L);
 		// count space indents
 		i64 indent = 0;
 		char *s    = ssGet(l);
 		range(i, lenG(l)) {
 			if (s[i] != ' ') {
 				break;
 			}
 			indent++;
 		}
 		if (indent < lenG(group_stack)-1) {
 			// remove groups from stack if same level or higher levels
 			delG(group_stack, -(lenG(group_stack)-1 - indent), 0);
 		}
 		trimG(l);
 		const char *tid = add_text(getG(group_stack, rtChar,-1), l);
 		create_group(tid);
 		pushG(group_stack, tid);
 		number_of_tasks++;
 		finishG(l);
 	}
 
 	sprintf(return_add_many_groups_from_text_array, "created %ld groups in group %s", number_of_tasks, group);
 	edi_log(return_add_many_groups_from_text_array);
 	return return_add_many_groups_from_text_array;
 }
 
 /* create group from text file
  * @param[in] group task id
  * @param[in] text_file with group structure
  * @ingroup EDI_CORE
  */
 const char *add_many_groups_from_text(const char *group, const char *text_file) {
 
 	// load file and call add_many_groups_from_text_array
 	createAllocateSmallArray(text_array);
 	readFileG(text_array, text_file);
 	const char *r = add_many_groups_from_text_array(group, text_array);
 	terminateG(text_array);
 
 	return r;
 }
 
 /** string returned from export_task_to_a_file */
 static char return_export_task_to_a_file[8192];
 
 /** copy description to path using first line of description as filename
  * @return path and filname
  * @param[in] tid task id
  * @param[in] path destination directory for task description
  * @ingroup EDI_CORE
  */
 const char *export_task_to_a_file(const char *tid, const char *path) {
 	createTaskPath(dPath, "description.txt");
 	createAllocateSmallArray(des);
 	readFileG(des, dPath);
 	smallStringt *fn = getNDupG(des, rtSmallStringt, 0);
 	trimG(fn);
 	delG(des, 0, 1);
 	sprintf(return_export_task_to_a_file, "%s/%s", path, ssGet(fn));
 	// remove eventual double //
 	uniqSlash((char *)&return_export_task_to_a_file);
 
 	writeFileG(des, return_export_task_to_a_file);
 	return return_export_task_to_a_file;
 }
 
 /** print description of task tid
  * @return list of strings
  * @param[in] tid task id
  * @param[in] titleFunc Function that changes first description line
  * @ingroup EDI_CORE
  * In GUI, titleFunc (passThroughTitle function) keeps original title line.
  */
 // python call: def display_task tid, titleFunc=generate_task_string_with_tid
 smallArrayt *display_task(const char *tid, smallStringt *titleFunc(const char *, smallStringt *)) {
 	createTaskPath(task_path, "description.txt");
 	createAllocateSmallArray(description);
 	if (isBlankG(tid)) {
 		// tid is invalid, return empty description
 		pushG(description, "");
 		return description;
 	}
 	readFileG(description, task_path);
 
 	// print tid, status and first line
 	smallStringt *s = getG(description, rtSmallStringt, 0);
 	if (s) {
 		setNFreeG(description, 0, titleFunc(tid, s));
 	}
 	else {
 		// empty description, push empty line
 		pushG(description, "");
 	}
 	finishG(s);
 	return description;
 }
 
 
 /** string returned frm find_group_containing_task */
 static char return_find_group_containing_task[64];
 
 /** find group containing task tid in groups folder
  * @return tid
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 const char *find_group_containing_task(const char *tid) {
 	if (eqG(tid, "root")) {
 		// root has not parent group, return root
 		return tid;
 	}
 	return_find_group_containing_task[0] = 0;
 	//#:define walk_groups
 	// reuse previously created group list, to save time
 	if (not lenG(group_directory_file_list)) {
 		terminateG(group_directory_file_list);
 ;		group_directory_file_list = walkDirG(rtSmallArrayt, data_location_groups);
 	}
 	smallArrayt *groups_and_tasks = group_directory_file_list;
 	forEachSmallArray(groups_and_tasks, GT) {
 		castS(t, GT);
 		smallArrayt *ts = splitG(t, "/");
 		if (endsWithG(t, tid) and not eqG(tid, getG(ts, rtChar, -2))) {
 			strcpy(return_find_group_containing_task,  getG(ts, rtChar, -2));
 		}
 		terminateG(ts);
 		finishG(GT);
 	}
 	//#:end
 	if (return_find_group_containing_task[0] == 0) {
 		printf("\n\nEDI_ERROR: Database inconsistent - run: find %s|grep %s and remove reference.\n", data_location, tid);
 		strcpy(return_find_group_containing_task, "error");
 	}
 	return return_find_group_containing_task;
 }
 
 /** find group containing task tid in groups folder and print
  * @return list of strings
  * @param[in] tid task id
  * @ingroup EDI_CORE
  * Shows path in tree and title for each group in path
  */
 smallArrayt *show_group_for_task(const char *tid) {
 	createAllocateSmallArray(r);
 
 	// set group string to be displayed on first line
 	char *group_s = "     ";
 	if (is_this_task_a_group(tid)) {
 		group_s = "GROUP";
 	}
 	if (is_linked(tid)) {
 		group_s = " LINK";
 	}
 
 	//#:walk_groups
 	// reuse previously created group list, to save time
 	if (not lenG(group_directory_file_list)) {
 		terminateG(group_directory_file_list);
 		group_directory_file_list = walkDirG(rtSmallArrayt, data_location_groups);
 	}
 	smallArrayt *groups_and_tasks = group_directory_file_list;
 	createAllocateSmallString(treePath);
 	forEachSmallArray(groups_and_tasks, GT) {
 		castS(t, GT);
 		smallArrayt *ts = splitG(t, "/");
 		if (endsWithG(t, tid) and not eqG(tid, getG(ts, rtChar, -2))) {
 			char *group = return_find_group_containing_task;
 			strcpy(return_find_group_containing_task,  getG(ts, rtChar, -2));
 			const char *tree_path = find_group_in_tree(group);
 
 			// p is data_location folder/tree
 			smallStringt *s = allocG(data_location_tree);
 			smallArrayt *p_l = splitG(s, "/");
 			terminateG(s);
 			sliceG(p_l, -2, 0);
 			smallStringt *p  = joinG(p_l, "/");
 			terminateG(p_l);
 
 			// if empty then command is run in tree root
 			setFromG(treePath, tree_path);
 			p_l = splitG(treePath, ssGet(p));
 			if (lenG(getG(p_l, rtChar, -1))) {
 				// print path of tids: tid/tid...
 				s = getNDupG(p_l, rtSmallStringt, -1);
 				// remove /
 				delG(s, 0, 1);
 				pushG(r,  s);
 				smallArrayt *g_l = splitG(s, "/");
 				finishG(s);
 				createAllocateSmallArray(group_titles_in_path);
 				forEachSmallArray(g_l, G) {
 					castS(g, G);
 					pushNFreeG(group_titles_in_path, get_task_title(ssGet(g)));
 					finishG(g);
 				}
 				terminateG(g_l);
 				// print title/title...
 				pushNFreeG(r, joinG(group_titles_in_path, "/"));
 				terminateG(group_titles_in_path);
 			}
 			terminateManyG(p, p_l);
 			p = get_task_title(group);
 			pushNFreeG(r, generate_group_string_with_tid(group, p));
 			terminateG(p);
 			pushG(r, "");
 		}
 		terminateG(ts);
 		finishG(GT);
 	}
 	terminateG(treePath);
 
 	// Print media and attachments
 	// media type
 	smallArrayt *m           = get_media(tid);
 	char *media              = getG(m, rtChar, 0);
 	// attachment list
 	smallArrayt *attachments = get_attachments(tid);
 
 	// Print task, colors, group list
 	smallArrayt *color       = get_forground_color(tid);
 	char *fc                 = toStringG(color);
 	terminateG(color);
 	color                    = get_background_color(tid);
 	char *bc                 = toStringG(color);
 	// Figure out creation time and modification times for description and status
 	smallArrayt *tctime      = get_creation_date(tid);
 	char *task_ctime         = getG(tctime, rtChar, 0);
 
 	createTaskPath(task_path, "description.txt");
 	char *description_mtime = timeToS(getModificationTimeG(task_path));
 	genTaskPath(task_path, "status");
 	char *status_mtime      = timeToS(getModificationTimeG(task_path));
 	smallStringt *tt        = get_task_title(tid);
 	prependG(tt, " ");
 	prependG(tt, group_s);
 	smallStringt *s         = generate_task_string_with_tid(tid, tt);
 	createAllocateSmallArray(info);
 	pushG                   (info, "Tasks:");
 	pushG                   (info, ssGet(s));
 	pushG                   (info, "");
 	pushG                   (info, "");
 	terminateManyG(tt, s);
 	pushNFreeG              (info, appendG("Media type: ", media));
 	pushG                   (info, "");
 	pushG                   (info, "Attachments:");
 	appendNSmashG           (info, attachments);
 	pushG                   (info, "");
 	pushG                   (info, "");
 	pushNFreeG              (info, formatS("foreground color:        %s", fc));
 	pushNFreeG              (info, formatS("background color:        %s", bc));
 	pushNFreeG              (info, formatS("Creation time:           %s", task_ctime));
 	pushNFreeG              (info, formatS("Last description change: %s", description_mtime));
 	pushNFreeG              (info, formatS("Last status change:      %s", status_mtime));
 	pushG                   (info, "");
 	pushG                   (info, "Group list");
 	appendNSmashG           (info, r);
 	r = info;
 	terminateManyG(m, color, tctime);
 	freeManyS(fc, bc, description_mtime, status_mtime);
 	return r;
 }
 
 /** string returned from find_group_in_tree */
 static char return_find_group_in_tree[8192];
 
 /** find group in tree folder
  * @return path_in_tree
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 const char *find_group_in_tree(const char *group) {
 	char *path_in_tree;
 	if (eqG(group, "root")) {
 		path_in_tree = data_location_tree;
 	}
 	else {
 		path_in_tree = return_find_group_in_tree;
 		path_in_tree[0] = 0;
 
 		// list all group paths in tree
 		/* if platform.system() = 'Windows' */
 		/* 	folders = [] */
 		/* 	folders append data_location_tree */
 		/* 	for dir, subdirs, files in os.walk(data_location_tree) */
 		/* 		for sd in subdirs */
 		/* 			folders append dir+os.sep + sd */
 		/* else */
 		smallArrayt *folders = walkDirAllG(rtSmallArrayt, data_location_tree);
 		enumerateSmallArray(folders, F, i) {
 			castS(f, F);
 			trimG(f);
 			setNFreePG(folders, i, f);
 		}
 		smallArrayt *groups       = folders;
 		// find the group in group paths
 		forEachSmallArray(groups, G) {
 			castS(g, G);
 			char *s = basename(ssGet(g));
 			if (eqG(s, group))
 				strcpy(path_in_tree, ssGet(g));
 			finishG(g);
 		}
 		terminateG(folders);
 	}
 	return path_in_tree;
 }
 
 /** Determines if a task has multiple references
  * @return integer 0 or 1
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 bool is_linked(const char *tid) {
 	bool status = false;
 	createTaskPath(task_linked_groups_path, "groups/");
 	// check if tid/groups exists
 	if (fileExists(task_linked_groups_path)) {
 		smallArrayt *groups = readDirG(rtSmallArrayt, task_linked_groups_path);
 		// check if task is linked to more than 1 group
 		if (lenG(groups) > 1) {
 			status = true;
 		}
 		terminateG(groups);
 	}
 	return status;
 }
 
 /** convert task to group
  * @return list of stings when there is an error
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 smallArrayt *create_group(const char *tid) {
 	createAllocateSmallArray(r);
 	// convert task to group only when task is not linked
 	if (is_linked(tid)) {
 		pushG(r, "Converting linked task to group removes links. The task groups are:");
 		appendNSmashG(r, show_group_for_task(tid));
 
 		// delete tid/groups because groups are not linked
 		createTaskPath(task_linked_groups_path, "groups/");
 		smallArrayt *groups = readDirG(rtSmallArrayt, task_linked_groups_path);
 		// remove all links except for the first group
 		forEachSmallArray(groups, G) {
 			castS(g, G);
 			delete_linked_task(ssGet(g),tid);
 			finishG(g);
 		}
 		if (fileExistsG(task_linked_groups_path)) {
 			rmAll(task_linked_groups_path);
 		}
 		pushNFreeG(r, formatS("Created group %s in %s", tid, getG(groups, rtChar,0)));
 		terminateG(groups);
 	}
 	// create new group in groups folder
 	char p[8192];
 	sprintf(p, "%s/%s", data_location_groups, tid);
 	mkdirParentsG(p);
 	// First task in group is group title task
 	const char *order_id = baseconvert(0);
 	sprintf(p, "%s/%s%s", generate_group_path(tid), order_id, tid);
 	FILE *f              = fopen(p, "w");
 	fclose(f);
 
 	// Add group in tree
 	// update group list
 	emptyG(group_directory_file_list);
 	const char *group    = find_group_containing_task(tid);
 	if (eqG(group, "root")) {
 		sprintf(p, "%s/%s", data_location_tree, tid);
 		mkdirParentsG(p);
 		// git support
 		sprintf(p, "%s/%s/.keepDir", data_location_tree, tid);
 		f = fopen(p, "w");
 		fclose(f);
 	}
 	else {
 		const char *s = find_group_in_tree(group);
 		sprintf(p, "%s/%s", s, tid);
 		mkdirParentsG(p);
 		// git support
 		sprintf(p, "%s/%s/.keepDir", s, tid);
 		f = fopen(p, "w");
 		fclose(f);
 	}
 
 	// Change status active to void by default
 	// To avoid filtering groups
 	if (eqG(get_status(tid), TASK_STATUS[TASK_STATUS_ACTIVE])) {
 		// set status to void
 		set_status(tid,TASK_STATUS_VOID);
 	}
 	sprintf(p, "created group %s", tid);
 	edi_log(p);
 	return r;
 }
 
 /** string returned from convert_group_to_task */
 static char return_convert_group_to_task[1];
 
 /** convert group to task
  * @param[in] group group to convert to task
  * @ingroup EDI_CORE
  */
 const char *convert_group_to_task(const char *group) {
 	char *r = return_convert_group_to_task;
 	r[0]    = 0;
 
 	// list all tasks (data_location_groups/GROUP/'ORDER_ID''TASK_ID') in groups folder
 	smallArrayt *groups_and_tasks = walkDirG(rtSmallArrayt, data_location_groups);
 
 	char *convert_group_status = "delete";
 	char groupslash[ORDER_ID_LENGTH + ID_LENGTH + 1];
 	sprintf(groupslash, "%s/", group);
 	forEachSmallArray(groups_and_tasks, T2) {
 		castS(t2, T2);
 		// search a task in group that is not tid
 		char *t2task = basename(ssGet(t2));
 		if (hasG(t2, groupslash) and (not eqG(group, t2task)))
 			convert_group_status = "There is another task in the group, keeping group.";
 			r = convert_group_status;
 			// just need to find one task
 			break;
 		finishG(t2);
 	}
 	terminateG(groups_and_tasks);
 	if (eqG(convert_group_status, "delete") and (not hasG(group, "root"))) {
 		// Delete group title and group folder
 		rmAllG(generate_group_path(group));
 		// Delete group in tree
 		const char *treepath = find_group_in_tree(group);
 		if (not isEmptyG(treepath)) {
 			rmAll(treepath);
 		}
 		// change state from void to active
 		set_status(group,TASK_STATUS_ACTIVE);
 		char log[100];
 		sprintf(log, "converted group %s to task", group);
 		edi_log(log);
 	}
 	return r;
 }
 
 /** string returned from delete_task */
 static char return_delete_task[ORDER_ID_LENGTH + ID_LENGTH + 1];
 
 /** delete task tid in all groups
  * @return group id
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 const char *delete_task(const char *tid) {
 	// Delete task in tasks
 	rmAll(generate_task_path(tid));
 
 	// Delete task reference in groups
 	// list all tasks (data_location_groups/GROUP/'ORDER_ID''TASK_ID') in groups folder
 	smallArrayt *groups_and_tasks = walkDirG(rtSmallArrayt, data_location_groups);
 
 	// Identify if task is a group
 	bool is_a_group = is_this_task_a_group(tid);
 
 	// Return group task, it changes when first task is deleted
 	char *group_id  = return_delete_task;
 	group_id[0]     = 0;
 	// list groups to reorder at the end
 	createAllocateSmallArray(reorder_groups);
 	forEachSmallArray(groups_and_tasks, T) {
 		castS(t, T);
 		// Delete reference in upper group, not the title task of the group
 		smallArrayt *ta = splitG(t, "/");
 		char thisGroup[8192];
 		strcpy(thisGroup, getG(ta, rtChar, -2));
 		terminateG(ta);
 		if ((endsWithG(t, tid)) and (not eqG(tid, thisGroup))) {
 			// group is the group for task tid
 			strcpy(group_id, thisGroup);
 			// Delete task reference in group
 			rmAllG(t);
 			pushG(reorder_groups, group_id);
 			if (is_a_group) {
 				// First task becomes a group, add a reference in group group
 				// list tasks in order in tid group
 				smallArrayt *group_tasks = readDirG(rtSmallArrayt, generate_group_path(tid));
 				// Delete emtpy group or first task in group becomes the group title.
 				if (lenG(group_tasks) == 1) {
 					rmAllG(generate_group_path(tid));
 					// Delete group in tree
 					// when a group is deleted, subgroups are automatically deleted in the tree
 					const char *s = find_group_in_tree(tid);
 					if (not isEmptyG(s)) {
 						rmAllG(s);
 					}
 				}
 				else {
 					// Remove order_id, keep task id only
 					char *first_task  = getG(group_tasks, rtChar,1) + ORDER_ID_LENGTH;
 					strcpy(group_id, first_task);
 					// Create an entry in group at the same position as tid had
 					ta = splitG(t, "/");
 					char *order_id = copyRngG(getG(ta, rtChar, -1), 0, ORDER_ID_LENGTH);
 					terminateG(ta);
 					char groupPath[8192];
 					sprintf(groupPath, "%s/%s%s", generate_group_path(group_id), order_id, first_task);
 					free(order_id);
 					FILE *f = fopen(groupPath, "w");
 					fclose(f);
 
 					// Delete group task of group of more then 2 tasks, first task becomes a group
 					// delete orderidtaskid
 					sprintf(groupPath, "%s/%s", generate_group_path(tid), getG(group_tasks, rtChar, 0));
 					rmAllG(groupPath);
 					const char *path = generate_group_path(tid);
 					char src[8192];
 					sprintf(src, "%s/%s", path, getG(group_tasks, rtChar, 1));
 					char dst[8192];
 					sprintf(dst, "%s/%s%s", path, baseconvert(0), first_task);
 					shRename(src, dst);
 					// reorder tasks to remove gap between group title task and first task
 					smallArrayt *tasks = readDirG(rtSmallArrayt, path);
 					enumerateSmallArray(tasks, T, n) {
 						castS(t, T);
 						char src[8192];
 						sprintf(src, "%s/%s", path, ssGet(t));
 						char dst[8192];
 						sprintf(dst, "%s/%s%s", path, baseconvert(n), ssGet(t)+ORDER_ID_LENGTH);
 						shRename(src, dst);
 						finishG(t);
 					}
 					terminateG(tasks);
 					// rename group in groups folder
 					shRename(path, generate_group_path(first_task));
 					// rename group in tree folder
 					const char *group_tree_path       = find_group_in_tree(tid);
 					smallStringt *s                   = allocG(group_tree_path);
 					smallArrayt *group_tree_path_l    = splitG(s, "/");
 					terminateG(s);
 					setG(group_tree_path_l, -1, first_task);
 					smallStringt *new_group_tree_path = joinG(group_tree_path_l, "/");
 					shRename(group_tree_path, ssGet(new_group_tree_path));
 					terminateManyG(new_group_tree_path, group_tree_path_l);
 				}
 				terminateG(group_tasks);
 			}
 		}
 		finishG(t);
 	}
 	terminateG(groups_and_tasks);
 
 	// reorder tasks to remove gaps in reorder_groups
 	forEachSmallArray(reorder_groups, T) {
 		castS(tidg, T);
 		const char *path = generate_group_path(ssGet(tidg));
 		smallArrayt *tasks = readDirG(rtSmallArrayt, path);
 		enumerateSmallArray(tasks, TD, n) {
 			castS(t, TD);
 			char src[8192];
 			sprintf(src, "%s/%s", path, ssGet(t));
 			char dst[8192];
 			sprintf(dst, "%s/%s%s", path, baseconvert(n), ssGet(t)+ORDER_ID_LENGTH);
 			shRename(src, dst);
 			finishG(t);
 		}
 		terminateG(tasks);
 		finishG(tidg);
 	}
 
 	// Return group task
 	smallStringt *s = joinG(reorder_groups, " ");
 	char *log = formatS("deleted %s in %s", tid, ssGet(s));
 	edi_log(log);
 	free(log);
 	terminateManyG(reorder_groups, s);
 	return group_id;
 }
 
 /** string returned from delete_linked_task */
 static char return_delete_linked_task[ORDER_ID_LENGTH + ID_LENGTH + 1];
 
 /** Delete task only if it is linked in one group
  * @return group id
  * @param[in] group task id
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 const char *delete_linked_task(const char *group, const char *tid) {
 	char *group_id = return_delete_linked_task;
 	strcpy(group_id, group);
 
 	if (not is_linked(tid)) {
 		group_id = (char *) delete_task(tid);
 	}
 	else {
 		// Delete task reference in group
 		const char *path = generate_group_path(group);
 		char p[8192];
 
 		// find task in group: ORDER_IDTASK_ID
 		smallArrayt *tasks = readDirG(rtSmallArrayt, path);
 		forEachSmallArray(tasks, T) {
 			castS(t, T);
 			if (eqG(ssGet(t)+ORDER_ID_LENGTH, tid)) {
 				sprintf(p, "%s%s", path, ssGet(t));
 				rmAllG(p);
 			}
 			finishG(t);
 		}
 		terminateG(tasks);
 
 		// delete group in tid/groups
 		sprintf(p, "%s/groups/%s", generate_task_path(tid), group);
 		rmAllG(p);
 
 		// reorder tasks to remove gaps in group
 		tasks = readDirG(rtSmallArrayt, path);
 		enumerateSmallArray(tasks, T, n) {
 			castS(t, T);
 			char src[8192];
 			sprintf(src, "%s/%s", path, ssGet(t));
 			char dst[8192];
 			sprintf(dst, "%s/%s%s", path, baseconvert(n), ssGet(t)+ORDER_ID_LENGTH);
 			shRename(src, dst);
 			finishG(t);
 		}
 		terminateG(tasks);
 
 		sprintf(p, "deleted %s in group %s", tid, group);
 		edi_log(p);
 	}
 
 	return group_id;
 }
 
 /** delete group tid
  * @return group id
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 const char *delete_group(const char *tid) {
 	// Delete tasks in group
 	smallArrayt *group_tasks = readDirG(rtSmallArrayt, generate_group_path(tid));
 	if ((lenG(group_tasks) == 0) and eqG(tid, "root")) {
 		// the database is already empty
 		return tid;
 	}
 	if (not eqG(tid, "root")) {
 		// root group doesnt have a title
 		// Remove group title from the loop to delete tasks only and then group
 		delG(group_tasks, 0, 1);
 	}
 
 	// Delete tasks and groups recursively
 	forEachSmallArray(group_tasks, T) {
 		castS(t, T);
 		// Remove order_id, keep task id only
 		char *oid = ssGet(t)+ORDER_ID_LENGTH;
 		if (not is_this_task_a_group(oid)) {
 			// delete tasks that are linked only once
 			delete_linked_task(tid, oid);
 		}
 		else {
 			delete_group(oid);
 		}
 		finishG(t);
 	}
 	terminateG(group_tasks);
 
 	if (not eqG(tid, "root")) {
 		// never delete root group
 		return delete_task(tid);
 	}
 	else {
 		// return root and keep root task
 		return tid;
 	}
 }
 
 /** edit task with vi
  * @param[in] tid task id
  * @ingroup EDI_CORE
  */
 void edit_task(const char *tid) {
 	createTaskPath(dPath, "description.txt");
 	char c[24576];
 	sprintf(c, "%s %s", editor, dPath);
 	system(c);
 	sprintf(c, "edited %s", tid);
 	edi_log(c);
 }
 
 /** move task from group at at_pos to to_pos and reorder
  * @return list of stings when there is an error
  * @param[in] group task id
  * @param[in] at_pos selected position
  * @param[in] to_pos insert position
  * @ingroup EDI_CORE
  */
 smallArrayt *change_task_order(const char *group, i64 at_pos, i64 to_pos) {
 	// List tasks in group
 	createAllocateSmallArray(r);
 	char path[8192];
 	strcpy(path, generate_group_path(group));
 	smallArrayt *tasks = readDirG(rtSmallArrayt, path);
 
 	// Verify position
 	// Get task
 	char *orderid_and_tid = getG(tasks, rtChar, at_pos);
 	if (not orderid_and_tid) {
 		pushNFreeG(r, formatS("%ld is an invalid position.", at_pos));
 		goto end;
 	}
 	if (to_pos == 0) {
 		char *tid = orderid_and_tid+ORDER_ID_LENGTH;
 		// do not move linked tasks to position 0
 		if (is_linked(tid)) {
 			pushG(r, "Converting linked task to group removes links. The task groups are:");
 			appendNSmashG(r, show_group_for_task(tid));
 
 			// delete tid/groups because groups are not linked
 			createTaskPath(task_linked_groups_path, "groups/");
 			smallArrayt *groups = readDirG(rtSmallArrayt, task_linked_groups_path);
 			// remove all links except for the first group
 			forEachSmallArray(groups, G) {
 				castS(g, G);
 				if (not eqG(g, group)) {
 					delete_linked_task(ssGet(g),tid);
 				}
 				finishG(g);
 			}
 			terminateG(groups);
 			if (fileExists(task_linked_groups_path)) {
 				rmAll(task_linked_groups_path);
 			}
 			const char *parent_group = find_group_containing_task(group);
 			pushNFreeG(r, formatS("Created group %s in %s",tid,parent_group));
 		}
 		// do not move groups to position 0
 		if (is_this_task_a_group(tid)) {
 			pushG(r, "Having a group in group title is not supported.");
 			goto end;
 		}
 	}
 	// Insert task at to_pos
 	char *to_pos_tid = NULL;
 	if (to_pos > at_pos) {
 		// +1 because at_pos reference will be deleted and will shift to_pos reference
 		to_pos += 1;
 		injectSG(tasks, to_pos, orderid_and_tid);
 		// Delete task at at_pos
 		delG(tasks, at_pos, at_pos+1);
 	}
 	else {
 		// rename group title, when to_pos in 0
 		if ((to_pos == 0) and (not eqG(group, "root"))) {
 			to_pos_tid = getG(tasks, rtChar, to_pos)+ORDER_ID_LENGTH;
 		}
 
 		injectSG(tasks, to_pos, orderid_and_tid);
 		// Delete task at at_pos+1 because the new position is before at_pos
 		// at_pos was shifted when to_pos reference was added above
 		delG(tasks, at_pos+1, at_pos+2);
 	}
 
 	//:define reorder_tasks
 	// Move tasks
 	enumerateSmallArray(tasks, T, n) {
 		castS(t, T);
 		char src[8192];
 		sprintf(src, "%s/%s", path, ssGet(t));
 		char dst[8192];
 		sprintf(dst, "%s/%s%s", path, baseconvert(n), ssGet(t)+ORDER_ID_LENGTH);
 		shRename(src, dst);
 		finishG(t);
 	}
 	//:end
 
 	// rename group title, when to_pos in 0
 	if ((to_pos == 0) and (not eqG(group, "root"))) {
 		// rename group in parent group
 		// group is tid for parent group and to_pos_tid is equal to group input parameter because to_pos is 0
 		const char *groupF = find_group_containing_task(group);
 		// to_pos_orderid_and_tid is group in parent group
 		smallStringt *to_pos_orderid_and_tid;
 		smallArrayt *parent_group_tasks = readDirG(rtSmallArrayt, generate_group_path(groupF));
 		forEachSmallArray(parent_group_tasks, T) {
 			castS(t, T);
 			if (eqG(ssGet(t)+ORDER_ID_LENGTH, to_pos_tid)) {
 				to_pos_orderid_and_tid = dupG(t);
 			}
 			finishG(t);
 		}
 		terminateG(parent_group_tasks);
 		// remove order_id, keep task id only for new group
 		char *group_id         = orderid_and_tid+ORDER_ID_LENGTH;
 		// create an entry in parent group at the same position as to_pos tid had
 		smallStringt *order_id = copyRngG(to_pos_orderid_and_tid, 0, ORDER_ID_LENGTH);
 		char p[8192];
 		sprintf(p, "%s/%s%s", generate_group_path(groupF), order_id,group_id);
 		FILE *f                = fopen(p, "w");
 		fclose(f);
 
 		// delete group task of group
 		// delete orderidtaskid
 		sprintf(p, "%s/%s", generate_group_path(groupF), ssGet(to_pos_orderid_and_tid));
 		rmAllG(p);
 
 		// rename group in groups folder
 		strcpy(p, generate_group_path(to_pos_tid));
 		shRename(p, generate_group_path(group_id));
 		// rename group in tree folder
 		const char *group_tree_path    = find_group_in_tree(to_pos_tid);
 		char **group_tree_path_l       = splitG(group_tree_path, "/");
 		setG(group_tree_path_l, -1, group_id);
 		char *new_group_tree_path      = joinG(group_tree_path_l, "/");
 		freeG(group_tree_path_l);
 		shRename(group_tree_path, new_group_tree_path);
 		free(new_group_tree_path);
 
 		// rename group in linked task and former linked task with a 'groups' folder in tasks database folder
 		smallArrayt *group_tasks = readDirG(rtSmallArrayt, generate_group_path(group_id));
 		forEachSmallArray(group_tasks, G) {
 			castS(group_task, G);
 			char tPath[8192];
 			sprintf(tPath, "%s/groups", generate_task_path(ssGet(group_task)+ORDER_ID_LENGTH));
 			if (fileExists(tPath)) {
 				// search for to_pos_tid (group input parameter) in task path groups folder
 				smallArrayt *link_groups = readDirG(rtSmallArrayt, tPath);
 				forEachSmallArray(link_groups, LG) {
 					castS(lg, LG);
 					if (eqG(to_pos_tid, lg)) {
 						// rename group to new group id since the title changed
 						char src[8192];
 						sprintf(src, "%s/%s", tPath, to_pos_tid);
 						char dst[8192];
 						sprintf(dst, "%s/%s", tPath, group_id);
 						shRename(src, dst);
 					}
 					finishG(lg);
 				}
 				terminateG(link_groups);
 			}
 			finishG(G);
 		}
 		terminateG(group_tasks);
 	}
 
 	char log[2048];
 	sprintf(log, "changed task order %s to %s in group %s", at_pos, to_pos, group);
 	edi_log(log);
 end:
 	terminateG(tasks);
 	return r;
 }
 
 /** move selected tasks in Easydoneit desktop from group to to_pos and reorder
  * @return list of stings when there is an error
  * @param[in] group task id
  * @param[in] selected_tasks selected tasks in GUI list (array of ints)
  * @param[in] to_pos insert position
  * @ingroup EDI_CORE
  */
 void change_task_order_desktop(const char *group,smallArrayt *selected_tasks, i64 to_pos) {
 	// List tasks in group
 	const char *path   = generate_group_path(group);
 	smallArrayt *tasks = readDirG(rtSmallArrayt, path);
 
 	createAllocateSmallArray(orderid_and_tids);
 	forEachSmallArray(selected_tasks, T) {
 		cast(smallIntt *, t, T);
 		pushG(orderid_and_tids, getG(tasks, rtChar, getG(t, rtI64, unusedV)));
 		finishG(t);
 	}
 	sortG(orderid_and_tids);
 
 	smallArrayt *task1 = copyRngG(tasks, 0, to_pos);
 	smallArrayt *task2 = copyRngG(tasks, to_pos, 0);
 
 	// remove selected tasks from group list
 	createAllocateSmallArray(task1m);
 	forEachSmallArray(task1, I) {
 		castS(i, I);
 		if (not binarySearchG(orderid_and_tids, ssGet(i))) {
 			pushG(task1m, i);
 		}
 		finishG(i);
 	}
 	createAllocateSmallArray(task2m);
 	forEachSmallArray(task2, I) {
 		castS(i, I);
 		if (not binarySearchG(orderid_and_tids, ssGet(i))) {
 			pushG(task2m, i);
 		}
 		finishG(i);
 	}
 	terminateManyG(task1, task2);
 
 	emptyG(tasks);
 	catG(tasks, task1m, orderid_and_tids, task2m);
 	smashManyO(task1m, orderid_and_tids, task2m);
 
 	//:reorder_tasks
 	// Move tasks
 	{enumerateSmallArray(tasks, T, n) {
 		castS(t, T);
 		char src[8192];
 		sprintf(src, "%s/%s", path, ssGet(t));
 		char dst[8192];
 		sprintf(dst, "%s/%s%s", path, baseconvert(n), ssGet(t)+ORDER_ID_LENGTH);
 		shRename(src, dst);
 		finishG(t);
 	}}
 	terminateG(tasks);
 
 	{enumerateSmallArray(orderid_and_tids, T, n) {
 		castS(t, T);
 		sliceG(t, ORDER_ID_LENGTH, 0);
 		setPG(orderid_and_tids, n, t);
 		finishG(t);
 	}}
 	smallStringt *log = joinG(orderid_and_tids, " ");
 	terminateG(orderid_and_tids);
 	char *s = formatS("changed task order (%s) to %ld in group %s", ssGet(log), to_pos, group);
 	terminateG(log);
 	edi_log(s);
 	free(s);
 }
 
 /** string returned from move_task_to_a_group */
 static char return_move_task_to_a_group[2048];
 
 /** move task to group
  * @return tid
  * @param[in] tgroup task id, select a task in this group
  * @param[in] tid task id
  * @param[in] group task id, destination group
  * @ingroup EDI_CORE
  */
 const char *move_task_to_a_group(const char *tgroup, const char *tid, const char *group) {
 
 	// find task tid in tgroup and remove task
 	char path[8192];
 	strcpy(path, generate_group_path(tgroup));
 	smallArrayt *tasks = readDirG(rtSmallArrayt, path);
 	char task_in_group[ORDER_ID_LENGTH + ID_LENGTH +1];
 	task_in_group[0] = 0;
 	enumerateSmallArray(tasks, T, n) {
 		castS(t, T);
 		// remove task from tasks to reorder tgroup
 		if (eqG(ssGet(t)+ORDER_ID_LENGTH, tid)) {
 			strcpy(task_in_group, ssGet(t));
 			delG(tasks, n, n+1);
 			break;
 		}
 		finishG(t);
 	}
 	if (isEmptyG(task_in_group)) {
 		sprintf(return_move_task_to_a_group, "%s not found in %s", tid, tgroup);
 		return return_move_task_to_a_group;
 	}
 
 	// Move group in tree
 	if (is_this_task_a_group(tid)) {
 		char treePath[8192];
 		strcpy(treePath, find_group_in_tree(group));
 		char *treeTid = strdup(find_group_in_tree(tid));
 		sliceG(&treeTid, 0, -ID_LENGTH-1);
 		if (eqG(treeTid, treePath)) {
 			// prevent moving a group on itself, in tree and moving group title position to parent group
 			free(treeTid);
 			return tid;
 		}
 		free(treeTid);
 		shRename(find_group_in_tree(tid), treePath);
 	}
 
 	// Remove task in source group
 	sprintf(path, "%s/%s", path, task_in_group);
 	rmAll(path);
 
 	//:reorder_tasks
 	// Move tasks
 	{enumerateSmallArray(tasks, T, n) {
 		castS(t, T);
 		char src[8192];
 		sprintf(src, "%s/%s", path, ssGet(t));
 		char dst[8192];
 		sprintf(dst, "%s/%s%s", path, baseconvert(n), ssGet(t)+ORDER_ID_LENGTH);
 		shRename(src, dst);
 		finishG(t);
 	}}
 	terminateG(tasks);
 
 	// check that tid is not already linked in destination group
 	if (is_linked(tid)) {
 		createTaskPath(gPath, "groups/");
 		smallArrayt *link_groups = readDirG(rtSmallArrayt, gPath);
 		if (hasG(link_groups, group)) {
 			// removed task reference from tgroup. Remove tgroup reference in task. There is already a tid reference in group, nothing more to do
 			char p[8192];
 			sprintf(p, "%s/%s", gPath, tgroup);
 			rmAllG(p);
 			terminateG(link_groups);
 			return tid;
 		}
 		terminateG(link_groups);
 	}
 
 	// Create reference in destination group
 	add_task_to_group_folder(tid, group);
 
 	// linked tasks, remove source group and add destination group
 	if (is_linked(tid)) {
 		// remove source tgroup from tid/groups
 		createTaskPath(gPath, "groups/");
 		char p[8192];
 		sprintf(p, "%s/%s", gPath, tgroup);
 		rmAllG(p);
 		sprintf(p, "%s/%s", gPath, group);
 		FILE *f = fopen(p, "w");
 		fclose(f);
 	}
 
 	char log[256];
 	sprintf(log, "moved %s in group %s to group %s", tid, tgroup, group);
 	edi_log(log);
 	return tid;
 }
 
 /** string returned from copy_task_to_a_group */
 static char return_copy_task_to_a_group[ORDER_ID_LENGTH + ID_LENGTH +1];
 
 /** copy task to group with new tid
  * @return new tid
  * @param[in] tid task id
  * @param[in] group task id, destination group
  * @ingroup EDI_CORE
  */
 const char *copy_task_to_a_group(const char *tid, const char *group) {
 	// Generate new tid
 	strcpy(return_copy_task_to_a_group, generate_id());
 	char *newtid = return_copy_task_to_a_group;
 	// Copy task in tasks
 	char newtidPath[8192];
 	strcpy(newtidPath, generate_task_path(newtid));
 	// add / to copy files in task
 	char *tPath = (char*) generate_task_path(tid);
 	strcat(tPath, "/");
 	copy(tPath, newtidPath);
 	// delete tid/groups because new task is not linked
 	char task_linked_groups_path[8192];
 	sprintf(task_linked_groups_path, "%s/groups/", newtidPath);
 	if (fileExistsG(task_linked_groups_path)) {
 		rmAllG(task_linked_groups_path);
 	}
 	// Copy group in groups and in tree
 	if (is_this_task_a_group(tid)) {
 		// create new group
 		copy(generate_group_path(tid), newtidPath);
 		// Change group title task to newtid
 		char tPath[8192];
 		sprintf(tPath, "%s/%s%s", newtidPath, baseconvert(0), tid);
 		char ntPath[8192];
 		sprintf(tPath, "%s/%s%s", newtidPath, baseconvert(0), newtid);
 		shRename(tPath, ntPath);
 
 		// delete tasks to be recreated with new tid
 		char p[8192];
 		smallArrayt *tasks = readDirG(rtSmallArrayt ,generate_group_path(newtid));
 		forEachSmallArray(tasks, T) {
 			castS(t, T);
 			sprintf(p, "%s/%s", generate_group_path(newtid), ssGet(t));
 			rmAllG(p);
 			finishG(t);
 		}
 		terminateG(tasks);
 
 		// Add group in tree
 		if (eqG(group, "root")) {
 			sprintf(p, "%s/%s", data_location_tree, newtid);
 			mkdirParentsG(p);
 		}
 		else {
 			sprintf(p, "%s/%s", find_group_in_tree(group), newtid);
 		}
 		mkdirParentsG(p);
 	}
 
 
 	// Add reference in group
 	// Create reference in destination group
 	add_task_to_group_folder(newtid, group);
 
 	if (is_this_task_a_group(tid)) {
 		// walk in group
 		// list items in group
 		smallArrayt *tasks = readDirG(rtSmallArrayt, generate_group_path(tid));
 
 		// add group found in first group
 		forEachSmallArray(tasks, T) {
 			castS(t, T);
 			// Check tasks that are not title task in a group
 			if (not eqG(ssGet(t) + ORDER_ID_LENGTH, tid))
 				// copy_task_to_a_group recursively
 				copy_task_to_a_group(ssGet(t) + ORDER_ID_LENGTH,newtid);
 			finishG(t);
 		}
 		terminateG(tasks);
 	}
 
 	sprintf(newtidPath, "copied %s to group %s, created %s", tid,group,newtid);
 	edi_log(newtidPath);
 	return newtid;
 }
 
 /** string returned from generate_task_path_in_database */
 static char return_generate_task_path_in_database[8192];
 
 /** create task path in database using database name
  * @return path to task in tasks
  * @param[in] tid task id
  * @param[in] location database name in data section of easydoneit.ini
  * @ingroup EDI_CORE
  */
 const char *generate_task_path_in_database(const char *tid, const char *location) {
 	char *locPath = getG(selected_d, rtChar, location);
 	sprintf(return_generate_task_path_in_database, "%s/tasks/%s/", locPath, tid);
 	return return_generate_task_path_in_database;
 }
 
 /** string returned from generate_group_path_in_database */
 static char return_generate_group_path_in_database[8192];
 
 /** create group path in database using database name
  * @return path to group in groups
  * @param[in] tid task id
  * @param[in] location database name in data section of easydoneit.ini
  * @ingroup EDI_CORE
  */
 const char *generate_group_path_in_database(const char *tid, const char *location) {
 	char *locPath = getG(selected_d, rtChar, location);
 	sprintf(return_generate_group_path_in_database, "%s/groups/%s/", locPath, tid);
 	return return_generate_group_path_in_database;
 }
 
 /** string returned from find_group_in_tree_in_database */
 static char return_find_group_in_tree_in_database[8192];
 
 /** find group in tree folder in database
  * @return path to group in tree
  * @param[in] group task id
  * @param[in] location database name in data section of easydoneit.ini
  * @ingroup EDI_CORE
  */
 const char *find_group_in_tree_in_database(const char *group, const char *location) {
 	char location_tree[8192];
 	char *locPath = getG(selected_d, rtChar, location);
 	sprintf(location_tree, "%s/tree", locPath);
 	char *path_in_tree = return_find_group_in_tree_in_database;
 	path_in_tree[0]    = 0;
 
 	if (eqG(group, "root")) {
 		strcpy(return_find_group_in_tree_in_database, location_tree);
 	}
 	else {
 		// list all group paths in tree
 		/* if platform.system() = 'Windows' */
 		/* 	folders = [] */
 		/* 	folders append location_tree */
 		/* 	for dir, subdirs, files in os.walk(location_tree) */
 		/* 		for sd in subdirs */
 		/* 			folders append dir+os.sep + sd */
 		/* else */
 		smallArrayt *folders = walkDirAllG(rtSmallArrayt, location_tree);
 		enumerateSmallArray(folders, F, i) {
 			castS(f, F);
 			trimG(f);
 			setNFreePG(folders, i, f);
 		}
 		smallArrayt *groups       = folders;
 		// find the group in group paths
 		forEachSmallArray(groups, G) {
 			castS(g, G);
 			char *s = basename(ssGet(g));
 			if (eqG(s, group))
 				strcpy(path_in_tree, ssGet(g));
 			finishG(g);
 		}
 		terminateG(folders);
 	}
 	return path_in_tree;
 }
 
 /** add task with new tid in selected database
  * @param[in] tid task id
  * @param[in] group task id
  * @param[in] location database name in data section of easydoneit.ini
  * @ingroup EDI_CORE
  */
 void add_task_to_group_folder_in_database(const char *tid, const char *group, const char* location) {
 	// Create an entry in group
 	smallArrayt *tasks = readDirG(rtSmallArrayt, generate_group_path_in_database(group,location));
 	// Add +1 to last order_id to have the task last in the list
 	const char *order_id;
 	if (lenG(tasks)) {
 		smallStringt *s   = getG(tasks, rtSmallStringt, -1);
 		smallStringt *pos = copyRngG(s, 0, ORDER_ID_LENGTH);
 		finishG(s);
 		order_id = baseconvert(baseconvert_to_dec(ssGet(pos))+1);
 		terminateG(pos);
 	}
 	else {
 		// start at 0 when group is empty
 		order_id = baseconvert(0);
 	}
 	terminateG(tasks);
 	char p[8192];
 	sprintf(p, "%s/%s%s", generate_group_path_in_database(group,location), order_id, tid);
 	FILE *f = fopen(p, "w");
 	fclose(f);
 }
 
 /** string returned from copy_task_to_database */
 static char return_copy_task_to_database[ORDER_ID_LENGTH + ID_LENGTH +1];
 
 /** copy task to group in selected database with new tid
  * @return new tid
  * @param[in] tid task id
  * @param[in] group task id
  * @param[in] location database name in data section of easydoneit.ini
  * @ingroup EDI_CORE
  */
 const char *copy_task_to_database(const char *tid, const char *location, const char *group) {
 	// Generate new tid
 	char *newtid;
 	newtid = return_copy_task_to_database;
 	strcpy(newtid, generate_id());
 	// Copy task in tasks
 	// add / to copy files in task
 	char *tidPath = (char*) generate_task_path(tid);
 	strcat(tidPath, "/");
 	copy(tidPath,generate_task_path_in_database(newtid,location));
 	// delete tid/groups because new task is not linked
 	char task_linked_groups_path[8192];
 	sprintf(task_linked_groups_path, "%s/groups/", generate_task_path_in_database(newtid,location));
 	if (fileExists(task_linked_groups_path)) {
 		rmAllG(task_linked_groups_path);
 	}
 	// Copy group in groups and in tree
 	if (is_this_task_a_group(tid)) {
 		// create new group
 		// add / to copy files in task
 		tidPath = (char*) generate_task_path(tid);
 		strcat(tidPath, "/");
 		copy(tidPath,generate_group_path_in_database(newtid,location));
 		// Change group title task to newtid
 		char tPath[8192];
 		sprintf(tPath, "%s/%s%s", generate_group_path_in_database(newtid,location), baseconvert(0), tid);
 		char ntPath[8192];
 		sprintf(ntPath, "%s/%s%s", generate_group_path_in_database(newtid,location), baseconvert(0), newtid);
 		shRename(tPath, ntPath);
 
 		// delete tasks to be recreated with new tid
 		smallArrayt *tasks = readDirG(rtSmallArrayt, generate_group_path_in_database(newtid,location));
 		forEachSmallArray(tasks, T) {
 			castS(t, T);
 			sprintf(tPath, "%s/%s", generate_group_path_in_database(newtid,location), ssGet(t));
 			rmAll(tPath);
 			finishG(t);
 		}
 		terminateG(tasks);
 
 		// Add group in tree
 		char location_tree[8192];
 		char *locPath = getG(selected_d, rtChar, location);
 		sprintf(location_tree, "%s/tree", locPath);
 		if (eqG(group, "root")) {
 			sprintf(tPath, "%s/%s", location_tree, newtid);
 			mkdirParentsG(tPath);
 		}
 		else {
 			sprintf(tPath, "%s/%s", find_group_in_tree_in_database(group,location), newtid);
 			mkdirParentsG(tPath);
 		}
 	}
 
 
 	// Add reference in group
 	// Create reference in destination group
 	add_task_to_group_folder_in_database(newtid, group, location);
 
 	if (is_this_task_a_group(tid)) {
 		// walk in group
 		// list items in group
 		smallArrayt *tasks = readDirG(rtSmallArrayt, generate_group_path(tid));
 
 		// add group found in first group
 		forEachSmallArray(tasks, T) {
 			castS(t, T);
 			// Check tasks that are not title task in a group
 			if (eqG(ssGet(t)+ORDER_ID_LENGTH, tid)) {
 				// copy_task_to_database recursively
 				copy_task_to_database(ssGet(t)+ORDER_ID_LENGTH,location,newtid);
 			}
 			finishG(t);
 		}
 		terminateG(tasks);
 	}
 	return newtid;
 }
 
 /** move task to database/group
  * @param[in] tgroup group id for task tid
  * @param[in] tid task id
  * @param[in] location database name in data section of easydoneit.ini
  * @param[in] group destination group id
  * @ingroup EDI_CORE
  * copy and delete
  */
 const char *move_task_to_a_group_to_database(const char *tgroup, const char *tid, const char *location, const char *group) {
 	const char *newtid = copy_task_to_database(tid,location,group);
 	if (is_this_task_a_group(tid)) {
 		delete_group(tid);
 	}
 	else {
 		delete_linked_task(tgroup,tid);
 	}
 	return newtid;
 }
 
 /** add reference to tid in group
  * @param[in] tid task id
  * @param[in] group destination group id
  * @ingroup EDI_CORE
  * Used in edi ln to link tasks
  */
 void add_task_reference_to_a_group(const char *tid, smallStringt *group) {
 	char p[8192];
 	// Check if selected item is a task
 	if (not is_this_task_a_group(tid)) {
 		// add group to task folder
 		createTaskPath(task_path, "groups");
 		FILE *f;
 		if (not fileExists(task_path)) {
 			mkdirParentsG(task_path);
 
 			// add first group when task is linked to tid/groups/
 			const char *first_group = find_group_containing_task(tid);
 			sprintf(p, "%s/%s", task_path, first_group);
 			f = fopen(p, "w");
 			fclose(f);
 		}
 		sprintf(p, "%s/%s", task_path, ssGet(group));
 		f = fopen(p, "w");
 		fclose(f);
 
 		// add task to group
 		add_task_to_group_folder(tid, ssGet(group));
 	}
 
 	sprintf(p, "linked %s to group %s", tid, ssGet(group));
 	edi_log(p);
 }
 
 /** set status for tid
  * @param[in] tid task id
  * @param[in] status_number index in edi_core.TASK_STATUS
  * @ingroup EDI_CORE
  */
 void set_status(const char *tid, i16 status_number) {
 	// Change status
 	createTaskPath(tpath, "status");
 	writeFileG(TASK_STATUS[status_number], tpath);
 	sprintf(tpath, "set status for %s to %s", tid, TASK_STATUS_TRIM[status_number]);
 	edi_log(tpath);
 }
 
 /* ## set all tasks in group to active */
 /* # @param[in] tid task id */
 /* # @ingroup EDI_CORE */
 /* def reset_group_status tid */
 /* 	group_tasks = os.listdir(generate_group_path(tid)) */
 /* 	for t in group_tasks */
 /* 		if (not is_this_task_a_group(t[ORDER_ID_LENGTH:])) or (is_this_task_a_group(t[ORDER_ID_LENGTH:]) and (get_status(t[ORDER_ID_LENGTH:]) != TASK_STATUS[TASK_STATUS_VOID])) */
 /* 			set_status(t[ORDER_ID_LENGTH:],TASK_STATUS_ACTIVE) */
 /* 	edi_log('reset group %s'%tid) */
 /*  */
 /** search string in tasks folder
  * @param[in] search query string
  * @ingroup EDI_CORE
  */
 smallArrayt *search_string(const char *search){
 	smallArrayt *tasks  = walkDirG(rtSmallArrayt, data_location_tasks);
 
 	// search in descriptions only
 	createAllocateSmallArray(grep_r);
 	forEachSmallArray(tasks, TID) {
 		castS(tido, TID);
 		if (not eqG(tido, "root")) {
 			// search in visible tasks only (filter enable status)
 			const char *task_status = get_status(ssGet(tido));
 			if (getG(status_filters_d, rtI32, task_status) == ENABLE) {
 				/* if platform.system() = 'Windows' */
 				/* 	// in windows, grep in python */
 				/* 	f          = open generate_task_path(tid)+os.sep+'description.txt' */
 				/* 	f_lines    = f readlines */
 				/* 	f close */
 				/* 	grep_lines = [] */
 				/* 	for l in f_lines */
 				/* 		if search lower in l lower */
 				/* 			grep_lines append l */
 				/* else */
 				char *tid   = ssGet(tido);
 				createTaskPath(dPath, "description.txt");
 				createAllocateSmallArray(grep_lines);
 				char c[16384];
 				sprintf(c, "grep -i \"%s\" %s", search, dPath);
 				execO(c, grep_lines, NULL);
 				// add tid and filename to results
 				sprintf(dPath, "/%s/description.txt:", tid);
 				forEachSmallArray(grep_lines, H) {
 					castS(h, H);
 					createAllocateSmallArray(a);
 					pushG(a, dPath);
 					pushNFreeG(a, h);
 					pushG(a, tid);
 					pushNFreeG(grep_r, a);
 				}
 				terminateG(grep_lines);
 			}
 		}
 		finishG(tido);
 	}
 
 	// r lists all hits
 	createAllocateSmallArray(r);
 	forEachSmallArray(grep_r, L) {
 		cast(smallArrayt *, l_l, L);
 		// replace filename with tid and title (first line in file)
 		// read first line in file
 		char *hit_filename = getG(l_l, rtChar, 0);
 		char task_path[8192];
 		sprintf(task_path, "%s/%s", data_location_tasks, hit_filename);
 		FILE *f = fopen(task_path, "r");
 		char *title = readLineG(rtChar, f);
 		trimG(&title);
 		fclose(f);
 		// set tid
 		char *tid          = getG(l_l, rtChar, 2);
 		char *group = "     ";
 		if (is_this_task_a_group(tid)) {
 			group = "GROUP";
 		}
 		if (is_linked(tid)) {
 			group = " LINK";
 		}
 		char l[16384];
 		sprintf(l, "%s %s - %s:%s", tid,group,title, getG(l_l, rtChar, 1));
 		free(title);
 		pushG(r, l);
 		finishG(l_l);
 	}
 	terminateG(grep_r);
 
 	return r;
 }
 
 /** search string in group
  * @param[in] group task id
  * @param[in] search query string
  * @ingroup EDI_CORE
  */
 smallArrayt *search_string_in_group(const char *group, const char *search) {
 
 	smallArrayt *tasks  = readDirG(rtSmallArrayt, generate_group_path(group));
 
 	// r lists all hits
 	createAllocateSmallArray(r);
 	forEachSmallArray(tasks, O) {
 		castS(orderidtid, O);
 		// tid for current task in group
 		char *tid   = ssGet(orderidtid)+ORDER_ID_LENGTH;
 		// search in visible tasks only (filter enable status)
 		const char *task_status = get_status(tid);
 		createAllocateSmallArray(grep_r);
 		if (getG(status_filters_d, rtI32, task_status) == ENABLE) {
 			/* if platform.system() = 'Windows' */
 			/* 	// in windows, grep in python */
 			/* 	f          = open generate_task_path(tid)+os.sep+'description.txt' */
 			/* 	f_lines    = f readlines */
 			/* 	f close */
 			/* 	grep_lines = [] */
 			/* 	for l in f_lines */
 			/* 		if search lower in l lower */
 			/* 			grep_lines append l */
 			/* else */
 			createTaskPath(dPath, "description.txt");
 			createAllocateSmallArray(grep_lines);
 			char c[16384];
 			sprintf(c, "grep -i \"%s\" %s", search, dPath);
 			execO(c, grep_lines, NULL);
 			// add tid and filename to results
 			sprintf(dPath, "/%s/description.txt", tid);
 			forEachSmallArray(grep_lines, H) {
 				castS(h, H);
 				createAllocateSmallArray(a);
 				pushG(a, dPath);
 				pushG(a, ssGet(h));
 				pushG(a, tid);
 				pushNFreeG(grep_r, a);
 				finishG(h);
 			}
 			terminateG(grep_lines);
 		}
 
 		forEachSmallArray(grep_r, L) {
 			cast(smallArrayt *, l_l, L);
 			// replace filename with tid and title (first line in file)
 			// read first line in file
 			char *hit_filename = getG(l_l, rtChar, 0);
 			char task_path[8192];
 			sprintf(task_path, "%s/%s", data_location_tasks, hit_filename);
 			FILE *f = fopen(task_path, "r");
 			if (!f) {
 				pFuncError
 				shEPrintfS("The path was: \"%s\"\n", task_path);
 			}
 			char *title = readLineG(rtChar, f);
 			trimG(&title);
 			fclose(f);
 			// set tid
 			tid         = getG(l_l, rtChar, 2);
 			char *group = "     ";
 			if (is_this_task_a_group(tid)) {
 				group = "GROUP";
 			}
 			if (is_linked(tid)) {
 				group = " LINK";
 			}
 			char l[16384];
 			sprintf(l, "%s %s - %s:%s", tid,group,title, getG(l_l, rtChar, 1));
 			free(title);
 			pushG(r, l);
 			finishG(l_l);
 		}
 		terminateG(grep_r);
 		finishG(orderidtid);
 	}
 	terminateG(tasks);
 	return r;
 }
 
 /** search string in tree
  * @param[in] group task id
  * @param[in] search query string
  * @ingroup EDI_CORE
  */
 smallArrayt *search_string_in_tree(const char *group, const char *search) {
 	// walk_group is the list of groups to visit. FIFO
 	createAllocateSmallArray(r);
 	createAllocateSmallArray(walk_group);
 	pushG(walk_group, group);
 	// the while loop goes through all the group that are found
 	while (lenG(walk_group)) {
 		// list items in first group
 		smallArrayt *tasks = readDirG(rtSmallArrayt ,generate_group_path(getG(walk_group, rtChar, 0)));
 		appendNSmashG(r, search_string_in_group(getG(walk_group, rtChar,0), search));
 
 		// add group found in first group
 		forEachSmallArray(tasks, T) {
 			castS(t, T);
 			// Check tasks that are not title task in a group
 			if (not eqG(ssGet(t)+ORDER_ID_LENGTH, getG(walk_group, rtChar, 0)) and is_this_task_a_group(ssGet(t) + ORDER_ID_LENGTH)) {
 				pushG(walk_group, ssGet(t)+ORDER_ID_LENGTH);
 			}
 			finishG(t);
 		}
 		terminateG(tasks);
 
 		// remove first group to list items in next group
 		delG(walk_group, 0, 1);
 	}
 	terminateG(walk_group);
 	return r;
 }
 
 /* ## build tree recursively */
 /* # @param[in] group group path in tree starting with os.sep */
 /* # @return group_tree list of groups in tree starting from group */
 /* # @ingroup EDI_CORE */
 /* def build_group_tree group */
 /* 	# list groups */
 /* 	# call build_group_tree recursively */
 /*  */
 /* 	# list groups */
 /* 	group_path    = generate_group_path(group.split(os.sep)[-1]) */
 /*  */
 /* 	groups        = sorted(os.listdir(group_path)) */
 /*  */
 /* 	if group != 'root' */
 /* 		# first task is group title */
 /* 		del groups[0] */
 /* 	else */
 /* 		# empty string for root */
 /* 		group = '' */
 /*  */
 /* 	only_groups   = [] */
 /* 	for g in groups */
 /* 		if is_this_task_a_group(g[ORDER_ID_LENGTH:]) */
 /* 			# complete tree path in only_groups */
 /* 			only_groups append '%s%s%s' % (group, os.sep, g[ORDER_ID_LENGTH:]) */
 /*  */
 /* 	# call build_group_tree recursively */
 /* 	group_tree = [] */
 /* 	if only_groups */
 /* 		for g in only_groups */
 /* 			group_tree append g */
 /* 			group_tree += build_group_tree(g) */
 /* 	return group_tree */
 /*  */
 /* ## build tree in order */
 /* # @param[in] group group path in tree or root */
 /* # @return group_tree list of groups in tree starting from group */
 /* # @ingroup EDI_CORE */
 /* def build_tree group */
 /* 	tidtree = build_group_tree(group) */
 /* 	return tidtree */
 /*  */
 /* ## show tree */
 /* #  @ingroup EDI_CORE */
 /* # print all trees: group tids and titles */
 /* def show_tree */
 /* 	r       = [] */
 /*  */
 /* 	tidtree = build_tree('root') */
 /*  */
 /* 	# remove '/' from path */
 /* 	tidtree = [i[1:] for i in tidtree] */
 /*  */
 /* 	# print titles path\n group tid path\n\n */
 /* 	for l in tidtree */
 /* 		# find title for group tids */
 /* 		group_titles_in_path = [] */
 /* 		for g in l strip.split(os.sep) */
 /* 			group_titles_in_path append get_task_title(g) */
 /* 		if user_interface = 'web' */
 /* 			# convert / to - to be able to create links correctly */
 /* 			group_titles_in_path = [i.replace(os.sep, '-') for i in group_titles_in_path] */
 /* 		# create string title/title... */
 /* 		group_titles_in_path_s = '/'.join(group_titles_in_path) */
 /* 		r append '%s\n'%group_titles_in_path_s */
 /* 		r append '%s\n'%l */
 /*  */
 /* 	return r */
 /*  */
 /* ## group statistics */
 /* #  @ingroup EDI_CORE */
 /* # print statistics for a group recursively */
 /* def group_statistics group */
 /* 	global stats */
 /* 	global stats_total */
 /* 	global stats_creation_dates */
 /* 	global stats_overtime */
 /*  */
 /* 	# compute total number of tasks in group */
 /* 	path = generate_group_path(group) */
 /*  */
 /* 	tasks         = [] */
 /* 	# remove group title */
 /* 	for i in os.listdir(path) */
 /* 		if not baseconvert(0) in i[:ORDER_ID_LENGTH] */
 /* 			tasks append i[ORDER_ID_LENGTH:] */
 /*  */
 /* 	stats_total   += len(tasks) */
 /*  */
 /* 	# compute number of tasks in each state, groups and links */
 /* 	for tid in tasks */
 /* 		task_status        = get_status(tid) */
 /* 		stats[task_status] += 1 */
 /* 		if is_this_task_a_group(tid) */
 /* 			stats['   Group'] += 1 */
 /* 			group_statistics(tid) */
 /* 		if is_linked(tid) */
 /* 			stats['  Linked'] += 1 */
 /*  */
 /* 		#stats_creation_dates */
 /* 		# Figure out creation time and modification time for description */
 /* 		task_ctime         = get_creation_date(tid)[1] */
 /*  */
 /* 		task_path         = generate_task_path(tid) */
 /* 		(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(task_path+os.sep+'description.txt') */
 /* 		# 'if' below to be compatible with first database format */
 /* 		if task_ctime = 0 */
 /* 			# ctime not available */
 /* 			task_ctime = mtime */
 /* 		stats_creation_dates append task_ctime */
 /*  */
 /* 		(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(task_path+os.sep+'status') */
 /*  */
 /* 		cdate = time.strftime("%Y-%m-%d", time.localtime(task_ctime)) */
 /* 		sdate = time.strftime("%Y-%m-%d", time.localtime(mtime)) */
 /* 		if not stats_overtime.has_key(cdate) */
 /* 			# initialize date dict */
 /* 			stats_overtime[cdate] = dict(zip(STATS_OVERTIME_KEYS,[0 for i in range(len(STATS_OVERTIME_KEYS))])) */
 /* 		stats_overtime[cdate]['Creation'] += 1 */
 /* 		if not stats_overtime.has_key(sdate) */
 /* 			# initialize date dict */
 /* 			stats_overtime[sdate] = dict(zip(STATS_OVERTIME_KEYS,[0 for i in range(len(STATS_OVERTIME_KEYS))])) */
 /* 		stats_overtime[sdate][task_status] += 1 */
 /* 		#end */
 /*  */
 /* ## statistics */
 /* #  @ingroup EDI_CORE */
 /* # print statistics for a group or a database */
 /* # compute speed */
 /* def statistics group */
 /* 	global stats */
 /* 	global stats_total */
 /* 	global stats_creation_dates */
 /* 	global stats_overtime */
 /* 	r = [] */
 /*  */
 /* 	# initialize stats dictionary */
 /* 	stat_keys     = [TASK_STATUS[i] for i in range(len(TASK_STATUS))] */
 /* 	stat_keys append '   Group' */
 /* 	stat_keys append '  Linked' */
 /* 	state_amounts = [0 for i in range(len(stat_keys))] */
 /* 	stats         = dict(zip(stat_keys,state_amounts)) */
 /*  */
 /* 	if group = 'for database' */
 /* 		# compute total number of tasks, excluding root */
 /* 		path          = data_location_tasks */
 /* 		tasks         = [] */
 /* 		for i in os.listdir(path) */
 /* 			if i != 'root' */
 /* 				tasks append i */
 /*  */
 /* 		# compute number of tasks in each state, groups and links */
 /* 		for tid in tasks */
 /* 			task_status        = get_status(tid) */
 /* 			stats[task_status] += 1 */
 /* 			if is_this_task_a_group(tid) */
 /* 				stats['   Group'] += 1 */
 /* 			if is_linked(tid) */
 /* 				stats['  Linked'] += 1 */
 /*  */
 /* #:define stats_creation_dates */
 /* 			# Figure out creation time and modification time for description */
 /* 			task_ctime         = get_creation_date(tid)[1] */
 /*  */
 /* 			task_path         = generate_task_path(tid) */
 /* 			(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(task_path+os.sep+'description.txt') */
 /* 			if task_ctime = 0 */
 /* 				# ctime not available */
 /* 				task_ctime = mtime */
 /* 			stats_creation_dates append task_ctime */
 /*  */
 /* 			(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(task_path+os.sep+'status') */
 /*  */
 /* 			cdate = time.strftime("%Y-%m-%d", time.localtime(task_ctime)) */
 /* 			sdate = time.strftime("%Y-%m-%d", time.localtime(mtime)) */
 /* 			if not stats_overtime.has_key(cdate) */
 /* 				# initialize date dict */
 /* 				stats_overtime[cdate] = dict(zip(STATS_OVERTIME_KEYS,[0 for i in range(len(STATS_OVERTIME_KEYS))])) */
 /* 			stats_overtime[cdate]['Creation'] += 1 */
 /* 			if not stats_overtime.has_key(sdate) */
 /* 				# initialize date dict */
 /* 				stats_overtime[sdate] = dict(zip(STATS_OVERTIME_KEYS,[0 for i in range(len(STATS_OVERTIME_KEYS))])) */
 /* 			stats_overtime[sdate][task_status] += 1 */
 /* #:end */
 /*  */
 /* 		stats_total   = len(tasks) */
 /* 	else */
 /* 		# compute total number of tasks in group */
 /* 		path = generate_group_path(group) */
 /*  */
 /* 		tasks         = [] */
 /* 		for i in os.listdir(path) */
 /* 			if group = 'root' */
 /* 				tasks append i[ORDER_ID_LENGTH:] */
 /* 			else */
 /* 				# the group task is not counted in the statistics */
 /* 				if not baseconvert(0) in i[:ORDER_ID_LENGTH] */
 /* 					tasks append i[ORDER_ID_LENGTH:] */
 /*  */
 /* 		stats_total   = len(tasks) */
 /*  */
 /* 		# compute number of tasks in each state, groups and links, recursively */
 /* 		for tid in tasks */
 /* 			task_status        = get_status(tid) */
 /* 			stats[task_status] += 1 */
 /* 			if is_this_task_a_group(tid) */
 /* 				stats['   Group'] += 1 */
 /* 				group_statistics(tid) */
 /* 			if is_linked(tid) */
 /* 				stats['  Linked'] += 1 */
 /*  */
 /* #:stats_creation_dates */
 /*  */
 /* 	if not stats_total */
 /* 		r append '0 task in statistics.' */
 /* 		return r */
 /*  */
 /* 	# csv format, not used for now */
 /* 	#col_names = ['Tasks'] + sorted(stats.keys()) */
 /* 	#col_names = [i strip for i in col_names] */
 /* 	#print ','.join(col_names) */
 /* 	#csv = '%d'%len(tasks) */
 /* 	#for k in sorted(stats.keys()) */
 /* 	#	csv += ',%d'%stats[k] */
 /* 	#r append csv */
 /* 	#r append '' */
 /*  */
 /* 	r append 'Number of items: %d\n'%stats_total */
 /* 	for k in sorted(stats.keys()) */
 /* 		r append '%s - %d'%(k, stats[k]) */
 /* 	r append '' */
 /*  */
 /* 	# speed */
 /* 	start_time        = sorted(stats_creation_dates)[0] */
 /* 	now               = time.time() */
 /* 	done_and_inactive = stats[TASK_STATUS[TASK_STATUS_DONE]] + stats[TASK_STATUS[TASK_STATUS_INACTIVE]] */
 /* 	if not done_and_inactive */
 /* 		r append 'Nothing is done or inactive' */
 /* 	else */
 /* 		# subtract tasks in state void, because tasks in void state are informative or groups */
 /* 		number_of_tasks   = stats_total - stats[TASK_STATUS[TASK_STATUS_VOID]] */
 /* 		remaining_tasks   = number_of_tasks - done_and_inactive */
 /* 		remaining_time    = (now - start_time) / float(done_and_inactive) * remaining_tasks */
 /* 		r append 'Number of tasks (excluding voids): %d'%number_of_tasks */
 /* 		r append 'Remaining tasks:                   %d'%remaining_tasks */
 /* 		r append 'Remaining days:                    %.3f'%(remaining_time/86400) */
 /* 		r append 'Start date:                        %s'%time.strftime("%Y-%m-%d", time.localtime(start_time)) */
 /* 		r append "Today's date:                      %s"%time.strftime("%Y-%m-%d", time.localtime(now)) */
 /* 		r append 'Finish date:                       %s'%time.strftime("%Y-%m-%d", time.localtime(now + remaining_time)) */
 /*  */
 /* 	# create csv stats from stats_overtime */
 /* 	f = open data_location+os.sep+'stats.csv' w */
 /* 	f write 'date,%s\n'%','.join([i strip for i in STATS_OVERTIME_KEYS]) */
 /*  */
 /* 	for d in sorted(stats_overtime keys) */
 /* 		f write '%s,%s\n'%(d, ','.join([str(stats_overtime[d][i]) for i in STATS_OVERTIME_KEYS])) */
 /* 	f close */
 /*  */
 /* 	# create creation, done and inactive stats */
 /* 	f = open data_location+os.sep+'stats_creation_done_inactive.csv' w */
 /* 	f write 'date,Creation,Done/Inactive\n' */
 /*  */
 /* 	for d in sorted(stats_overtime keys) */
 /* 		f write '%s,%d,%d\n'%(d, stats_overtime[d]['Creation'], stats_overtime[d][TASK_STATUS[TASK_STATUS_DONE]] + stats_overtime[d][TASK_STATUS[TASK_STATUS_INACTIVE]]) */
 /* 	f close */
 /*  */
 /* 	r append '' */
 /* 	return r */
 /*  */
 /* ## create secret */
 /* #  @ingroup EDI_CORE */
 /* # encrypts description.txt in tid */
 /* # the title remains clear */
 /* def create_secret tid */
 /*  */
 /* 	# encrypt description.txt to description.txt.gpg */
 /* 	tdir = generate_task_path(tid) +os.sep */
 /* 	path = tdir+'description.txt' */
 /* #:define encrypt */
 /* 	os.system 'gpg -c --cipher-algo AES256 %s' % path */
 /* 	# delete clear text */
 /* 	os.rename(path, tdir+'tmp') */
 /* 	# create clear title */
 /* 	os.system 'head -n 1 %s > %s' % (tdir+'tmp', path) */
 /* 	os.remove tdir+'tmp' */
 /* #:end */
 /*  */
 /* ## edit secret */
 /* #  @ingroup EDI_CORE */
 /* # decrypts description.txt.gpg to description.txt */
 /* # starts text editor */
 /* # encrypts description.txt in tid */
 /* # the title remains clear */
 /* def edit_secret tid */
 /*  */
 /* 	# delete clear description.txt (holding the title) */
 /* 	tdir = generate_task_path(tid) +os.sep */
 /* 	path = tdir+'description.txt' */
 /* 	os.remove path */
 /* 	os.system 'gpg %s' % (path+'.gpg') */
 /* 	os.remove path+'.gpg' */
 /* 	# start text editor */
 /* 	edit_task(tid) */
 /* #:encrypt */
 /*  */
 /* ## for your eyes only */
 /* #  @ingroup EDI_CORE */
 /* # print secret and hide passwords */
 /* def fyeo tid */
 /*  */
 /* 	# decrypt description.txt.gpg to stdout */
 /* 	f = os.popen 'gpg -d %s' % generate_task_path(tid) +os.sep+'description.txt.gpg' */
 /* 	t = f readlines */
 /* 	f close */
 /* 	for l in t */
 /* 		# hide text after the word password on lines starting with password */
 /* 		if l lower[:8] = 'password' */
 /* 			L = l strip.split(' ') */
 /* 			p = L[0] */
 /* 			del L[0] */
 /* 			s = ' '.join(L) */
 /* 			print '%s \033[1;8m\033[1;41m%s\033[0;0m' %(p, s) */
 /* 		else */
 /* 			# print normal text */
 /* 			print l rstrip */
 /*  */
 
 /**
  * list text for all tasks in list
  * @param
  *   tid group to show
  * @return
  *   array containing all task descriptions in group
  */
 smallArrayt *listTasksInList(smallArrayt *ls) {
 	createAllocateSmallArray(r);
 	forEachSmallArray(ls, T) {
 		cast(smallDictt*, d, T);
 		if (not eqG(getG(d, rtChar, "tid"), "")) {
 			smallArrayt *desc = display_task(getG(d, rtChar, "tid"), passThroughTitle);
 			pushG(r, "---");
 			appendNSmashG(r, desc);
 		}
 		finishG(d);
 	}
 	return r;
 }
 
 /**
  * list text for all tasks in group tid
  * @param
  *   tid group to show
  * @return
  *   array containing all task descriptions in group
  */
 smallArrayt *listTasksInGroup(const char *tid) {
 	createAllocateSmallArray(r);
 	if (is_this_task_a_group(tid)) {
 		// list_group...
 		smallArrayt *ls = list_group(tid);
 		forEachSmallArray(ls, T) {
 			cast(smallDictt*, d, T);
 			if (not eqG(getG(d, rtChar, "tid"), "")) {
 				smallArrayt *desc = display_task(getG(d, rtChar, "tid"), passThroughTitle);
 				pushG(r, "---");
 				appendNSmashG(r, desc);
 			}
 			finishG(d);
 		}
 		terminateG(ls);
 	}
 	return r;
 }
 
 /**
  * list text in bookmarks
  * @return
  *   array containing all task descriptions in the bookmarks
  */
 smallArrayt *listTasksInBookmarks(void) {
 	createAllocateSmallArray(r);
 	forEachSmallArray(bookmarks, T) {
 		castS(s, T);
 		smallArrayt *desc = display_task(ssGet(s), passThroughTitle);
 		pushG(r, "---");
 		appendNSmashG(r, desc);
 		finishG(s);
 	}
 	return r;
 }
 
 /** clear edi_core buffers
  * @ingroup EDI_DESKTOP
  */
 void edi_core_clear_previous_run(void) {
 	emptyG(group_directory_file_list);
 	if (agenda) {
 		emptyG(agenda);
 	}
 }
 
 /** search tid in all selected databases
  * @return r empty when tid is not found, 'tid exists' when found
  * @param[in] tid task or group id
  * @ingroup EDI_DESKTOP
  * The setup of the database for tid is kept
  */
 bool tid_exists(const char *tid) {
 	bool r = false;
 	// clear edi_core variable because the database setup can change
 	edi_core_clear_previous_run();
 	forEachSmallArray(selected_path, P) {
 		castS(path, P);
 		freeManyS(data_location, data_location_tasks, data_location_groups, data_location_tree);
 		data_location        = dupG(ssGet(path));
 
 		data_location_tasks  = appendG(data_location, "/tasks");
 		data_location_groups = appendG(data_location, "/groups");
 		data_location_tree   = appendG(data_location, "/tree");
 
 		if (not fileExists(data_location)) {
 			//strcpy(result_select_database, data_location);
 			//strcat(result_select_database, " is unreachable");
 			finishG(P);
 			break;
 		}
 
 		if (fileExists(generate_task_path(tid))) {
 			r = true;
 			finishG(P);
 			break;
 		}
 		finishG(P);
 	}
 	return r;
 }
 
 /** search tid in all selected databases
  * @param[in] tid task or group id
  * @ingroup EDI_DESKTOP
  * The setup of the database for tid is kept.
  * Same as tid_exists without return value.
  */
 bool setup_data_location_for_tid(const char *tid) {
 	return tid_exists(tid);
 }
 
 /** save current database path in saved_data_location
  * @ingroup EDI_DESKTOP
  */
 void save_edi_core_data_location(void) {
 	//debug print 'save'
 	free(saved_data_location);
 	saved_data_location = dupG(data_location);
 }
 
 /** restore saved_data_location
  * @ingroup EDI_DESKTOP
  */
 void restore_edi_core_data_location(void) {
 	//debug print 'restore'
 
 	freeManyS(data_location, data_location_tasks, data_location_groups, data_location_tree);
 	data_location        = saved_data_location;
 	saved_data_location  = NULL;
 
 	data_location_tasks  = appendG(data_location, "/tasks");
 	data_location_groups = appendG(data_location, "/groups");
 	data_location_tree   = appendG(data_location, "/tree");
 
 	// clear edi_core variable because the database setup can change
 	edi_core_clear_previous_run();
 }
 
 char return_getDatabaseNameFromPath[8192];
 
 const char *getDatabaseNameFromPath(const char *database_path) {
 	return_getDatabaseNameFromPath[0] = 0;
 	forEachSmallDict(selected_d, k, V) {
 		castS(v, V);
 		if (eqG(v, database_path)) {
 			strcpy(return_getDatabaseNameFromPath, k);
 			finishG(v);
 			break;
 		}
 		finishG(v);
 	}
 	listFreeS(libsheepyInternalKeys);
 	return return_getDatabaseNameFromPath;
 }
 
 // test core functions
 void test(void) {
 	// test
 	group_directory_file_list = walkDirG(rtSmallArrayt, data_location_groups);
 	logG(group_directory_file_list);
 	return;
 	smallArrayt *ls = list_group("root");
 
 	forEachSmallArray(ls, L) {
 		cast(smallDictt*, d, L)
 		putsG(d);
 		finishG(d);
 	}
 	forEachSmallArray(ls, L) {
 		cast(smallDictt*, d, L)
 		putsG(getG(d, rtChar, "title"));
 		finishG(d);
 	}
 	terminateG(ls);
 
 	smallArrayt *desc = display_task("RUkjgkUSsDYREKqM", generate_task_string_with_tid);
 	logG(desc);
 	terminateG(desc);
 
 	/* t1 = add_task('root', 'task1.txt') */
 	/* add_task('root', 'task2.txt') */
 	/* g3 = add_task('root', 'task3.txt') */
         /*  */
 	/* create_group(g3) */
 	/* t4 = add_task(g3, 'task4.txt') */
         /*  */
 	/* list_group('root') */
 	/* list_group(g3) */
         /*  */
 	/* //display_task(t1) */
 	/* //display_task(t4) */
         /*  */
 	/* // Delete task in a group of 2 tasks */
 	/* print '// Delete task in a group of 2 tasks' */
 	/* delete_task(t4) */
         /*  */
 	/* list_group('root') */
         /*  */
 	/* create_group(g3) */
 	/* t4 = add_task(g3, 'task4.txt') */
         /*  */
 	/* list_group('root') */
         /*  */
 	/* // Delete group first task */
 	/* print '// Delete group first task' */
 	/* delete_task(g3) */
         /*  */
 	/* list_group('root') */
         /*  */
 	/* // Delete group task of a group with more than 2 tasks */
 	/* print '// Delete group task of a group with more than 2 tasks' */
 	/* delete_task(t4) */
         /*  */
 	/* g3 = add_task('root', 'task3.txt') */
 	/* create_group(g3) */
 	/* t4 = add_task(g3, 'task4.txt') */
 	/* t2 = add_task(g3, 'task2.txt') */
         /*  */
 	/* list_group('root') */
 	/* list_group(g3) */
 	/* new_group_id = delete_task(g3) */
 	/* print 'New group id %s'%new_group_id */
         /*  */
 	/* list_group('root') */
 	/* list_group(new_group_id) */
         /*  */
 	/* // Delete group */
 	/* print '// Delete group' */
 	/* delete_group(new_group_id) */
         /*  */
 	/* list_group('root') */
         /*  */
 	/* print baseconvert(100) */
 	/* print baseconvert_to_dec(baseconvert(100)) */
 	/* print */
         /*  */
 	/* //edit_task(t1) */
         /*  */
 	/* // Change order */
 	/* print '// Change order' */
 	/* g3 = add_task('root', 'task3.txt') */
 	/* change_task_order('root',1,0) */
 	/* change_task_order('root',0,2) */
         /*  */
 	/* list_group('root') */
         /*  */
 	/* // Change status */
 	/* print '// Change status' */
 	/* create_group(g3) */
 	/* t4 = add_task(g3, 'task4.txt') */
 	/* t2 = add_task(g3, 'task2.txt') */
         /*  */
 	/* list_group('root') */
         /*  */
 	/* set_status(t1,TASK_STATUS_DONE) */
 	/* set_status(t4,TASK_STATUS_DONE) */
         /*  */
 	/* list_group('root') */
 	/* list_group(g3) */
         /*  */
 	/* // Reset status */
         /*  */
 	/* reset_group_status(g3) */
         /*  */
 	/* list_group('root') */
 	/* list_group(g3) */
         /*  */
 	/* reset_group_status('root') */
         /*  */
 	/* list_group('root') */
 	/* list_group(g3) */
         /*  */
 	/* // Create a group in group */
 	/* print '// Create a group in group' */
 	/* create_group(t4) */
 	/* t2 = add_task(t4,'task2.txt') */
         /*  */
 	/* list_group('root') */
 	/* list_group(g3) */
 	/* list_group(t4) */
         /*  */
 	/* // Delete task in a group of 2 tasks not in root */
 	/* print '// Delete task in a group of 2 tasks not in root' */
 	/* delete_task(t2) */
         /*  */
 	/* list_group('root') */
 	/* list_group(g3) */
         /*  */
 	/* // Delete group with groups in it */
 	/* print '// Delete group with groups in it' */
 	/* create_group(t4) */
 	/* t2 = add_task(t4,'task2.txt') */
         /*  */
 	/* list_group('root') */
 	/* list_group(g3) */
 	/* list_group(t4) */
         /*  */
 	/* delete_group(g3) */
         /*  */
 	/* list_group('root') */
         /*  */
 	/* // Search string */
 	/* print '// Search string' */
         /*  */
 	/* search_string('AND') */
         /*  */
 	/* // List tree */
 	/* print '// List tree' */
 	/* g3 = add_task('root', 'task3.txt') */
 	/* create_group(g3) */
 	/* t4 = add_task(g3, 'task4.txt') */
 	/* t2 = add_task(g3, 'task2.txt') */
 	/* create_group(t4) */
 	/* t2 = add_task(t4,'task2.txt') */
         /*  */
 	/* list_tree('root') */
         /*  */
 	/* // Show group for a task */
 	/* print '// Show group for a task' */
         /*  */
 	/* print 'Show group for %s - %s' %(t2,get_task_title(t2)) */
 	/* show_group_for_task(t2) */
 	/* print 'Show group for %s - %s' %(t4,get_task_title(t4)) */
 	/* show_group_for_task(t4) */
 	/* print 'Show group for %s - %s' %(t1,get_task_title(t1)) */
 	/* show_group_for_task(t1) */
 
 	// create task
 	//create_task(t4)
 	//list_group(t4)
 }
 
 /** start - always called at startup.
  * @ingroup EDI_CORE
  * @param[in] interface selects current user interface. cli loads the configuration from user home, web loads the configuration located in edi_web folder.
  * creates default .easydoneit.ini<br>
  * creates database folders<br>
  * loads .easydoneit.ini
  */
 void start(char *interface) {
 	// steps
 	// initialize variables
 	// create default config
 	// load config from inipath
 
 	// initialize variables
 	add_top_or_bottom = strdup("bottom");
 	status_filters    = allocG(rtSmallArrayt);
 	//static i16 no_color[4]            = {-1,-1,-1,255};
 	//static i16 status_fgColors[6][4]  = {{0,0,0,255},{0,255,0,255},{255,128,0,255},{255,0,0,255},{192,192,192,255},{0,0,0,255}};
 	no_color          = allocG(rtSmallArrayt);
 	pushG(no_color, -1);
 	pushG(no_color, -1);
 	pushG(no_color, -1);
 	pushG(no_color, 255);
 	status_fgColors   = allocG(rtSmallArrayt);
 	smallArrayt *c    = allocG(rtSmallArrayt);
 	pushG(c, 0);
 	pushG(c, 0);
 	pushG(c, 0);
 	pushG(c, 255);
 	pushNFreeG(status_fgColors, dupG(c));
 	setG(c, 0, 0);
 	setG(c, 1, 255);
 	setG(c, 2, 0);
 	setG(c, 3, 255);
 	pushNFreeG(status_fgColors, dupG(c));
 	setG(c, 0, 255);
 	setG(c, 1, 128);
 	setG(c, 2, 0);
 	setG(c, 3, 255);
 	pushNFreeG(status_fgColors, dupG(c));
 	setG(c, 0, 255);
 	setG(c, 1, 0);
 	setG(c, 2, 0);
 	setG(c, 3, 255);
 	pushNFreeG(status_fgColors, dupG(c));
 	setG(c, 0, 192);
 	setG(c, 1, 192);
 	setG(c, 2, 192);
 	setG(c, 3, 255);
 	pushNFreeG(status_fgColors, dupG(c));
 	setG(c, 0, 0);
 	setG(c, 1, 0);
 	setG(c, 2, 0);
 	setG(c, 3, 255);
 	pushNFreeG(status_fgColors, dupG(c));
 	status_bgColors   = allocG(rtSmallArrayt);
 	range(i, COUNT_ELEMENTS(TASK_STATUS)-1) {
 		pushNFreeG(status_bgColors, dupG(no_color));
 	}
 	//logVarG(no_color);
 	//logVarG(status_fgColors);
 	//logVarG(status_bgColors);
 	group_directory_file_list = allocG(rtSmallArrayt);
 
 	inipath           = "~/.easydoneit.ini";
 	inipath           = expandHomeG(inipath);
 
 	user_interface = interface;
 
 	if (not eqG(user_interface, "tui")) {
 		puts(user_interface);
 		puts(BLD RED "Not supported." RST);
 		XFAILURE
 	}
 	else {
 		if (not fileExists(inipath)) {
 			// create default config
 			createAllocateSmallArray(newcfg);
 			pushG(newcfg, "[data]");
 			pushG(newcfg, "location=~/easydoneit_data");
 			pushG(newcfg, "1=~/easydoneit_data");
 			pushG(newcfg, "");
 			pushG(newcfg, "[locations]");
 			pushG(newcfg, "selected=1");
 			pushG(newcfg, "default_add_in=1");
 			pushG(newcfg, "");
 			pushG(newcfg, "[filters]");
 			// enable all status filters
 			char buf[1024];
 			forEachS(TASK_STATUS, nfilter) {
 				// strip to remove spaces in status strings
 				char *filter = lowerS(nfilter);
 				trimG(&filter);
 				sprintf(buf, "%s= %s", filter, STATUS_FILTER_STATES[0]);
 				free(filter);
 				pushG(newcfg, buf);
 			}
 			pushG(newcfg, "");
 			pushG(newcfg, "[colors]");
 			enumerateS(TASK_STATUS, nfilter, n) {
 				char *filter = lowerS(nfilter);
 				trimG(&filter);
 				smallArrayt *c = getG(status_fgColors, rtSmallArrayt, n);
 				sprintf(buf, "%s_fgColor=%d,%d,%d,%d", filter, getG(c, rtI32, 0),  getG(c, rtI32, 1), getG(c, rtI32, 2), getG(c, rtI32, 3));
 				finishG(c);
 				free(filter);
 				pushG(newcfg, buf);
 			}
 			{enumerateS(TASK_STATUS, nfilter, n) {
 				char *filter = lowerS(nfilter);
 				trimG(&filter);
 				smallArrayt *c = getG(status_bgColors, rtSmallArrayt, n);
 				sprintf(buf, "%s_bgColor=%d,%d,%d,%d", filter, getG(c, rtI32, 0),  getG(c, rtI32, 1), getG(c, rtI32, 2), getG(c, rtI32, 3));
 				finishG(c);
 				free(filter);
 				pushG(newcfg, buf);
 			}}
 
 			pushG(newcfg, "\n[settings]");
 			pushG(newcfg, "editor=vi");
 
 			writeFileG(newcfg, inipath);
 			terminateG(newcfg);
 		}
 	}
 
 	// load config from inipath
 	ini = parseIni(inipath);
 
 	smallDictt *data      = getG(ini, rtSmallDictt, "data");
 	smallDictt *locations = getG(ini, rtSmallDictt, "locations");
 	smallDictt *filters   = getG(ini, rtSmallDictt, "filters");
 	smallDictt *colors    = getG(ini, rtSmallDictt, "colors");
 	smallDictt *settings  = getG(ini, rtSmallDictt, "settings");
 	smallDictt *desktop   = getG(ini, rtSmallDictt, "desktop");
 
 	//logVarG(filters);
 
 	// convert ~ to home path
 	data_location = expandHomeG(getG(data, rtChar,"location"));
 
 	// load available databases
 	char **data_keys          = keysG(data);
 	smallArrayt *data_section = valuesG(data);
 	// remove location which is a path to a database
 	// clear databases for reentrant testing
 	databases = allocG(rtSmallArrayt);
 	enumerateSmallArray(data_section, D, i) {
 		if (not eqG(data_keys[i], "location")) {
 			pushNFreeG(databases, dupG(D));
 		}
 		free(D);
 	}
 	//logVarG(databases);
 
 	// load add_top_or_bottom
 	char **location_keys      = keysG(locations);
 	if (hasG(location_keys, "add_top_or_bottom")) {
 		add_top_or_bottom = getNDupG(locations, rtChar,"add_top_or_bottom");
 	}
 
 	// load selected database paths
 	smallStringt *sselected = getNDupG(locations, rtSmallStringt, "selected");
 	selected            = splitG(sselected, ",");
 	terminateG(sselected);
 	default_add_in      = getNDupG(locations,rtChar, "default_add_in");
 	selected_path       = allocG(rtSmallArrayt);
 	forEachSmallArray(selected, D) {
 		castS(d, D);
 		pushNFreeG(selected_path, expandHomeG(getG(data, rtChar, ssGet(d))));
 		free(D);
 	}
 
 	selected_d = allocG(rtSmallDictt);
 	zipG(selected_d, selected, selected_path);
 	//logVarG(selected_path);
 	//logVarG(selected_d);
 
 	// load autolink groups
 	if (hasG(location_keys, "autolink")) {
 		smallStringt *autolink_cfg = getG(locations, rtSmallStringt,"autolink");
 		autolink                   = allocG(rtSmallArrayt);
 		rangeStep(i, lenG(autolink_cfg), ID_LENGTH+1) {
 			smallStringt *s = copyRngG(autolink_cfg, i, i+ID_LENGTH);
 			pushNFreeG(autolink, s);
 		}
 		finishG(autolink_cfg);
 	}
 	//logVarG(autolink);
 
 	// load list groups
 	if (hasG(location_keys, "list")) {
 		smallStringt *list_cfg = getG(locations, rtSmallStringt, "list");
 		list_of_groups  = splitG(list_cfg, ",");
 	}
 
 	// load status filters and status colors
 	char **config_filter_names = keysG(filters);
 	char **config_color_names  = keysG(colors);
 	enumerateS(TASK_STATUS, nfilter, n) {
 		// strip to remove spaces in status strings
 		// check that task_status filter is in config file, to avoid problems between config file versions
 		char *filter = lowerS(nfilter);
 		trimG(&filter);
 		pushG(&TASK_STATUS_TRIM, filter);
 		if (hasG(config_filter_names, filter)) {
 			smallStringt *s = getG(filters, rtSmallStringt, filter);
 			if (eqG(s, STATUS_FILTER_STATES[DISABLE])) {
 				pushG(status_filters, DISABLE);
 			}
 			else {
 				pushG(status_filters, ENABLE);
 			}
 			finishG(s);
 		}
 		char *fc = appendG(filter, "_fgcolor");
 		if (hasG(config_color_names, fc)) {
 			smallStringt *s = getG(colors, rtSmallStringt, fc);
 			smallArrayt *a  = splitG(s, ",");
 
 			// convert a strings to int
 			enumerateSmallArray(a, CP, ci) {
 				castS(cp, CP);
 				setG(a, ci, parseIntG(cp));
 				finishG(cp);
 			}
 			setNFreeG(status_fgColors, n, a);
 			finishG(s);
 		}
 		free(fc);
 		fc = appendG(filter, "_bgcolor");
 		if (hasG(config_color_names, fc)) {
 			smallStringt *s = getG(colors, rtSmallStringt, fc);
 			smallArrayt *a  = splitG(s, ",");
 
 			// convert a strings to int
 			enumerateSmallArray(a, CP, ci) {
 				castS(cp, CP);
 				setG(a, ci, parseIntG(cp));
 				finishG(cp);
 			}
 			setNFreeG(status_bgColors, n, a);
 			finishG(s);
 		}
 		free(fc);
 	}
 	//logVarG(status_fgColors);
 	//logVarG(status_bgColors);
 
 	// Set text editor
 	editor              = getNDupG(settings, rtChar,"editor");
 
 	// set user name and email
 	char **settings_keys = keysG(settings);
 	if (hasG(settings_keys, "username")) {
 		user  = getNDupG(settings, rtChar, "username");
 	}
 	else {
 		user  = strdup("Unknown");
 	}
 	if (hasG(settings, "useremail")) {
 		email = getNDupG(settings, rtChar, "useremail");
 	}
 	else {
 		emptyS(email);
 	}
 
 	if (desktop) {
 		smallStringt *s = getG(desktop, rtSmallStringt, "bookmarks");
 		bookmarks = splitG(s, "|");
 		finishG(s);
 	}
 	else {
 		// no desktop section in ini file, empty bookmarks
 		bookmarks = allocG(rtSmallArrayt);
 	}
 
 	// init
 	init();
 
 	listFreeManyS(data_keys, location_keys, settings_keys, config_filter_names, config_color_names);
 	finishManyG(data, locations, filters, colors, settings, desktop);
 }