easydoneitCTui

edt.c (55502B)

---

 #! /usr/bin/env sheepy
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <ncurses.h>
 #include <unistd.h>
 #include <signal.h>
 #include "shpPackages/md/md.h"
 #include "shpPackages/ini/src/ini.h"
 #include "tui/tui.h"
 #include "libsheepyObject.h"
 #include "edCore.h"
 
 // TODO add n 'add many tasks' and m 'add many one line tasks'
 // TODO sort group list
 // TODO handle path in statusBar when it exceeds screen size
 
 /** path element
  */
 typedef struct {
 	/** group id */
 	char group[16+1];
 	/** position in list */
 	u16 pos;
 	/** index in list of first line in the window */
 	u16 firstLineOnScreen;
 } pathInTreeElement;
 
 /** maximum path length stored, when MAX_PATH_DEPTH is reached, the oldest path is removed */
 // TODO test with low MAX
 #define MAX_PATH_DEPTH 1000
 /** path in tree circular buffer */
 staticArrayT(pathInTreeT, pathInTreeElement, MAX_PATH_DEPTH);
 /** pathInTree has the path browsed without the group in WGROUP */
 pathInTreeT pathInTree;
 /** titles for group in pathInTree and currentGroup for statusBar */
 smallArrayt *pathTitles = NULL;
 
 /** main window */
 WINDOW *mainwin;
 /** sub windows (colummns) */
 void **subwins = NULL;
 enum { WLEFT, WGROUP, WVIEW, WSEARCH, WHELP};
 
 /** window attributes */
 typedef struct {
 	/** this windows index in subwins array */
 	u8 subwin;
 	/** coordinate */
 	i16 row;
 	/** coordinate */
 	i16 col;
 	/** size */
 	i16 szrow;
 	/** size */
 	i16 szcol;
 	/** index in list of first line on screen */
 	i32 indexFirstLine;
 } awindow;
 
 /** window array for attributes */
 awindow windows[5];
 
 /** screen size */
 int row,col;
 
 enum {SHOWING_DATABASE, SHOWING_BOOKMARKS, SEARCH, SHOWING_SEARCH, HELP};
 /** ui state for user input */
 i8 state = SHOWING_DATABASE;
 i8 previousState;
 /** state for Info (F9) function - toggle between info and text/group */
 bool stateInfo = false;
 
 /** group in the WGROUP window */
 char currentGroup[ID_LENGTH+1];
 /** cursor in the WGROUP window */
 char selectedGroup[ID_LENGTH+1];
 /** index of cursor in WLEFT window */
 u16 leftCursor   = 0;
 /** index if cursor in WGROUP */
 u16 selectedLine = 0;
 
 /** list of select items (tids) */
 smallArrayt *selectedList = NULL;
 smallArrayt *selectedListAttributes = NULL;
 
 /** list in WLEFT window */
 smallArrayt *lsLeft   = NULL;
 /** list in WGROUP window */
 smallArrayt *lsGroup  = NULL;
 /** list in WVIEW window */
 smallArrayt *viewText = NULL;
 bool viewTextIsGroup  = false;
 
 const int cursorColor       = 8;
 const int regularListColor  = 0;
 const int groupListColor    = 2;
 const int selectedListColor = 3;
 
 char statusSymbols[] = "AD>^# ";
 i8   statusColors[]  = {0, 6, 3, 14, 4, 5};
 typedef enum { HIDE_STATUS, SHOW_STATUS} displayStatusT;
 
 char *searchString = NULL;
 
 typedef enum { NO_PAPER, COPIED, CUT} paperfunctionT;
 paperfunctionT paperfunction = NO_PAPER;
 
 /* PROTOTYPES */
 void statusBar(void);
 
 /**
  * add group to pathInTree with cursor position in group list
  * @param
  *   groupid group id to add
  * @param
  *   pos     cursor position in group list
  */
 void addGroupToPath(const char *groupid, u16 pos) {
 	if (staticArrayIsFull(pathInTree)) {
 		// remove oldest path when full
 		staticArrayDequeue(pathInTree);
 	}
 
 	// allocate element
 	staticArrayPush(pathInTree);
 	// store groupid
 	strcpy(staticArrayLast(pathInTree).group, groupid);
 	// store cursor position
 	staticArrayLast(pathInTree).pos               = pos;
 	// store window state
 	staticArrayLast(pathInTree).firstLineOnScreen = windows[WGROUP].indexFirstLine;
 	// copy window state WLEFT to keep same view as WGROUP
 	windows[WLEFT].indexFirstLine                 = windows[WGROUP].indexFirstLine;
 }
 
 /**
  * go back in path history
  */
 void moveToParentGroup(void) {
 	if (not staticArrayIsEmpty(pathInTree)) {
 		// there is a parent
 		// set last path to currentGroup
 		strcpy(currentGroup, staticArrayLast(pathInTree).group);
 		// set cursor in WGROUP
 		selectedLine                   = staticArrayLast(pathInTree).pos;
 		// set first line index in window
 		windows[WGROUP].indexFirstLine = staticArrayLast(pathInTree).firstLineOnScreen;
 		// pop path
 		staticArrayPop(pathInTree);
 		if (not staticArrayIsEmpty(pathInTree)) {
 			// set first line in window for new parent path
 			windows[WLEFT].indexFirstLine = staticArrayLast(pathInTree).firstLineOnScreen;
 		}
 	}
 	// TODO handle situation when pathInTree is empty and currentGroup is not root (lost history in the circular buffer)
 }
 
 /** get first group id in pathInTree */
 const char *getParentGroupInPath(void) {
 	if (not staticArrayIsEmpty(pathInTree)) {
 		// return last element in pathInTree
 		return staticArrayLast(pathInTree).group;
 	}
 	else {
 		// database top or pathInTree empty
 		return "";
 	}
 }
 
 /** create string with status
  * @param
  *   d dictionary containing the information about the group
  * @return
  *   statusIndex index in TASK_STATUS
  * @return
  *   string to be freed in the format 'STATUS TITLE'
  */
 char *statusAndTitle(smallDictt *d, i8 *statusIndex) {
 	// status is one char
 	char statusSymbol[3] = "  ";
 	*statusIndex         = 0;
 
 	// convert status string to status index in TASK_STATUS array
 	for (; *statusIndex < TASK_STATUS_VOID+1 ; (*statusIndex)++) {
 		if (eqG(getG(d, rtChar, "status"), TASK_STATUS[*statusIndex])) {
 			break;
 		}
 	}
 	statusSymbol[0]      = statusSymbols[*statusIndex];
 	char *s              = catS(statusSymbol, getG(d, rtChar, "title"));
 	return s;
 }
 
 /** display list in window w with cursor and showing/hiding each task/group status */
 void displayGroupList(smallArrayt *list, u16 w, u16 cursor, displayStatusT status) {
 	if (lenG(list) <= windows[w].szrow) {
 		// the list is smaller than the window
 		// the list top is the first line in the window
 		windows[w].indexFirstLine = 0;
 	}
 	// when the list is longer than the window, check that the list end is at window bottom
 	#define checkEndListInWindow(list, w) ((lenG(list) > windows[w].szrow) and ((windows[w].indexFirstLine + windows[w].szrow) > lenG(list)))
 	if checkEndListInWindow(list, w) {
 		// keep list end at window bottom
 		windows[w].indexFirstLine = lenG(list) - windows[w].szrow -1;
 	}
 	// print list in window
 	enumerateSmallArray(list, L, line) {
 		cast(smallDictt*, d, L)
 		if (line < windows[w].indexFirstLine) {
 			// skip elements before first line on screen
 			goto end;
 		}
 		i8 i;
 		char *s;
 		if (status == HIDE_STATUS) {
 			// hide status for database list, use regularListColor
 			i = regularListColor;
 		}
 		else {
 			// color according to status
 			s = statusAndTitle(d, &i);
 		}
 		if (line == cursor) {
 			// show cursor in cursorColor
 			wcolor_set(subwins[w], cursorColor, NULL);
 			if (w == WGROUP) {
 				// get tid at cursor position in list
 				// only for list in WGROUP window
 				strcpy(selectedGroup, getG(d, rtChar, "tid"));
 			}
 		}
 		else {
 			// set color
 			if (hasG(selectedList, getG(d, rtChar, "tid"))) {
 				wcolor_set(subwins[w], selectedListColor, NULL);
 			}
 			else {
 				if (eqG(getG(d, rtChar, "group"), "GROUP")) {
 					wcolor_set(subwins[w], groupListColor, NULL);
 				}
 				else {
 					wcolor_set(subwins[w], statusColors[i], NULL);
 				}
 			}
 		}
 		if (status == HIDE_STATUS) {
 			// print title without status
 			mvwaddnstr(subwins[w], line - windows[w].indexFirstLine, 0, getG(d, rtChar, "title"), windows[w].szcol-1);
 		}
 		else {
 			// print title with status
 			mvwaddnstr(subwins[w], line - windows[w].indexFirstLine, 0, s, windows[w].szcol-1);
 			free(s);
 		}
 		if (line == cursor) {
 			// fill the cursor line with cursorColor
 			wchgat(subwins[w],-1, 0, cursorColor , NULL);
 		}
 end:
 		finishG(d);
 	}
 }
 
 /** show list in WLEFT window */
 void showLeft(void) {
 	if (not currentGroup[0]) {
 		// path is database list, show nothing
 		return;
 	}
 	if (getParentGroupInPath()[0]) {
 		// a group is displayed on the left
 		displayGroupList(lsLeft, WLEFT, leftCursor, SHOW_STATUS);
 	}
 	else {
 		// display database list without status
 		displayGroupList(lsLeft, WLEFT, leftCursor, HIDE_STATUS);
 	}
 }
 
 /**
  * generate database list
  * @return
  *   ls array of dictionaries, same format as list_group
  */
 void listDatabases(smallArrayt *ls) {
 	// list selected databases (from .easydoneit.ini)
 	enumerateSmallArray(selected, S, line) {
 		castS(s, S);
 		createAllocateSmallDict(task_d);
 		setG(task_d, "head", "element");
 		setG(task_d, "tid", "");
 		setG(task_d, "position", line);
 		setG(task_d, "group", "GROUP");
 		setG(task_d, "title", ssGet(s));
 		setG(task_d, "status", TASK_STATUS[TASK_STATUS_VOID]);
 		setG(task_d, "ctime", 0);
 		pushNFreeG(ls, task_d);
 		finishG(s);
 	}
 	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(ls, task_d);
 }
 
 /**
  * generate and display list in WLEFT window
  * @param
  *   parent group id or "" for database root
  */
 void viewLeftParent(const char *parent) {
 	if (parent[0] == 0) {
 		// database root
 		if (not currentGroup[0]) {
 			// path is database list, show nothing
 			// the database list is in WGROUP, the user is selecting a database
 			return;
 		}
 		// show database list
 		leftCursor = staticArrayGet(pathInTree, pathInTree.last-1).pos;
 		// create list
 		if (lsLeft) {
 			terminateG(lsLeft);
 		}
 		initiateAllocateSmallArray(&lsLeft);
 		listDatabases(lsLeft);
 	}
 	else {
 		// show parent group
 		if (lsLeft) {
 			terminateG(lsLeft);
 		}
 		lsLeft = list_group(parent);
 		// find currentGroup in list
 		// TODO add a pos parameter to viewLeftParent and remove this loop
 		enumerateSmallArray(lsLeft, L, pI) {
 			cast(smallDictt*, d, L)
 			if (eqG(getG(d, rtChar, "tid"), currentGroup)) {
 				break;
 			}
 			finishG(d);
 		}
 		leftCursor = pI;
 	}
 	showLeft();
 }
 
 /** show list in WGROUP window */
 void showGroup(void) {
 	if (lenG(lsGroup) == 1) {
 		// list is empty, set invalid selectedGroup tid, no cursor in list
 		// (lsGroup always has an empty item at the end of the list)
 		selectedGroup[0] = 0;
 	}
 	displayGroupList(lsGroup, WGROUP, selectedLine, SHOW_STATUS);
 }
 
 /**
  * generate and display list in WGROUP window
  * @param
  *   currentGroup group id
  */
 void viewGroup(const char *currentGroup) {
 	if (state == SHOWING_SEARCH) {
 		goto show;
 	}
 	if (lsGroup) {
 		terminateG(lsGroup);
 	}
 ifState:
 	if (not currentGroup[0]) {
 		// path is database list
 		// show database list to select another database
 		initiateAllocateSmallArray(&lsGroup);
 		listDatabases(lsGroup);
 	}
 	else if (state == SHOWING_BOOKMARKS) {
 		lsGroup = listBookmarks();
 	}
 	else if (state == SEARCH) {
 		if (isBlankG(searchString)) {
 			// the search string is empty
 			// leave search results
 			state = previousState;
 			// show previous state: bookmark or current group
 			goto ifState;
 		}
 		state = SHOWING_SEARCH;
 		// SEARCH
 		smallArrayt *searchR = search_string_in_tree(currentGroup, trimG(&searchString));
 		uniqG(searchR, unusedV);
 		createAllocateSmallArray(hit_tids);
 		forEachSmallArray(searchR, S) {
 			castS(s, S);
 			char *id = ssGet(s);
 			*(id+ID_LENGTH) = 0;
 			pushG(hit_tids, id);
 			finishG(s);
 		}
 		smashG(searchR);
 		uniqG(hit_tids, unusedV);
 		initiateAllocateSmallArray(&lsGroup);
 		enumerateSmallArray(hit_tids, H, count) {
 			castS(h, H);
 			smallDictt *d = get_task_in_list_group_format(ssGet(h));
 			setG(d, "position", count);
 			pushNFreeG(lsGroup, d);
 			finishG(h);
 		}
 		terminateG(hit_tids);
 		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(lsGroup, task_d);
 	}
 	else {
 		// show group
 		lsGroup = list_group(currentGroup);
 	}
 	// check the list length and adjust selectedLine when there is only 1 line
 	if (selectedLine+2 > lenG(lsGroup)) {
 		selectedLine = lenG(lsGroup)-2;
 	}
 show:
 	showGroup();
 }
 
 /** show text in WVIEW window */
 void showSelected(const char *selected) {
 	if (not currentGroup[0]) {
 		// path is database list, show nothing
 		return;
 	}
 	if (windows[WVIEW].indexFirstLine < 0) {
 		// keep first line index in list
 		windows[WVIEW].indexFirstLine = 0;
 	}
 	if (lenG(viewText) <= windows[WVIEW].szrow) {
 		// the list is smaller than the window
 		// the list top is the first line in the window
 		windows[WVIEW].indexFirstLine = 0;
 	}
 	//if ((lenG(viewText) > windows[WVIEW].szrow) and ((windows[WVIEW].indexFirstLine + windows[WVIEW].szrow) > lenG(viewText))) {
 	if checkEndListInWindow(viewText, WVIEW) {
 		// keep list end at window bottom
 		windows[WVIEW].indexFirstLine = lenG(viewText) - windows[WVIEW].szrow -1;
 	}
 	// in root show all groups
 	// in groups, show text for task at pos 0 (group title task)
 	if (viewTextIsGroup and ((selectedLine != 0) or eqG(currentGroup, "root"))) {
 		// show group at cursor in WGROUP window
 		enumerateSmallArray(viewText, L, line) {
 			cast(smallDictt*, d, L)
 			if (line < windows[WVIEW].indexFirstLine) {
 				// skip elements before first line on screen
 				goto endGroup;
 			}
 			// print status and title
 			i8 i;
 			char *s = statusAndTitle(d, &i);
 			// set color
 			if (eqG(getG(d, rtChar, "group"), "GROUP")) {
 				wcolor_set(subwins[WVIEW], groupListColor, NULL);
 			}
 			else {
 				wcolor_set(subwins[WVIEW], statusColors[i], NULL);
 			}
 			mvwaddnstr(subwins[WVIEW], line - windows[WVIEW].indexFirstLine, 0, s, windows[WVIEW].szcol-1);
 			free(s);
 endGroup:
 			finishG(d);
 		}
 	}
 	else {
 		// show task text
 		enumerateSmallArray(viewText, L, line) {
 			castS(l, L);
 			if (line < windows[WVIEW].indexFirstLine) {
 				// skip elements before first line on screen
 				goto endText;
 			}
 			mvwaddnstr(subwins[WVIEW], line - windows[WVIEW].indexFirstLine, 0, ssGet(l), windows[WVIEW].szcol-1);
 endText:
 			finishG(l);
 		}
 	}
 }
 
 /**
  * generate and display list in WVIEW window
  * @param
  *   selected tid at cursor in WGROUP
  */
 void viewSelected(const char *selected) {
 	if (viewText) {
 		terminateG(viewText);
 	}
 	if (not currentGroup[0]) {
 		// path is database list, show nothing
 		return;
 	}
 	if (state == SHOWING_BOOKMARKS) {
 		// setup database, bookmarks can be in any database
 		save_edi_core_data_location();
 		setup_data_location_for_tid(selected);
 	}
 	// in root show all groups
 	// in groups, show text for task at pos 0 (group title task)
 	if (is_this_task_a_group(selected) and ((selectedLine != 0) or eqG(currentGroup, "root"))) {
 		// show group
 		viewText        = list_group(selected);
 		viewTextIsGroup = true;
 	}
 	else {
 		// show task text
 		viewText        = display_task(selected, passThroughTitle);
 		viewTextIsGroup = false;
 	}
 	if (state == SHOWING_BOOKMARKS) {
 		restore_edi_core_data_location();
 	}
 	showSelected(selected);
 }
 
 void showHelp(void) {
 	windows[WHELP].subwin = listLength(subwins);
 #define margin 4
 	windows[WHELP].row    = margin;
 	windows[WHELP].col    = margin;
 	windows[WHELP].szrow  = row - windows[WHELP].row - margin;
 	windows[WHELP].szcol  = col - windows[WHELP].col - margin;
 	void *w;
 	listPush(&subwins, EVA(w, newwin(windows[WHELP].szrow, windows[WHELP].szcol, windows[WHELP].row, windows[WHELP].col)) );
 	setSubwindows(subwins);
 	wcolor_set(subwins[windows[WHELP].subwin], 1, NULL);
 	// fill background with color
 	char *b = malloc(windows[WHELP].szrow * windows[WHELP].szcol +1);
 	range(i, windows[WHELP].szrow * windows[WHELP].szcol) {
 		b[i] = ' ';
 	}
 	b[windows[WHELP].szrow * windows[WHELP].szcol] = 0;
 	waddstr(subwins[windows[WHELP].subwin], b);
 	free(b);
 	box(w, 0 , 0);
 	mvwaddnstr(subwins[windows[WHELP].subwin], 0, 2, " HELP ", windows[WHELP].szcol-2);
 	smallArrayt *help = createSA(
 			"q              quit                                 g              set active status",
 			"INSERT/i       new task                             h              set done status",
 			"DELETE/p       delete selected items                j              set ongoing status",
 			"z              select/deselect all items            k              set pending status",
 			"x              cut selected items                   l              set inactive status",
 			"c              copy selected items                  o              set unknown status",
 			"v              paste selected items                 a              attach files to cursor item",
 			"b              link selected items                  d              convert task to group or group to task",
 			"DOWN           move cursor down                     t              toggle top/bottom",
 			"END            page down list",
 			"UP             move cursor up",
 			"HOME           page up list",
 			"RIGHT/ENTER    enter group/database (or edit task)",
 			"LEFT/BACKSPACE browse back in history",
 			"PAGE DOWN      page down description",
 			"PAGE UP        page up description",
 			"SPACE          select multiple items",
 			"F2             deselect items",
 			"F3             toggle active filter",
 			"F4             toggle done filter",
 			"F5             toggle ongoing filter",
 			"F6             toggle pending filter",
 			"F7             toggle inactive filter",
 			"F8             view all group tasks",
 			"F9             show task information",
 			"F10            search",
 			"F11            add selected items to bookmarks",
 			"F12            show bookmarks",
 			"",
 			"List symbols: 'A' Active, 'D' Done, '>' Ongoing, '^' Pending, '#' inactive, ' ' Unknown"
 	);
 	enumerateSmallArray(help, H, line) {
 		castS(h, H);
 		mvwaddnstr(subwins[windows[WHELP].subwin], 2+line, 3, ssGet(h), windows[WHELP].szcol-2);
 		if (2+line == windows[WHELP].szrow-2) {
 			// prevent print outside the window
 			break;
 		}
 		finishG(h);
 	}
 	terminateG(help);
 }
 
 /**
  * first line in main window
  * keyboard commands
  */
 void topMenu(void) {
 	// print menu, inverted colors to the end of the screen
 	int colorPair = 1;
 	move(0,0);
 	color_set(colorPair, NULL);
 	attron(A_REVERSE);
 	addnstr("F1 Help F2 Deselect ", col-1);
 
 	i32 *flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_ACTIVE);
 	if (*flt == DISABLE) {
 		color_set(cursorColor, NULL);
 	}
 	else {
 		color_set(colorPair, NULL);
 	}
 
 	addnstr("F3 Active", col-1);
 	color_set(colorPair, NULL);
 	addnstr(" ", col-1);
 
 	flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_DONE);
 	if (*flt == DISABLE) {
 		color_set(cursorColor, NULL);
 	}
 	else {
 		color_set(colorPair, NULL);
 	}
 
 	addnstr("F4 Done", col-1);
 	color_set(colorPair, NULL);
 	addnstr(" ", col-1);
 
 	flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_ONGOING);
 	if (*flt == DISABLE) {
 		color_set(cursorColor, NULL);
 	}
 	else {
 		color_set(colorPair, NULL);
 	}
 
 	addnstr("F5 Ongoing", col-1);
 	color_set(colorPair, NULL);
 	addnstr(" ", col-1);
 
 	flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_PENDING);
 	if (*flt == DISABLE) {
 		color_set(cursorColor, NULL);
 	}
 	else {
 		color_set(colorPair, NULL);
 	}
 
 	addnstr("F6 Pending", col-1);
 	color_set(colorPair, NULL);
 	addnstr(" ", col-1);
 
 	flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_INACTIVE);
 	if (*flt == DISABLE) {
 		color_set(cursorColor, NULL);
 	}
 	else {
 		color_set(colorPair, NULL);
 	}
 
 	addnstr("F7 Inactive", col-1);
 	color_set(colorPair, NULL);
 	addnstr(" F8 View Group F9 Info F10 Search F11 Bookmark F12 Bookmarks", col-1);
 	attroff(A_REVERSE);
 	chgat(-1, A_REVERSE, colorPair , NULL);
 }
 
 /**
  * show pathInTree at the bottom of main window
  */
 void statusBar(void) {
 	// print path at bottom
 	move(row-1,0);
 	color_set(2, NULL);
 	smallStringt *p = joinG(pathTitles, "/");
 	addnstr(ssGet(p), col-1);
 	clrtoeol();
 }
 
 /**
  * place WLEFT, WGROUP and WVIEW on screen
  * at start and the terminal is resized
  */
 void placeCols(void) {
 	// create columns 15 35 50
 	int szWin1 = (col * 3) / (2 * 10);
 	int szWin2 = (col * 7) / (2 * 10);
 	int szWin3 = col - szWin1 -szWin2;
 
 	windows[WLEFT].row    = 1;
 	windows[WLEFT].col    = 0;
 	windows[WLEFT].szrow  = row-2;
 	windows[WLEFT].szcol  = szWin1-1;
 	windows[WGROUP].row   = 1;
 	windows[WGROUP].col   = szWin1;
 	windows[WGROUP].szrow = row-2;
 	windows[WGROUP].szcol = szWin2-1;
 	windows[WVIEW].row    = 1;
 	windows[WVIEW].col    = szWin1+szWin2;
 	windows[WVIEW].szrow  = row-2;
 	windows[WVIEW].szcol  = szWin3;
 }
 
 /**
  * create WLEFT, WGROUP and WVIEW
  */
 void createCols(void) {
 	free(subwins);
 	subwins = NULL;
 
 	placeCols();
 
 	// initialize firstLineOnScreen index
 	windows[WLEFT].indexFirstLine  = 0;
 	windows[WGROUP].indexFirstLine = 0;
 	windows[WVIEW].indexFirstLine  = 0;
 
 	// create 3 window colunms WLEFT, WGROUP, WVIEW
 	WINDOW *w;
 
 	// refresh here, otherwise the new window is invisible
 	refresh();
 	// create left window
 	w = newwin(windows[WLEFT].szrow, windows[WLEFT].szcol, windows[WLEFT].row, windows[WLEFT].col);
 	listPush(&subwins, w);
 
 	// create group window
 	w = newwin(windows[WGROUP].szrow, windows[WGROUP].szcol, windows[WGROUP].row, windows[WGROUP].col);
 	listPush(&subwins, w);
 
 	// create view window
 	w = newwin(windows[WVIEW].szrow, windows[WVIEW].szcol, windows[WVIEW].row, windows[WVIEW].col);
 	listPush(&subwins, w);
 
 	setSubwindows(subwins);
 }
 
 /**
  * resize the windows when the terminal is resized
  */
 void resizeCols(void) {
 
 	placeCols();
 
 	// erase previous content to remove all artifacts
 	eraseSubwindows();
 	// refresh to show the windows again
 	refresh();
 	enumerateType(void, subwins, w, i) {
 		mvwin(*w, windows[i].row, windows[i].col);
 		wresize(*w, windows[i].szrow, windows[i].szcol);
 	}
 }
 
 /**
  * fill WLEFT, WGROUP, WVIEW
  */
 void fillCols(void) {
 	viewLeftParent(getParentGroupInPath());
 	viewGroup(currentGroup);
 	viewSelected(selectedGroup);
 }
 
 /**
  * display again the lists in WLEFT, WGROUP and WVIEW without updates
  * when the terminal is resized
  */
 void showCols(void) {
 	showLeft();
 	showGroup();
 	showSelected(selectedGroup);
 }
 
 /**
  * detect when the terminal is resized
  */
 void winch_sigaction(int sig, siginfo_t *si, void *arg) {
 	endwin();
 	initscr();
 	refresh();
 	clear();
 	row = LINES;
 	col = COLS;
 	topMenu();
 	statusBar();
 	resizeCols();
 	showCols();
 	refreshAll();
 }
 
 void registerSigWinch(void) {
 	struct sigaction sa;
 	memset(&sa, 0, sizeof(struct sigaction));
 	sigemptyset(&sa.sa_mask);
 	sa.sa_sigaction = winch_sigaction;
 	sa.sa_flags   = SA_SIGINFO;
 	sigaction(SIGWINCH, &sa, NULL);
 }
 
 void pasteClipboard(const char *pasteLinkOrCopy) {
 	// handle multiple databases
 	save_edi_core_data_location();
 	// saved_data_location is destination database
 	setup_data_location_for_tid(getG(selectedList, rtChar, 0));
 	// data_location is source database
 	bool sameSrcDstDatabase = true;
 	const char *destination_database_name;
 	if (not eqG(data_location, saved_data_location)) {
 		sameSrcDstDatabase        = false;
 		destination_database_name = getDatabaseNameFromPath(saved_data_location);
 	}
 	if (paperfunction == COPIED) {
 		forEachSmallArray(selectedList, T) {
 			castS(t, T);
 			if (sameSrcDstDatabase) {
 				if (eqG(pasteLinkOrCopy, "paste")) {
 					copy_task_to_a_group(ssGet(t), currentGroup);
 				}
 				if (eqG(pasteLinkOrCopy, "link")) {
 					smallStringt *c;
 					add_task_reference_to_a_group(ssGet(t), EVA(c, allocG(currentGroup)));
 					terminateG(c);
 				}
 			}
 			else {
 				// always copy to different source/destination databases
 				copy_task_to_database(ssGet(t), destination_database_name, currentGroup);
 			}
 			finishG(t);
 		}
 	}
 	if (paperfunction == CUT) {
 		enumerateSmallArray(selectedList, T, i) {
 			castS(t, T);
 			if (sameSrcDstDatabase) {
 				smallArrayt *a = getG(selectedListAttributes, rtSmallArrayt, i);
 				if (getG(a, rtI32, 1) == SHOWING_DATABASE) {
 					move_task_to_a_group(getG(a, rtChar, 0), ssGet(t), currentGroup);
 				}
 				else {
 					// group in selectedListAttributes is invalid
 					move_task_to_a_group(find_group_containing_task(ssGet(t)), ssGet(t), currentGroup);
 				}
 				finishG(a);
 			}
 			else {
 				const char *new_tid = NULL;
 				smallArrayt *a = getG(selectedListAttributes, rtSmallArrayt, i);
 				if (getG(a, rtI32, 1) == SHOWING_DATABASE) {
 					// move to other database
 					new_tid = move_task_to_a_group_to_database(getG(a, rtChar, 0), ssGet(t), destination_database_name, currentGroup);
 				}
 				else {
 					// group in selectedListAttributes is invalid
 					new_tid = move_task_to_a_group_to_database(find_group_containing_task(ssGet(t)), ssGet(t), destination_database_name, currentGroup);
 				}
 				finishG(a);
 
 				if (new_tid){
 					ssize_t index = findG(bookmarks, ssGet(t));
 					if (index != -1) {
 							// update bookmark
 							setG(bookmarks, index, new_tid);
 					}
 				}
 			}
 			finishG(t);
 		}
 	}
 	restore_edi_core_data_location();
 	// deselect all items
 	emptyG(selectedList);
 	emptyG(selectedListAttributes);
 	paperfunction = NO_PAPER;
 }
 
 void saveEdiState(void) {
 	char *path = expandHomeG("~/.easydoneit.bin");
 	createAllocateSmallJson(ediState);
 
 	createAllocateSmallArray(a);
 
 	range(i, staticArrayCount(pathInTree)) {
 		createAllocateSmallArray(a2);
 		pushG(a2, staticArrayGet(pathInTree, i).group);
 		pushG(a2, (u32)staticArrayGet(pathInTree, i).pos);
 		pushG(a2, (u32)staticArrayGet(pathInTree, i).firstLineOnScreen);
 		pushNFreeG(a, a2);
 	}
 
 	setNFreeG(ediState, "pathInTree", a);
 
 	setNFreeG(ediState, "pathTitles", pathTitles);
 
 	setG(ediState, "state", (int32_t)state);
 	setG(ediState, "previousState", (int32_t)previousState);
 	setG(ediState, "stateInfo", stateInfo);
 	setG(ediState, "currentGroup", currentGroup);
 	setG(ediState, "selectedGroup", selectedGroup);
 	setG(ediState, "selectedLine", (u32)selectedLine);
 	setNFreeG(ediState, "selectedList", selectedList);
 	setNFreeG(ediState, "selectedListAttributes", selectedListAttributes);
 	setNFreeG(ediState, "lsGroup", lsGroup); // for search results, avoid crash
 	// TODO save view text to restore view group
 	//setNFreeG(ediState, "searchString", searchString);
 	setG(ediState, "paperfunction", paperfunction);
 
 	//logVarG(ediState);
 	smallBytest *B = serialG(ediState);
 	writeFileG(B, path);
 	terminateManyG(ediState, B);
 	free(path);
 }
 
 /** true when state is loaded */
 bool loadEdiState(void) {
 	bool r = false;
 	char *path = expandHomeG("~/.easydoneit.bin");
 
 	// use default when edi state is not found
 	if (fileExists(path)) {
 		createAllocateSmallBytes(B);
 		readFileG(B, path);
 
 		createAllocateSmallJson(ediState);
 
 		deserialG(ediState, B);
 		//logVarG(ediState);
 
 		smallArrayt *a = getG(ediState, rtSmallArrayt, "pathInTree");
 
 		enumerateSmallArray(a, P, i) {
 			cast(smallArrayt *, p, P);
 			staticArrayPush(pathInTree);
 			strcpy(staticArrayLast(pathInTree).group, getG(p, rtChar, 0));
 			staticArrayLast(pathInTree).pos               = getG(p, rtI32, 1);
 			staticArrayLast(pathInTree).firstLineOnScreen = getG(p, rtI32, 2);
 			finishG(p);
 		}
 
 		finishG(a);
 
 		pathTitles             = getNDupG(ediState, rtSmallArrayt, "pathTitles");
 		state                  = getG(ediState, rtI32, "state");
 		previousState          = getG(ediState, rtI32, "previousState");
 	    stateInfo              = getG(ediState, rtBool, "stateInfo");
 		strcpy(currentGroup,     getG(ediState, rtChar, "currentGroup"));
 		strcpy(selectedGroup,    getG(ediState, rtChar, "selectedGroup"));
 		selectedLine           = getG(ediState, rtI32, "selectedLine");
 		selectedList           = getNDupG(ediState, rtSmallArrayt, "selectedList");
 		selectedListAttributes = getNDupG(ediState, rtSmallArrayt,"selectedListAttributes");
 		lsGroup                = getNDupG(ediState, rtSmallArrayt, "lsGroup");
 		//getG(ediState, rtChar, "searchString");
 		paperfunction          = getG(ediState, rtI32, "paperfunction");
 
 		terminateManyG(ediState, B);
 
 		r = true;
 	}
 	free(path);
 	return r;
 }
 
 
 int main(int argc, char** argv) {
 
 	//char *c = readFileG(c, argv[1]);
 	//logG(md_highlight(c));
 
 	initLibsheepy(argv[0]);
 
 	//#if 0
 	start("tui");
 
 	mainwin = initScreen(&row, &col);
 
 	staticArrayInit(pathInTree);
 
 	// database top
 	// path top title is database name
 	// groupid parameter to addGroupToPath is "", pos is the cursor in the database list
 	windows[WGROUP].indexFirstLine = 0;
 
 	if (not loadEdiState()) {
 		initiateAllocateSmallArray(&selectedList);
 		initiateAllocateSmallArray(&selectedListAttributes);
 
 		addGroupToPath("", 0);
 		initiateAllocateSmallArray(&pathTitles);
 		pushG(pathTitles, getG(selected, rtChar, 0));
 		strcpy(currentGroup, "root");
 	}
 
 	topMenu();
 	statusBar();
 	createCols();
 	registerSigWinch();
 	fillCols();
 
 	refreshAll();
 
 	int c;
 	while (((c = wgetch(mainwin)) != 'q') || (state == SEARCH)) {
 		if (state == HELP) {
 			state   = previousState;
 			void *w = listPop(&subwins);
 			setSubwindows(subwins);
 			werase(mainwin);
 			//refresh();
 			wnoutrefresh(mainwin);
 			delwin(w);
 			topMenu();
 			statusBar();
 			showCols();
 		}
 		else if (state == SEARCH) {
 			switch(c){
 				case KEY_F(1):
 					state = previousState;
 					noecho();
 					statusBar();
 					break;
 				case '\n': {
 					// state is SEARCH, viewGroup will perform the search
 
 					move(row-1,0);
 					color_set(cursorColor, NULL);
 					clrtoeol();
 					addnstr("Searching...", col-1);
 					chgat(-1, 0, cursorColor, NULL);
 					refresh();
 
 					noecho();
 					statusBar();
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					fillCols();
 					break;
 				}
 				case KEY_BACKSPACE:
 					delG(&searchString, -1, 0);
 			}
 			if (c < KEY_MIN) {
 				iInjectS(&searchString, -1, c);
 			}
 			if (state == SEARCH) {
 				move(row-1,0);
 				color_set(1, NULL);
 				clrtoeol();
 				char *s = appendS("SEARCH (F1 to cancel): ", searchString);
 				addnstr(s, col-1);
 				free(s);
 				chgat(-1, 0, 1, NULL);
 			}
 		}
 		else {
 			if ((c != KEY_F(9)) and (stateInfo == true)) {
 				// exit state info when any key is pressed
 				stateInfo = false;
 			}
 			switch(c){
 				case 'a':
 					// TODO add attachments
 					break;
 				case 't':
 					if (eqG(add_top_or_bottom, "top")) {
 						free(add_top_or_bottom);
 						add_top_or_bottom = strdup("bottom");
 					}
 					else {
 						free(add_top_or_bottom);
 						add_top_or_bottom = strdup("top");
 					}
 					break;
 				case 'd':
 					// convert selected items
 					if (not lenG(selectedList)) {
 						if (not is_this_task_a_group(selectedGroup)) {
 							create_group(selectedGroup);
 						}
 						else {
 							convert_group_to_task(selectedGroup);
 						}
 					}
 					else {
 						// selected items in selectedList
 						forEachSmallArray(selectedList, T) {
 							castS(t, T);
 							if (not is_this_task_a_group(ssGet(t))) {
 								create_group(ssGet(t));
 							}
 							else {
 								convert_group_to_task(ssGet(t));
 							}
 							finishG(t);
 						}
 						emptyG(selectedList);
 						emptyG(selectedListAttributes);
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					fillCols();
 					break;
 				case 'i':
 				case KEY_IC:
 					// INSERT
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 					}
 					create_task(currentGroup);
 					// refresh screen
 					system("reset");
 					reInitScreen(mainwin);
 					topMenu();
 					statusBar();
 					eraseSubwindows();
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					fillCols();
 					redrawwin(mainwin);
 					refresh();
 					showCols();
 					forEachType(void, subwins, wd) {
 						redrawwin((WINDOW *)(*wd));
 					}
 					break;
 				case 'p':
 				case KEY_DC:
 					// DELETE
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 					}
 					if (not lenG(selectedList)) {
 						delete_linked_task(currentGroup, selectedGroup);
 						save_edi_core_data_location();
 						if (not tid_exists(selectedGroup)) {
 								ssize_t index = findG(bookmarks, selectedGroup);
 								if (index != -1) {
 										// delete bookmark
 										delG(bookmarks, index, index+1);
 								}
 						}
 						restore_edi_core_data_location();
 					}
 					else {
 						// selected items in selectedList
 						enumerateSmallArray(selectedList, T, i) {
 							castS(t, T);
 							smallArrayt *a = getG(selectedListAttributes, rtSmallArrayt, i);
 							if (getG(a, rtI32, 1) == SHOWING_DATABASE) {
 								delete_linked_task(getG(a, rtChar, 0), ssGet(t));
 							}
 							else {
 								// group in selectedListAttributes is invalid
 								delete_task(ssGet(t));
 							}
 								save_edi_core_data_location();
 								if (not tid_exists(ssGet(t))) {
 										ssize_t index = findG(bookmarks, ssGet(t));
 										if (index != -1) {
 												// delete bookmark
 												delG(bookmarks, index, index+1);
 										}
 								}
 								restore_edi_core_data_location();
 							finishG(a);
 							finishG(t);
 						}
 						emptyG(selectedList);
 						emptyG(selectedListAttributes);
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					fillCols();
 					break;
 				case ' ':
 					// select/deselect item under cursor in the group list
 					if (currentGroup[0]) {
 						// select only in group, not database list
 						ssize_t index = findG(selectedList, selectedGroup);
 						if (index == -1) {
 							// add new selection
 							pushG(selectedList, selectedGroup);
 							createAllocateSmallArray(a);
 							pushG(a, currentGroup);
 							pushG(a, (int32_t)state);
 							pushNFreeG(selectedListAttributes, a);
 						}
 						else {
 							// remove selection
 							delG(selectedList, index, index+1);
 							delG(selectedListAttributes, index, index+1);
 						}
 					}
 				case KEY_DOWN:
 					// move cursor down in WGROUP window
 					// when the cursor reaches the list bottom
 					// it goes back to the top
 					if (selectedLine < lenG(lsGroup)-2) {
 						// move down the list and stay inside
 						selectedLine++;
 					}
 					else {
 						selectedLine                   = 0;
 						windows[WGROUP].indexFirstLine = 0;
 					}
 					if ((selectedLine - windows[WGROUP].indexFirstLine +1) > windows[WGROUP].szrow) {
 						// scroll to keep cursor on screen
 						windows[WGROUP].indexFirstLine++;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					fillCols();
 					break;
 				case KEY_END:
 					// page down WGROUP window
 					// when the last page is reached, the cursor is moved to the window bottom
 					// on next page down, the cursor is moved to the list top
 					if ((windows[WGROUP].indexFirstLine + windows[WGROUP].szrow) < lenG(lsGroup)-2) {
 						// list middle is on window bottom
 						windows[WGROUP].indexFirstLine += windows[WGROUP].szrow;
 						// keep cursor on window top
 						if checkEndListInWindow(lsGroup, WGROUP) {
 							selectedLine                    = lenG(lsGroup) - windows[WGROUP].szrow -1;
 						}
 						else {
 							selectedLine                    = windows[WGROUP].indexFirstLine;
 						}
 					}
 					else {
 						// list end is on window bottom
 						if (selectedLine != (lenG(lsGroup)-2)) {
 							// cursor not at window bottom, move cursor to bottom
 							selectedLine = lenG(lsGroup)-2;
 						}
 						else {
 							// cursor is at bottom, move to list top
 							selectedLine                   = 0;
 							windows[WGROUP].indexFirstLine = 0;
 						}
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					fillCols();
 					break;
 				case KEY_UP:
 					// move cursor up in WGROUP window
 					// when cursor reaches the list top
 					// it goes back to the bottom
 					if (selectedLine > 0) {
 						// keep cursor in list
 						selectedLine--;
 						if (selectedLine < windows[WGROUP].indexFirstLine) {
 							// scroll to keep cursor on screen
 							windows[WGROUP].indexFirstLine--;
 						}
 					}
 					else {
 						// cursor is at top, move to list bottom
 						selectedLine = lenG(lsGroup)-2;
 						windows[WGROUP].indexFirstLine = lenG(lsGroup) - windows[WGROUP].szrow -1;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					fillCols();
 					break;
 				case KEY_HOME:
 					// page up WGROUP window
 					// when the first page is reached, the cursor is moved to the window top
 					// on next page up, the cursor is moved to the list bottom
 					if (((windows[WGROUP].indexFirstLine - windows[WGROUP].szrow)) > 0) {
 						// list middle is on window top
 						windows[WGROUP].indexFirstLine -= windows[WGROUP].szrow;
 						// keep cursor on window bottom
 						selectedLine                    = windows[WGROUP].indexFirstLine + windows[WGROUP].szrow -1;
 					}
 					else {
 						// list top is on window top
 						i32 newIndex = 0;
 						if (windows[WGROUP].indexFirstLine) {
 							// currently list top is not in window
 							if (selectedLine >= windows[WGROUP].szrow) {
 								// cursor is outside window after page down
 								// keep cursor at window bottom
 								selectedLine = windows[WGROUP].szrow -1;
 							}
 						}
 						else {
 							if (selectedLine != 0) {
 								// cursor not at window top, move cursor to top
 								selectedLine = 0;
 							}
 							else {
 								// cursor is at top, move to list bottom
 								selectedLine = lenG(lsGroup)-2;
 								newIndex     = lenG(lsGroup) - windows[WGROUP].szrow -1;
 							}
 						}
 						// show list top at WGROUP window top
 						windows[WGROUP].indexFirstLine = newIndex;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					fillCols();
 					break;
 				case '\n':
 				case KEY_RIGHT:
 					// move to selected item (group, database)
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					if (state == SHOWING_BOOKMARKS) {
 						// currently showing bookmarks
 						// stop showing bookmarks
 						state = SHOWING_DATABASE;
 					}
 					if (!currentGroup[0]) {
 						// a database is selected
 						// add empty group id for root in pathInTree
 						addGroupToPath("", selectedLine);
 						smallDictt *d = getG(lsGroup, rtSmallDictt, selectedLine);
 						char *dName = getG(d, rtChar, "title");
 						select_database(dName);
 
 						// update database name in status bar
 						free(popG(pathTitles, rtChar));
 						pushG(pathTitles, dName);
 
 						// set current group root, database top
 						strcpy(currentGroup, "root");
 						selectedLine = 0;
 						statusBar();
 						eraseSubwindows();
 						fillCols();
 						break;
 					}
 					// in root enter all groups
 					// in groups, edit text for task at pos 0 (group title task)
 					if (is_this_task_a_group(selectedGroup) and ((selectedLine != 0) or eqG(currentGroup, "root"))) {
 						// a group is selected
 						// add currentGroup to pathInTree
 						addGroupToPath(currentGroup, selectedLine);
 						// set selected group as current group
 						strcpy(currentGroup, selectedGroup);
 						// line 0 is group title, select first task in group instead
 						// viewGroup keeps the cursor in the list
 						// so when the group is empty, it is moved to line 0
 						selectedLine = 1;
 
 						// add new current group title to pathTitles for status bar
 						pushNFreeG(pathTitles, trimG(get_task_title(currentGroup)));
 
 						statusBar();
 						eraseSubwindows();
 						fillCols();
 					}
 					else {
 						// edit task, open editor
 						edit_task(selectedGroup);
 						// refresh screen
 						system("reset");
 						reInitScreen(mainwin);
 						topMenu();
 						statusBar();
 						eraseSubwindows();
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						fillCols();
 						redrawwin(mainwin);
 						refresh();
 						showCols();
 						forEachType(void, subwins, wd) {
 							redrawwin((WINDOW *)(*wd));
 						}
 					}
 					break;
 				case KEY_BACKSPACE:
 				case KEY_LEFT: {
 					// move back in browsing history
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 						eraseSubwindows();
 						fillCols();
 						break;
 					}
 					if (state == SHOWING_BOOKMARKS) {
 						// currently showing bookmarks
 						// stop showing bookmarks and stay in same group
 						state = SHOWING_DATABASE;
 						eraseSubwindows();
 						fillCols();
 						break;
 					}
 					if ((staticArrayCount(pathInTree) == 1) and (currentGroup[0] not_eq 0)) {
 						// path is root and currentGroup is not database list
 						// show database list in WGROUP window
 						currentGroup[0] = 0;
 					}
 
 					moveToParentGroup();
 					if (lenG(pathTitles) > 1) {
 						// always keep database name in path title
 						// to show current database in status bar
 						free(popG(pathTitles, rtChar));
 					}
 
 					statusBar();
 					eraseSubwindows();
 					fillCols();
 					break;
 					}
 				case KEY_NPAGE:
 					// page down WVIEW window
 					// showSelected keeps the text in the window and adjusts indexFirstLine
 					windows[WVIEW].indexFirstLine += windows[WVIEW].szrow;
 					eraseSubwindows();
 					/* fillCols(); */
 					viewLeftParent(getParentGroupInPath());
 					viewGroup(currentGroup);
 					showSelected("");
 					break;
 				case KEY_PPAGE:
 					// page up WVIEW window
 					// showSelected keeps the text in the window and adjusts indexFirstLine
 					windows[WVIEW].indexFirstLine -= windows[WVIEW].szrow;
 					eraseSubwindows();
 					/* fillCols(); */
 					viewLeftParent(getParentGroupInPath());
 					viewGroup(currentGroup);
 					showSelected("");
 					break;
 				case KEY_F(1):
 					if (state != HELP) {
 						previousState = state;
 						state         = HELP;
 						showHelp();
 					}
 					break;
 				case KEY_F(3): {
 					// toggle active filter
 					// deselect all items
 					emptyG(selectedList);
 					emptyG(selectedListAttributes);
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 					}
 					i32 *flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_ACTIVE);
 					if (*flt == DISABLE) {
 						*flt = ENABLE;
 					}
 					else {
 						*flt = DISABLE;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					topMenu();
 					fillCols();
 					break;
 				}
 				case KEY_F(4): {
 					// toggle done filter
 					// deselect all items
 					emptyG(selectedList);
 					emptyG(selectedListAttributes);
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 					}
 					i32 *flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_DONE);
 					if (*flt == DISABLE) {
 						*flt = ENABLE;
 					}
 					else {
 						*flt = DISABLE;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					topMenu();
 					fillCols();
 					break;
 				}
 				case KEY_F(5): {
 					// toggle ongoing filter
 					// deselect all items
 					emptyG(selectedList);
 					emptyG(selectedListAttributes);
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 					}
 					i32 *flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_ONGOING);
 					if (*flt == DISABLE) {
 						*flt = ENABLE;
 					}
 					else {
 						*flt = DISABLE;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					topMenu();
 					fillCols();
 					break;
 				}
 				case KEY_F(6): {
 					// toggle pending filter
 					// deselect all items
 					emptyG(selectedList);
 					emptyG(selectedListAttributes);
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 					}
 					i32 *flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_PENDING);
 					if (*flt == DISABLE) {
 						*flt = ENABLE;
 					}
 					else {
 						*flt = DISABLE;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					topMenu();
 					fillCols();
 					break;
 				}
 				case KEY_F(7): {
 					// toggle inactive filter
 					// deselect all items
 					emptyG(selectedList);
 					emptyG(selectedListAttributes);
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 					}
 					i32 *flt = (i32 *) getG(status_filters, rtI32P, TASK_STATUS_INACTIVE);
 					if (*flt == DISABLE) {
 						*flt = ENABLE;
 					}
 					else {
 						*flt = DISABLE;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					topMenu();
 					fillCols();
 					break;
 				}
 				case KEY_F(8): {
 					// show all descriptions for tasks in list
 					if (viewText) {
 						terminateG(viewText);
 					}
 					if (state == SHOWING_SEARCH) {
 						// show tasks from search results
 						viewText = listTasksInList(lsGroup);
 						viewTextIsGroup = true;
 					}
 					if (state == SHOWING_DATABASE) {
 						// show tasks in current group
 						viewText = listTasksInGroup(currentGroup);
 						viewTextIsGroup = true;
 					}
 					if (state == SHOWING_BOOKMARKS) {
 						// show tasks from bookmarks
 						viewText = listTasksInBookmarks();
 						viewTextIsGroup = true;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					/* fillCols(); */
 					viewLeftParent(getParentGroupInPath());
 					viewGroup(currentGroup);
 					showSelected("");
 					break;
 				}
 				case KEY_F(9):
 					// toggle info
 					if (not stateInfo) {
 						stateInfo = true;
 						if (viewText) {
 							terminateG(viewText);
 						}
 						//viewText = createSA("fwefw", "wfwef");
 						viewText = show_group_for_task(selectedGroup);
 						viewTextIsGroup = false;
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						/* fillCols(); */
 						viewLeftParent(getParentGroupInPath());
 						viewGroup(currentGroup);
 						showSelected("");
 					}
 					else {
 						stateInfo = false;
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						fillCols();
 					}
 					break;
 				case '/':
 				case KEY_F(10): {
 					// search string in group
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 						break;
 					}
 					iEmptySF(&searchString);
 					previousState = state;
 					state = SEARCH;
 					echo();
 					move(row-1,0);
 					color_set(1, NULL);
 					clrtoeol();
 					addnstr("SEARCH (F1 to cancel): ", col-1);
 					chgat(-1, 0, 1, NULL);
 					break;
 				}
 				case KEY_F(11): {
 					// bookmark items
 					// remove from bookmark if already bookmarked
 					if (not lenG(selectedList)) {
 						ssize_t index = findG(bookmarks, selectedGroup);
 						if (index == -1) {
 							// no duplicated bookmarks
 							// remove empty strings in bookmarks
 							compactG(bookmarks);
 							pushG(bookmarks, selectedGroup);
 						}
 						else {
 							// remove bookmark
 							delG(bookmarks, index, index+1);
 						}
 					}
 					else {
 						// selected items in selectedList
 						forEachSmallArray(selectedList, T) {
 							castS(t, T);
 							ssize_t index = findG(bookmarks, ssGet(t));
 							if (index == -1) {
 								// no duplicated bookmarks
 								pushG(bookmarks, ssGet(t));
 							}
 							else {
 								// remove bookmark
 								delG(bookmarks, index, index+1);
 							}
 							finishG(t);
 						}
 						emptyG(selectedList);
 						emptyG(selectedListAttributes);
 					}
 					break;
 				}
 				case KEY_F(12): {
 					// show bookmarks
 					if (state == SHOWING_SEARCH) {
 						// leave search results
 						state = previousState;
 					}
 					if ((state != SHOWING_BOOKMARKS) and (not eqG(getG(bookmarks, rtChar, 0), ""))) {
 						state = SHOWING_BOOKMARKS;
 					}
 					else if (state == SHOWING_BOOKMARKS) {
 						state = SHOWING_DATABASE;
 					}
 					// scroll WVIEW window to top
 					windows[WVIEW].indexFirstLine = 0;
 					eraseSubwindows();
 					fillCols();
 					break;
 				}
 				case 'g':
 					// set selected item active
 					if (currentGroup[0]) {
 						// change status for all selected tasks
 						if (not lenG(selectedList)) {
 							set_status(selectedGroup, TASK_STATUS_ACTIVE);
 						}
 						else {
 							// selected items in selectedList
 							forEachSmallArray(selectedList, T) {
 								castS(t, T);
 								set_status(ssGet(t), TASK_STATUS_ACTIVE);
 								finishG(t);
 							}
 							emptyG(selectedList);
 							emptyG(selectedListAttributes);
 						}
 
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						fillCols();
 					}
 					break;
 				case 'h':
 					// set selected item active
 					if (currentGroup[0]) {
 						// change status for all selected tasks
 						if (not lenG(selectedList)) {
 							set_status(selectedGroup, TASK_STATUS_DONE);
 						}
 						else {
 							// selected items in selectedList
 							forEachSmallArray(selectedList, T) {
 								castS(t, T);
 								set_status(ssGet(t), TASK_STATUS_DONE);
 								finishG(t);
 							}
 							emptyG(selectedList);
 							emptyG(selectedListAttributes);
 						}
 
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						fillCols();
 					}
 					break;
 				case 'j':
 					// set selected item active
 					if (currentGroup[0]) {
 						// change status for all selected tasks
 						if (not lenG(selectedList)) {
 							set_status(selectedGroup, TASK_STATUS_ONGOING);
 						}
 						else {
 							// selected items in selectedList
 							forEachSmallArray(selectedList, T) {
 								castS(t, T);
 								set_status(ssGet(t), TASK_STATUS_ONGOING);
 								finishG(t);
 							}
 							emptyG(selectedList);
 							emptyG(selectedListAttributes);
 						}
 
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						fillCols();
 					}
 					break;
 				case 'k':
 					// set selected item active
 					if (currentGroup[0]) {
 						// change status for all selected tasks
 						if (not lenG(selectedList)) {
 							set_status(selectedGroup, TASK_STATUS_PENDING);
 						}
 						else {
 							// selected items in selectedList
 							forEachSmallArray(selectedList, T) {
 								castS(t, T);
 								set_status(ssGet(t), TASK_STATUS_PENDING);
 								finishG(t);
 							}
 							emptyG(selectedList);
 							emptyG(selectedListAttributes);
 						}
 
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						fillCols();
 					}
 					break;
 				case 'l':
 					// set selected item active
 					if (currentGroup[0]) {
 						// change status for all selected tasks
 						if (not lenG(selectedList)) {
 							set_status(selectedGroup, TASK_STATUS_INACTIVE);
 						}
 						else {
 							// selected items in selectedList
 							forEachSmallArray(selectedList, T) {
 								castS(t, T);
 								set_status(ssGet(t), TASK_STATUS_INACTIVE);
 								finishG(t);
 							}
 							emptyG(selectedList);
 							emptyG(selectedListAttributes);
 						}
 
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						fillCols();
 					}
 					break;
 				case 'o':
 					// set selected item active
 					if (currentGroup[0]) {
 						// change status for all selected tasks
 						if (not lenG(selectedList)) {
 							set_status(selectedGroup, TASK_STATUS_VOID);
 						}
 						else {
 							// selected items in selectedList
 							forEachSmallArray(selectedList, T) {
 								castS(t, T);
 								set_status(ssGet(t), TASK_STATUS_VOID);
 								finishG(t);
 							}
 							emptyG(selectedList);
 							emptyG(selectedListAttributes);
 						}
 
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						fillCols();
 					}
 					break;
 				case 'z':
 					// select all in list
 					if (currentGroup[0]) {
 						// select only in group, not database list
 						if (lenG(selectedList)) {
 							// deselect all items
 							emptyG(selectedList);
 							emptyG(selectedListAttributes);
 						}
 						else {
 							// nothing is selected, select all
 							// except group title
 							enumerateSmallArray(lsGroup, D, i) {
 								cast(smallDictt*, d, D);
 								// in groups don't select group title
 								if ((i not_eq 0) or eqG(currentGroup, "root") or (state != SHOWING_DATABASE)) {
 										char *s = getG(d, rtChar, "tid");
 										if (not isBlankG(s)) {
 											pushG(selectedList, s);
 											createAllocateSmallArray(a);
 											pushG(a, currentGroup);
 											pushG(a, (int32_t)state);
 											pushNFreeG(selectedListAttributes, a);
 										}
 								}
 								finishG(d);
 							}
 						}
 						showCols();
 					}
 					break;
 				case 'x':
 					// cut selected items
 					if (currentGroup[0]) {
 						// select only in group, not database list
 						if (not lenG(selectedList)) {
 							pushG(selectedList, selectedGroup);
 							createAllocateSmallArray(a);
 							pushG(a, currentGroup);
 							pushG(a, (int32_t)state);
 							pushNFreeG(selectedListAttributes, a);
 						}
 						paperfunction = CUT;
 
 						move(row-1,0);
 						color_set(cursorColor, NULL);
 						clrtoeol();
 						addnstr("Cut selected items, move to destination and paste (v)", col-1);
 						chgat(-1, 0, cursorColor, NULL);
 					}
 					break;
 				case 'c':
 					// copy selected items
 					if (currentGroup[0]) {
 						// select only in group, not database list
 						if (not lenG(selectedList)) {
 							pushG(selectedList, selectedGroup);
 							createAllocateSmallArray(a);
 							pushG(a, currentGroup);
 							pushG(a, (int32_t)state);
 							pushNFreeG(selectedListAttributes, a);
 						}
 						paperfunction = COPIED;
 
 						move(row-1,0);
 						color_set(cursorColor, NULL);
 						clrtoeol();
 						addnstr("Copied selected items, move to destination and paste (v) or link (b)", col-1);
 						chgat(-1, 0, cursorColor, NULL);
 					}
 					break;
 				case 'v':
 					if ((currentGroup[0]) and (state == SHOWING_DATABASE) and (paperfunction != NO_PAPER)) {
 						pasteClipboard("paste");
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						fillCols();
 					}
 					break;
 				case 'b':
 					// link selected tasks
 					if ((currentGroup[0]) and (state == SHOWING_DATABASE) and (paperfunction != NO_PAPER)) {
 						pasteClipboard("link");
 						// scroll WVIEW window to top
 						windows[WVIEW].indexFirstLine = 0;
 						eraseSubwindows();
 						fillCols();
 					}
 					break;
 				/* case KEY_MOUSE: */
 				/* 	mvaddstr(row-4, 0, "mouse event"); */
 				/* 	if(getmouse(&event) == OK) { */
 				/* 		mvprintw(row-3,0,"x %d y %d z %d bstate 0x%x", event.x, event.y, event.z, event.bstate); */
 				/* 	} */
 				/* 	break; */
 			}
 		}
 		refreshAll();
 	}
 exit:
 	finalizeScreen(mainwin);
 
 	//test();
 
 	// save bookmarks in ini file
 	smallDictt *data      = getG(ini, rtSmallDictt, "data");
 	smallDictt *locations = getG(ini, rtSmallDictt, "locations");
 	smallDictt *filters   = getG(ini, rtSmallDictt, "filters");
 	smallDictt *desktop = getG(ini, rtSmallDictt, "desktop");
 
 	setNFreeG(data, "location", data_location);
 
 	setNFreeG(locations, "add_top_or_bottom", add_top_or_bottom);
 
 	enumerateS(TASK_STATUS_TRIM, name, i) {
 		i32 flt = getG(status_filters, rtI32, i);
 		setG(filters, name, STATUS_FILTER_STATES[flt]);
 	}
 	if (desktop) {
 		smallStringt *b     = joinG(bookmarks, "|");
 		setNFreeG(desktop, "bookmarks", b);
 	}
 	else {
 		// no desktop section in ini file, empty bookmarks
 		if (lenG(bookmarks)) {
 			// create a desktop section
 			desktop = allocG(rtSmallDictt);
 			smallStringt *b     = joinG(bookmarks, "|");
 			setNFreeG(desktop, "bookmarks", b);
 			setG(ini, "desktop", desktop);
 		}
 	}
 
 	char *p = expandHomeG("~/.easydoneit.ini");
 	saveIni(ini, p);
 	free(p);
 	//logVarG(ini);
 
 	saveEdiState();
 
 	terminateG(ini);
 
 	finalizeLibsheepy();
 
 	XSUCCESS
 }