fraawlen
/
Hotpot-proto
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Temporary prototypes of a document management program and gui toolkit I'm working on.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
12 Commits
1 Branch
216KB
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
Hotpot-proto/main.c

1394 lines
36KB
Raw Permalink Blame History 

  1. #define _DEFAULT_SOURCE

  2. #include <dirent.h>

  3. #include <stdlib.h>

  4. #include <stdio.h>

  5. #include <string.h>

  6. #include <sys/stat.h>

  7. #include <unistd.h>

  8. 

  9. #include "btk/btk.h"

  10. 

  11. /* for filesystem navigation */

  12. /* change depending on your system */

  13. #define NAME_SIZE  255

  14. #define PATH_SIZE  4096

  15. 

  16. /* buffer increments */

  17. #define  DIR_BUFFER_INC 100

  18. #define DATA_BUFFER_INC 2

  19. 

  20. #define READ_SIZE 2048

  21. #define TEXT_SIZE 4096

  22. #define ITEM_SIZE 256

  23. 

  24. #define TAG_COL     0

  25. #define UID_COL     1

  26. #define NAME_COL    2

  27. #define DATA_COLS_N 9 /* excludes id, filename and tag */

  28. 

  29. enum tag_type {

  30. 	TAG_NONE       = 0,

  31. 	TAG_STRAY      = 1U << 0,

  32. 	TAG_NEW        = 1U << 1,

  33. 	TAG_DEL        = 1U << 2,

  34. 	TAG_EDITED     = 1U << 3,

  35. 	TAG_VISIBILITY = 1U << 4

  36. };

  37. 

  38. enum status {

  39. 	STATUS_NONE,

  40. 	STATUS_ERROR,

  41. 	STATUS_LATEST,

  42. 	STATUS_EDITED,

  43. 	STATUS_BUSY

  44. };

  45. 

  46. enum dir_mode {

  47. 	DIR_FILES  = 1U << 0,

  48. 	DIR_HIDDEN = 1U << 1

  49. };

  50. 

  51. typedef struct {

  52. 	char uid[ITEM_SIZE];

  53. 	char filename[ITEM_SIZE];

  54. 	char misc[DATA_COLS_N][ITEM_SIZE];

  55. 	char notes[TEXT_SIZE];

  56. 	unsigned int notes_w;

  57. } data_entry_t;

  58. 

  59. /* window creation functions */

  60. void build_entry_form  ();

  61. void build_file_picker ();

  62. void build_main_window ();

  63. void build_settings    ();

  64. 

  65. /* functions */

  66. void  clean_string_copy      (char *, char *, unsigned int, int);

  67. int   cmp_str_for_qsort      (const void *, const void*);

  68. void  entry_form_apply       ();

  69. void  entry_form_close       ();

  70. void  entry_form_open        ();

  71. int   file_exists            ();

  72. void  file_picker_close      ();

  73. void  file_picker_open       (int);

  74. void  file_picker_open_entry ();

  75. void  file_picker_open_open  ();

  76. void  file_picker_open_new   ();

  77. void  file_picker_select     ();

  78. int   find_dir_spot          (char *, char *);

  79. char* get_data_item          (unsigned int, unsigned int);

  80. void  hotpot_close           ();

  81. void  hotpot_load            ();

  82. void  hotpot_reload          ();

  83. void  hotpot_sync            ();

  84. void  hotpot_unload          ();

  85. void  move_dir               (int);

  86. void  open_ext_dir           ();

  87. void  open_ext_entry         (int);

  88. void  quit                   ();

  89. int   parse_dir              (char *, int);

  90. void  push_entry             (int, data_entry_t);

  91. void  settings_close         ();

  92. void  settings_open          ();

  93. void  set_activity_status    (int, int);

  94. void  set_entry_tag_col      (unsigned int, int);

  95. void  set_main_win_states    (int);

  96. void  set_file_picker_states (int);

  97. void  str_to_lower_case      (char *);

  98. void  toggle_del_tag         ();

  99. void  toggle_col             (int, btk_arg_t);

  100. void  toggle_hidden          (int, btk_arg_t);

  101. void  toggle_notes           (int, btk_arg_t);

  102. void  toggle_visibility_tag  ();

  103. void  update_select_data     (int);

  104. 

  105. /* btk windows */

  106. btk_session_t *session;

  107. btk_window_t  *entry_form;

  108. btk_window_t  *file_picker;

  109. btk_window_t  *main_win;

  110. btk_window_t  *settings;

  111. btk_window_t  *windows[4];

  112. 

  113. /* btk important cells */

  114. btk_cell_t   *table_cell;

  115. btk_cell_t   *dir_list_cell;

  116. btk_cell_t   *notes_view_cell;

  117. btk_cell_t   *file_select_cell;

  118. btk_cell_t   *activity_cell;

  119. btk_cell_t   *edited_note_cell;

  120. unsigned int  table_cell_id;

  121. unsigned int  dir_list_cell_id;

  122. unsigned int  notes_view_cell_id;

  123. unsigned int  file_select_cell_id;

  124. unsigned int  activity_cell_id;

  125. unsigned int  edited_note_cell_id;

  126. 

  127. /* file navigation */

  128. char          dir_current[PATH_SIZE];

  129. char         *dir_list   = NULL;

  130. int          *dir_spot   = NULL;

  131. unsigned int  dir_list_n = 0;

  132. int           nav_select = -1;

  133. int           nav_mode;

  134. 

  135. /* hotpot data */

  136. int           file_picker_mode;

  137. char          open_dir[PATH_SIZE] = "";

  138. int           hotpot_open   = 0;

  139. char         *data          = NULL;

  140. char         *data_notes    = NULL;

  141. int          *data_tags     = NULL;

  142. int          *data_spot     = NULL;

  143. char         *data_rename   = NULL;

  144. unsigned int  data_n        = 0;

  145. unsigned int  data_buffer_n = 0;

  146. unsigned int  last_uid      = 0;

  147. 

  148. /* selected data */

  149. int           select_data   = -1;

  150. char          select_note[TEXT_SIZE];

  151. 

  152. /* edited data */

  153. char          edited_uid[ITEM_SIZE];

  154. char          edited_filename[ITEM_SIZE];

  155. char          edited_misc[DATA_COLS_N][ITEM_SIZE];

  156. char          edited_note[TEXT_SIZE];

  157. 

  158. /* misc gui stuff */

  159. char status_open_file[PATH_SIZE + NAME_SIZE];

  160. char status_files_n[15];

  161. char status_activity[9];

  162. char misc_titles[DATA_COLS_N][ITEM_SIZE];

  163. char misc_switches[DATA_COLS_N][ITEM_SIZE];

  164. unsigned int data_cols_cw[DATA_COLS_N + 3]  = {1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 2};

  165. int          data_cols_ena[DATA_COLS_N + 3] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

  166. char data_header[DATA_COLS_N + 3][ITEM_SIZE] = {

  167. 	"TAGS",

  168. 	"UID",

  169. 	"FILENAME",

  170. 	"TOPICS",

  171. 	"AUTHORS",

  172. 	"INSTITUTIONS",

  173. 	"PUBLISHER",

  174. 	"YEAR",

  175. 	"VOL",

  176. 	"NO",

  177. 	"PAGES",

  178. 	"ACCESSED"

  179. };

  180. 

  181. /* misc */

  182. btk_arg_t dummy_arg = {.i = 0, .f = 0.0f, .c = NULL, .p = NULL};

  183. 

  184. /*******************************************************************/

  185. 

  186. void

  187. build_entry_form()

  188. {

  189. 	entry_form = btk_window_create(session->x_con,

  190. 	                               session->x_scr,

  191. 	                               session->x_vis,

  192. 	                               8,   6 + DATA_COLS_N,

  193. 								   4,   3 + DATA_COLS_N,

  194. 	                               100, 0,

  195. 	                               10 + 2 * DATA_COLS_N,

  196. 								   entry_form_close);

  197. 	btk_window_set_name(entry_form, "hotpot - entry form");

  198. 

  199. 	edited_note_cell_id = 0;

  200. 	edited_note_cell = &(entry_form->cells[edited_note_cell_id]);

  201. 	btk_cell_set_editor(edited_note_cell, 2, 2 + DATA_COLS_N, 6, 4, (char*)&edited_note, TEXT_SIZE);

  202. 

  203. 	btk_cell_set_mark   (&(entry_form->cells[1]), 0, 0, 2, BTK_JUSTIFY_RIGHT, "uid :");

  204. 	btk_cell_set_mark   (&(entry_form->cells[2]), 0, 1, 2, BTK_JUSTIFY_RIGHT, "filename :");

  205. 	btk_cell_set_mark   (&(entry_form->cells[3]), 2, 0, 6, BTK_JUSTIFY_LEFT, edited_uid);

  206. 	btk_cell_set_input  (&(entry_form->cells[4]), 2, 1, 6, (char*)edited_filename, NAME_SIZE);

  207. 	btk_cell_set_mark   (&(entry_form->cells[5]), 0, 2 + DATA_COLS_N, 2, BTK_JUSTIFY_RIGHT, "notes :");

  208. 	btk_cell_set_empty  (&(entry_form->cells[6]), 0, 3 + DATA_COLS_N, 2, 1);

  209. 	btk_cell_set_button (&(entry_form->cells[7]), 0, 4 + DATA_COLS_N, 2, "apply", entry_form_apply);

  210. 	btk_cell_set_button (&(entry_form->cells[8]), 0, 5 + DATA_COLS_N, 2, "close", entry_form_close);

  211. 

  212. 	/* generate input fields for misc data */

  213. 	for (int i = 0; i < DATA_COLS_N; i++) {

  214. 

  215. 		strcpy(misc_titles[i], data_header[i + 3]);

  216. 		str_to_lower_case(misc_titles[i]);

  217. 		strcat(misc_titles[i], " :");

  218. 

  219. 		btk_cell_set_mark   (&(entry_form->cells[9 + i]),  0, 2 + i, 2, BTK_JUSTIFY_RIGHT, misc_titles[i]);

  220. 		btk_cell_set_input  (&(entry_form->cells[10 + DATA_COLS_N + i]), 2, 2 + i, 6, (char*)edited_misc[i], NAME_SIZE);

  221. 	}

  222. }

  223. 

  224. void

  225. build_file_picker()

  226. {

  227. 	file_picker = btk_window_create(session->x_con,

  228. 	                                session->x_scr,

  229. 	                                session->x_vis,

  230. 	                                4, 9,

  231. 	                                2, 2,

  232. 	                                0, 300,

  233. 	                                5,

  234. 	                                file_picker_close);

  235. 	btk_window_set_name(file_picker, "hotpot - file picker");

  236. 

  237. 	dir_list_cell_id = 0;

  238. 	dir_list_cell = &(file_picker->cells[dir_list_cell_id]);

  239. 	btk_cell_set_list   (dir_list_cell,

  240. 	                     0, 1, 4, 5,

  241. 	                     &dir_list,

  242. 	                     &dir_list_n,

  243. 	                     NAME_SIZE,

  244. 	                     NULL, NULL,

  245. 	                     &dir_spot,

  246. 	                     move_dir,

  247. 	                     set_file_picker_states);

  248. 

  249. 	file_select_cell_id = 1;

  250. 	file_select_cell = &(file_picker->cells[file_select_cell_id]);

  251. 	btk_cell_set_button (file_select_cell, 0, 7, 4, "select", file_picker_select);

  252. 

  253. 	btk_cell_set_mark   (&(file_picker->cells[2]), 0, 0, 4, BTK_JUSTIFY_RIGHT, (char*)&dir_current);

  254. 	btk_cell_set_switch (&(file_picker->cells[3]), 0, 6, 4, "show hidden", toggle_hidden, dummy_arg);

  255. 	btk_cell_set_button (&(file_picker->cells[4]), 0, 8, 4, "cancel", file_picker_close);

  256. }

  257. 

  258. void

  259. build_main_window()

  260. {

  261. 	main_win = btk_window_create(session->x_con,

  262. 	                             session->x_scr,

  263. 	                             session->x_vis,

  264. 	                             13, 16,

  265. 	                             4, 7,

  266. 	                             400, 0,

  267. 	                             21,

  268. 	                             quit);

  269. 	btk_window_set_name(main_win, "hotpot");

  270. 

  271. 	table_cell_id = 0;

  272. 	table_cell = &(main_win->cells[table_cell_id]);

  273. 	btk_cell_set_table(table_cell,

  274. 	                   3, 0, 10, 15,

  275. 	                   (char*)data_header,

  276. 	                   &data,

  277. 	                   ITEM_SIZE,

  278. 	                   DATA_COLS_N + 3,

  279. 	                   &data_n,

  280. 	                   (int*)data_cols_ena,

  281. 	                   data_cols_cw,

  282. 	                   2,

  283. 	                   NULL, NULL,

  284. 	                   &data_spot,

  285. 	                   open_ext_entry,

  286. 	                   update_select_data);

  287. 

  288. 	strcpy(select_note, "");

  289. 	notes_view_cell_id = 1;

  290. 	notes_view_cell = &(main_win->cells[notes_view_cell_id]);

  291. 	btk_cell_set_editor(notes_view_cell,

  292. 	                    3, 9, 10, 6,

  293. 	                    select_note,

  294. 	                    TEXT_SIZE);

  295. 	main_win->cells[notes_view_cell_id].state |= BTK_CELL_STATE_DISABLED;

  296. 	main_win->cells[notes_view_cell_id].state |= BTK_CELL_STATE_HIDDEN;

  297. 

  298. 	activity_cell_id = 18;

  299. 	activity_cell = &(main_win->cells[activity_cell_id]);

  300. 	btk_cell_set_mark   (activity_cell,

  301. 	                     11, 15, 2,

  302. 	                     BTK_JUSTIFY_RIGHT,

  303. 	                     (char*)&status_activity);

  304. 

  305. 	btk_cell_set_button (&(main_win->cells[2]),  0,  0,  3,  "open", file_picker_open_open);

  306. 	btk_cell_set_button (&(main_win->cells[3]),  0,  1,  3,  "new", file_picker_open_new);

  307. 	btk_cell_set_button (&(main_win->cells[4]),  0,  2,  3,  "sync", hotpot_sync);

  308. 	btk_cell_set_button (&(main_win->cells[5]),  0,  3,  3,  "view directory", open_ext_dir);

  309. 	btk_cell_set_button (&(main_win->cells[6]),  0,  4,  3,  "reload", hotpot_reload);

  310. 	btk_cell_set_button (&(main_win->cells[7]),  0,  5,  3,  "close", hotpot_close);

  311. 	btk_cell_set_button (&(main_win->cells[8]),  0,  6,  3,  "quit", quit);

  312. 	btk_cell_set_empty  (&(main_win->cells[9]),  0,  7,  3,  1);

  313. 	btk_cell_set_button (&(main_win->cells[10]), 0,  8,  3,  "add file", file_picker_open_entry);

  314. 	btk_cell_set_button (&(main_win->cells[11]), 0,  9,  3,  "edit entry", entry_form_open);

  315. 	btk_cell_set_button (&(main_win->cells[12]), 0,  10, 3,  "tag for deletion", toggle_del_tag);

  316. 	btk_cell_set_button (&(main_win->cells[19]), 0,  11, 3,  "tag for visibility", toggle_visibility_tag);

  317. 	btk_cell_set_button (&(main_win->cells[20]), 0,  12, 3,  "export citation", NULL);

  318. 	btk_cell_set_empty  (&(main_win->cells[13]), 0,  13, 3,  1);

  319. 	btk_cell_set_switch (&(main_win->cells[14]), 0,  14, 3,  "show notes", toggle_notes, dummy_arg);

  320. 	btk_cell_set_button (&(main_win->cells[15]), 0,  15, 3,  "settings", settings_open);

  321. 	btk_cell_set_mark   (&(main_win->cells[16]), 3,  15, 6,  BTK_JUSTIFY_RIGHT, (char*)&status_open_file);

  322. 	btk_cell_set_mark   (&(main_win->cells[17]), 9,  15, 2,  BTK_JUSTIFY_RIGHT, (char*)&status_files_n);

  323. 

  324. 	main_win->cells[15].state |= BTK_CELL_STATE_ON;

  325. 	main_win->cells[20].state |= BTK_CELL_STATE_DISABLED;

  326. 	set_main_win_states(0);

  327. }

  328. 

  329. void

  330. build_settings()

  331. {

  332. 	settings = btk_window_create(session->x_con,

  333. 	                             session->x_scr,

  334. 	                             session->x_vis,

  335. 	                             3, 3 + DATA_COLS_N,

  336. 	                             -1, -1,

  337. 	                             0, 0,

  338. 	                             3 + DATA_COLS_N,

  339. 	                             settings_close);

  340. 	btk_window_set_name(settings, "hotpot - settings");

  341. 

  342. 	btk_arg_t col_arg= {.i = TAG_COL};

  343. 

  344. 	btk_cell_set_switch (&(settings->cells[0]), 0,  0, 3,  "show tags", toggle_col, col_arg);

  345. 	btk_cell_set_empty  (&(settings->cells[1 + DATA_COLS_N]), 0,  1 + DATA_COLS_N, 3,  1);

  346. 	btk_cell_set_button (&(settings->cells[2 + DATA_COLS_N]), 0,  2 + DATA_COLS_N, 3,  "close", settings_close);

  347. 	

  348. 	settings->cells[0].state |= BTK_CELL_STATE_ON;

  349. 

  350. 	/* generate col toggles for misc data */

  351. 	for (int i = 0; i < DATA_COLS_N; i++) {

  352. 

  353. 		sprintf(misc_switches[i], "show %s", data_header[i + 3]);

  354. 		str_to_lower_case(misc_switches[i]);

  355. 	

  356. 		btk_arg_t col_arg = {.i = i + 3};

  357. 		btk_cell_set_switch (&(settings->cells[1 + i]), 0,  1 + i, 3,  misc_switches[i], toggle_col, col_arg);

  358. 		settings->cells[1 + i].state |= BTK_CELL_STATE_ON;

  359. 	}

  360. }

  361. 

  362. /****************************************************************************************/

  363. 

  364. int

  365. main()

  366. {

  367. 	getcwd(dir_current, PATH_SIZE);

  368. 	strcat(dir_current, "/");

  369. 

  370. 	/* btk init */

  371. 	session = btk_open();

  372. 	build_entry_form();

  373. 	build_file_picker();

  374. 	build_main_window();

  375. 	build_settings();

  376. 	windows[0] = main_win;

  377. 	windows[1] = file_picker;

  378. 	windows[2] = entry_form;

  379. 	windows[3] = settings;

  380. 

  381. 	btk_map(session, main_win);

  382. 	btk_loop(session, windows, 4);

  383. 

  384. 	btk_close(session);

  385. 

  386. 	quit();

  387. 	return 0;

  388. }

  389. 

  390. /****************************************************************************************/

  391. 

  392. void

  393. clean_string_copy(char* dest, char* src, unsigned int max_size, int del_newline)

  394. {

  395. 	if (!max_size)

  396. 		return;

  397. 

  398. 	char mid[max_size];

  399. 	

  400. 	strncpy(mid, src, max_size);

  401. 	if (del_newline)

  402. 		*strchr(mid, '\n') = '\0';

  403. 	mid[max_size - 1] = '\0';

  404. 	strcpy(dest, mid);

  405. }

  406. 

  407. int

  408. cmp_str_for_qsort(const void *a, const void *b)

  409. {

  410. 	return strcmp((char*)a, (char*)b);

  411. }

  412. 

  413. /* check if any data changed, copy it and update status if so */

  414. void

  415. entry_form_apply()

  416. {

  417. 	int changed = 0;

  418. 

  419. 	if (strcmp(edited_filename, get_data_item(NAME_COL, select_data))) {

  420. 		strcpy(data_rename + select_data * ITEM_SIZE, get_data_item(NAME_COL, select_data));

  421. 		strcpy(get_data_item(NAME_COL, select_data), edited_filename);

  422. 		changed = 1;

  423. 	}

  424. 

  425. 	for (int i = 0; i < DATA_COLS_N; i++) {

  426. 		if (strcmp(edited_misc[i], get_data_item(i + 3, select_data))) {

  427. 			strcpy(get_data_item(i + 3, select_data), edited_misc[i]);

  428. 			changed = 1;

  429. 		}

  430. 	}

  431. 	if (strcmp(edited_note, select_note)) {

  432. 		strcpy(data_notes + select_data * TEXT_SIZE, edited_note);

  433. 		strcpy(select_note, edited_note);

  434. 		btk_cell_editor_update_text(notes_view_cell);

  435. 		changed = 1;

  436. 	}

  437. 

  438. 	if (changed) {

  439. 		data_tags[select_data] |= TAG_EDITED;

  440. 		set_entry_tag_col(select_data, data_tags[select_data]);

  441. 		set_activity_status(STATUS_EDITED, 1);

  442. 		btk_window_redraw(main_win);

  443. 	}	

  444. }

  445. 

  446. void

  447. entry_form_open()

  448. {

  449. 	if (select_data < 0 || select_data >= data_n)

  450. 		return;

  451. 

  452. 	strcpy(edited_note, select_note);

  453. 	btk_cell_editor_reset_caret(edited_note_cell);

  454. 

  455. 	strcpy(edited_uid, get_data_item(1, select_data));

  456. 	strcpy(edited_filename, get_data_item(2, select_data));

  457. 	btk_cell_input_reset_caret(&(entry_form->cells[4]));

  458. 

  459. 	for (int i = 0; i < DATA_COLS_N; i++) {

  460. 		strcpy(edited_misc[i], get_data_item(i + 3, select_data));

  461. 		btk_cell_input_reset_caret(&(entry_form->cells[10 + DATA_COLS_N + i]));

  462. 	}

  463. 

  464. 	btk_cell_editor_update_text(edited_note_cell);

  465. 	btk_window_disable(main_win);

  466. 	btk_map(session, entry_form);

  467. }

  468. 

  469. void

  470. entry_form_close()

  471. {

  472. 	btk_window_enable(main_win);

  473. 	btk_unmap(session, entry_form);

  474. }

  475. 

  476. /* checks if currently selected file in the file picker

  477.  * exists in the open hotpot directory */

  478. int

  479. file_exists()

  480. {

  481. 	DIR *d;

  482. 	struct dirent *dir;

  483. 

  484. 	d = opendir(open_dir);

  485. 	if (!d) {

  486. 		printf("ERROR - couldn't read directory");

  487. 		return 0;

  488. 	}

  489. 

  490. 	while ((dir = readdir(d))) {

  491. 		if (!strcmp(dir->d_name, dir_list + nav_select * NAME_SIZE))

  492. 			return 1;

  493. 	}

  494. 

  495. 	return 0;

  496. }

  497. 

  498. void

  499. file_picker_close()

  500. {

  501. 	btk_window_enable(main_win);

  502. 	btk_unmap(session, file_picker);

  503. }

  504. 

  505. void

  506. file_picker_open(int mode)

  507. {

  508. 	btk_cell_list_deselect(dir_list_cell);

  509. 	set_file_picker_states(-1);

  510. 

  511. 	file_picker_mode = mode;

  512. 	if (!file_picker_mode) {

  513. 		nav_mode |= DIR_FILES;

  514. 	} else {

  515. 		nav_mode &= ~DIR_FILES;

  516. 	}

  517. 

  518. 	btk_window_disable(main_win);

  519. 	btk_map(session, file_picker);

  520. 	parse_dir(dir_current, nav_mode);

  521. }

  522. 

  523. void file_picker_open_entry() { file_picker_open(0); }

  524. void file_picker_open_open()  { file_picker_open(1); }

  525. void file_picker_open_new()   { file_picker_open(2); }

  526. 

  527. void

  528. file_picker_select()

  529. {

  530. 	if (nav_select < 0 || nav_select >= dir_list_n) {

  531. 		printf("ERROR -> tried to open out of bound selection\n");

  532. 		return;

  533. 	}

  534. 

  535. 	switch(file_picker_mode) {

  536. 	

  537. 	/* copy selected file into open hotpot directory, then add it to data */

  538. 	case 0:;

  539. 		/* compose command */

  540. 		char cmd[12 + 2 * PATH_SIZE + NAME_SIZE];

  541. 		sprintf(cmd,

  542. 		        "cp -n \'%s%s\' \'%s\'",

  543. 		        dir_current,

  544. 		        dir_list + nav_select * NAME_SIZE,

  545. 		        open_dir);

  546. 		system(cmd);

  547. 		/* create new entry */

  548. 		data_entry_t new_entry;

  549. 		new_entry.notes_w = 0;

  550. 		new_entry.notes[0] = '\0';

  551. 		new_entry.uid[0] = '\0';

  552. 		for (int i = 0; i < DATA_COLS_N; i++)

  553. 			new_entry.misc[i][0] = '\0';

  554. 		strcpy(new_entry.filename, dir_list + nav_select * NAME_SIZE);

  555. 		push_entry(TAG_NEW, new_entry);

  556. 		/* update window */

  557. 		set_activity_status(STATUS_EDITED, 0);

  558. 		set_entry_tag_col(data_n - 1, data_tags[data_n - 1]);

  559. 		set_main_win_states(1);	

  560. 		break;

  561. 

  562. 	/* open hotpot */

  563. 	case 1:

  564. 		strcpy(open_dir, dir_current);

  565. 		strcat(open_dir, dir_list + nav_select * NAME_SIZE);

  566. 		hotpot_load();

  567. 		break;

  568. 

  569. 	/* create hotpot file, then open it */

  570. 	case 2:

  571. 		strcpy(open_dir, dir_current);

  572. 		strcat(open_dir, dir_list + nav_select * NAME_SIZE);

  573. 		char hotpot_file[PATH_SIZE + NAME_SIZE];

  574. 		strcpy(hotpot_file, open_dir);

  575. 		strcat(hotpot_file, "/.htpt");

  576. 		FILE *f = fopen(hotpot_file, "w");

  577. 		if (!f) {

  578. 			set_activity_status(STATUS_ERROR, 1);

  579. 			printf("ERROR - couldn't create new hotpot file");

  580. 			return;

  581. 		}

  582. 		fclose(f);

  583. 		hotpot_load();

  584. 		break;

  585. 	}

  586. 

  587. 	file_picker_close();

  588. 	set_main_win_states(1);

  589. }

  590. 

  591. /* returns the hilight color index of the directory */

  592. int

  593. find_dir_spot(char *search_dir, char *sub_dir)

  594. {

  595. 	char search_path[PATH_SIZE];

  596. 	strcpy(search_path, search_dir);

  597. 	strcat(search_path, sub_dir);

  598. 	strcat(search_path, "/");

  599. 

  600. 	DIR *d;

  601. 	struct dirent *dir;

  602. 	struct stat file_stats;

  603. 	char file_path[PATH_SIZE + NAME_SIZE];

  604. 

  605. 	d = opendir(search_path);

  606. 	if (!d) {

  607. 		printf("ERROR - couldn't read directory");

  608. 		return 0;

  609. 	}

  610. 

  611. 	while ((dir = readdir(d))) {

  612. 		strcpy(file_path, search_path);

  613. 		strcat(file_path, dir->d_name);

  614. 		stat(file_path, &file_stats);

  615. 		if ((file_stats.st_mode & S_IFMT) != S_IFDIR) {

  616. 			if (strcmp(dir->d_name, ".htpt") == 0) {

  617. 				return 1;

  618. 			}

  619. 		}

  620. 	}

  621. 	return 2;

  622. }

  623. 

  624. char*

  625. get_data_item(unsigned int col, unsigned int row)

  626. {

  627. 	return data + ITEM_SIZE * (col + row * (DATA_COLS_N + 3));

  628. }

  629. 

  630. void

  631. hotpot_close()

  632. {

  633. 	hotpot_unload();

  634. 	select_data = -1;

  635. 	strcpy(select_note, "");

  636. 	strcpy(open_dir, "");

  637. 

  638. 	set_main_win_states(1);

  639. }

  640. 

  641. void

  642. hotpot_load()

  643. {

  644. 	set_activity_status(STATUS_BUSY, 1);

  645. 

  646. 	char hotpot_file[PATH_SIZE + NAME_SIZE];

  647. 	strcpy(hotpot_file, open_dir);

  648. 	strcat(hotpot_file, "/.htpt");

  649. 

  650. 	FILE *f = fopen(hotpot_file, "r");

  651. 	if (!f) {

  652. 		printf("ERROR - couldn't read hotpot file\n");

  653. 		set_activity_status(STATUS_ERROR, 1);

  654. 		return;

  655. 	}

  656. 

  657. 	hotpot_unload();

  658. 

  659. 	/* arrays preparation for on the go resizing */

  660. 	data_buffer_n = DATA_BUFFER_INC;

  661. 	data         = malloc(data_buffer_n * ITEM_SIZE * (DATA_COLS_N + 3));

  662. 	data_notes   = malloc(data_buffer_n * TEXT_SIZE);

  663. 	data_tags    = malloc(data_buffer_n * sizeof(int));

  664. 	data_spot    = malloc(data_buffer_n * sizeof(int));

  665. 	data_rename  = malloc(data_buffer_n * ITEM_SIZE); /* used for syncing later */

  666. 

  667. 	data_entry_t entry_read;

  668. 	char line_read[READ_SIZE];

  669. 	char *last_newline;

  670. 	int in_section = 0, col = 0, w = 0;

  671. 

  672. 	/* get lastest used uid on the first line */

  673. 	/* if it is not present it will be regenerated after the rest of the file has

  674. 	 * been parsed */

  675. 	if (fgets(line_read, READ_SIZE, f) && line_read[0] == '-') {

  676. 		last_uid = strtol(line_read + 1, NULL, 16);

  677. 	} else {

  678. 		last_uid = 0; /* to be regenerated */

  679. 	}

  680. 

  681. 	/* parse rest of .htpt file */

  682. 	while (fgets(line_read, READ_SIZE, f)) {

  683. 		switch (line_read[0]) {

  684. 

  685. 		/* open section, reset entry_read */

  686. 		case '[':

  687. 			if (in_section)

  688. 				break;

  689. 			in_section = 1;

  690. 			col = 0;

  691. 			w = 0;

  692. 			entry_read.notes_w = 0;

  693. 			entry_read.notes[0] = '\0';

  694. 			entry_read.uid[0] = '\0';

  695. 			entry_read.filename[0] = '\0';

  696. 			for (int i = 0; i < DATA_COLS_N; i++)

  697. 				entry_read.misc[i][0] = '\0';

  698. 			break;

  699. 

  700. 		/* close section, push entry_read to data */

  701. 		case ']':

  702. 			if (!in_section)

  703. 				break;

  704. 			in_section = 0;

  705. 			last_newline = strrchr(entry_read.notes, '\n');

  706. 			if (last_newline) /* remove last unecessary newline */

  707. 				*last_newline = '\0';

  708. 			push_entry(TAG_STRAY, entry_read);

  709. 			break;

  710. 

  711. 		/* get uid */

  712. 		case '-':

  713. 			if (!in_section)

  714. 				break;

  715. 			clean_string_copy(entry_read.uid, line_read + 1, ITEM_SIZE, 1);

  716. 			break;

  717. 

  718. 		/* get filename */

  719. 		case '+':

  720. 			if (!in_section)

  721. 				break;

  722. 			clean_string_copy(entry_read.filename, line_read + 1, ITEM_SIZE, 1);

  723. 			break;

  724. 

  725. 		/* get other data */

  726. 		case '.':

  727. 			if (!in_section || col >= DATA_COLS_N)

  728. 				break;

  729. 			clean_string_copy(entry_read.misc[col], line_read + 1, ITEM_SIZE, 1);

  730. 			col++;

  731. 			break;

  732. 

  733. 		/* get notes on multiple lines until section close or reaching TEXT_SIZE

  734. 		 * character limit */

  735. 		case '*':

  736. 			if (!in_section)

  737. 				break;

  738. 			w = strlen(line_read + 1);

  739. 			if (entry_read.notes_w + w >= TEXT_SIZE) {

  740. 				w = TEXT_SIZE - entry_read.notes_w;

  741. 			} else {

  742. 				strncat(entry_read.notes, line_read + 1, w);

  743. 			}

  744. 			entry_read.notes_w += w;

  745. 			break;

  746. 

  747. 		default:

  748. 			break;

  749. 		}

  750. 	}

  751. 	fclose(f);

  752. 

  753. 	/* regenerate uid if needed */

  754. 	if (!last_uid) {

  755. 		for (int i = 0; i < data_n; i++)

  756. 			if (last_uid < strtol(get_data_item(UID_COL, i), NULL, 16))

  757. 				last_uid = strtol(get_data_item(UID_COL, i), NULL, 16);

  758. 	}

  759. 

  760. 	/* parse all files in hotpot directory and match them to parsed data */

  761. 	DIR *d = opendir(open_dir);

  762. 	struct dirent *dir;

  763. 	struct stat file_stats;

  764. 	char file_path[PATH_SIZE + NAME_SIZE];

  765. 	int found = 0;

  766. 	int new_files = 0;

  767. 	int n = data_n;

  768. 	int is_dir;

  769. 

  770. 	data_entry_t dummy_entry;

  771. 	dummy_entry.uid[0] = '\0';

  772. 	dummy_entry.notes[0] = '\0';

  773. 	dummy_entry.notes_w = 0;

  774. 	for (int i = 0; i < DATA_COLS_N; i++)

  775. 		dummy_entry.misc[i][0] = '\0';

  776. 

  777. 	/* scan found files */

  778. 	while ((dir = readdir(d))) {

  779. 		found = 0;

  780. 		strcpy(file_path, open_dir);

  781. 		strcat(file_path, dir->d_name);

  782. 		stat(file_path, &file_stats);

  783. 		is_dir = (file_stats.st_mode & S_IFMT) == S_IFDIR ? 1 : 0;

  784. 		//printf("%i\t%s\n", is_dir, dir->d_name); TODO fix directory detection

  785. 		if (is_dir || dir->d_name[0] == '.') {

  786. 			continue;

  787. 		}

  788. 		for (int i = 0; i < n; i++) {

  789. 			if (strcmp(dir->d_name, get_data_item(NAME_COL, i)) == 0) {

  790. 				data_tags[i] = TAG_NONE;

  791. 				found = 1;

  792. 				break;

  793. 			}

  794. 		}

  795. 		/* if file not found, create new entry */

  796. 		if (!found) {

  797. 			clean_string_copy(dummy_entry.filename, dir->d_name, ITEM_SIZE, 0);

  798. 			push_entry(TAG_NEW, dummy_entry);

  799. 			new_files = 1;

  800. 		}

  801. 	}

  802. 

  803. 	/* set tag values in data */

  804. 	for (int i = 0; i < data_n; i++) {

  805. 		set_entry_tag_col(i, data_tags[i]);

  806. 	}

  807. 

  808. 	btk_cell_table_deselect(table_cell);

  809. 	strcpy(select_note, "");

  810. 	set_activity_status((new_files ? STATUS_EDITED : STATUS_LATEST), 1);

  811. 

  812. 		

  813. 	return;

  814. }

  815. 

  816. void

  817. hotpot_reload()

  818. {

  819. 	hotpot_unload();

  820. 	select_data   = -1;

  821. 	strcpy(select_note, "");

  822. 

  823. 	hotpot_load();

  824. 

  825. 	set_main_win_states(1);

  826. }

  827. 

  828. void

  829. hotpot_sync()

  830. {

  831. 	set_activity_status(STATUS_BUSY, 1);

  832. 

  833. 	char hotpot_file[PATH_SIZE + NAME_SIZE];

  834. 	strcpy(hotpot_file, open_dir);

  835. 	strcat(hotpot_file, "/.htpt");

  836. 

  837. 	FILE *f = fopen(hotpot_file, "w");

  838. 	if (!f) {

  839. 		printf("ERROR - couldn't write hotpot file\n");

  840. 		set_activity_status(STATUS_ERROR, 1);

  841. 		return;

  842. 	}

  843. 

  844. 	/* output last uid */

  845. 	fprintf(f, "-%X\n\n", last_uid);

  846. 

  847. 	/* output rows of data */

  848. 	char *note_token;

  849. 	char note[TEXT_SIZE];

  850. 	for (int i = 0; i < data_n; i++) {

  851. 

  852. 		if ((data_tags[i] & TAG_DEL))

  853. 			continue;

  854. 

  855. 		fprintf(f, "[\n");

  856. 

  857. 		fprintf(f, "-%s\n", get_data_item(UID_COL, i));

  858. 		fprintf(f, "+%s\n", get_data_item(NAME_COL, i));

  859. 		for (int j = 0; j < DATA_COLS_N; j++)

  860. 			fprintf(f, ".%s\n", get_data_item(j + 3, i));

  861. 

  862. 		// TODO

  863. 		/*

  864. 		strcpy(note, data_notes + i * TEXT_SIZE);

  865. 		char *lim = strchr(note, '\n');

  866. 		while (lim) {

  867. 			*lim = '\0';

  868. 			printf("%lu >> \'%s\'\n", strlen(note), note);

  869. 			fprintf(f, "*%s\n", note);

  870. 			strcpy(note, ++lim);

  871. 			lim = strchr(note, '\n');

  872. 		}

  873. 		*/

  874. 

  875. 		strcpy(note, data_notes + i * TEXT_SIZE);

  876. 		note_token = strtok(note, "\n");

  877. 		while (note_token) {

  878. 			fprintf(f, "*%s\n", note_token);

  879. 			note_token = strtok(NULL, "\n");

  880. 		}

  881. 

  882. 		fprintf(f, "]\n\n");

  883. 	}

  884. 	fclose(f);

  885. 

  886. 	/* rename edited files if those are not stray entries */

  887. 	char cmd_mv[11 + 2 * (PATH_SIZE + NAME_SIZE)]; 

  888. 	for (int i = 0; i < data_n; i++) {

  889. 		if (!(data_tags[i] & TAG_STRAY) && strcmp(data_rename + i * ITEM_SIZE, "")) {

  890. 			sprintf(cmd_mv,

  891. 			        "mv \'%s/%s\' \'%s/%s\'",

  892. 			        open_dir,

  893. 					data_rename + i * ITEM_SIZE,

  894. 			        open_dir,

  895. 			        get_data_item(NAME_COL, i));

  896. 			system(cmd_mv);

  897. 		}	

  898. 	}

  899. 

  900. 	/* delete rows with DEL tag by shifting down */

  901. 	int c = 0;

  902. 	char mid[TEXT_SIZE]; /* just to get rid of pointer overlap warning */

  903. 	char cmd_rm[5 + PATH_SIZE + NAME_SIZE];

  904. 	for (int i = 0; i < data_n; i++) {

  905. 		if (c) {

  906. 			data_tags[i - c] = data_tags[i];

  907. 			strcpy(mid, data_notes + i * TEXT_SIZE);

  908. 			strcpy(data_notes + (i - c) * TEXT_SIZE, mid);

  909. 			for (int j = 0; j < DATA_COLS_N + 3; j++)

  910. 				strcpy(get_data_item(j, i - c), get_data_item(j, i));

  911. 		}

  912. 		if ((data_tags[i] & TAG_DEL)) {

  913. 			if (!(data_tags[i] & TAG_STRAY)) {

  914. 				sprintf(cmd_rm,

  915. 				        "rm \'%s/%s\'",

  916. 				        open_dir,

  917. 				        get_data_item(NAME_COL, i));

  918. 				system(cmd_rm);

  919. 			}

  920. 			c++;

  921. 		}

  922. 	}

  923. 	data_n -= c;

  924. 

  925. 	/* remove EDIT and NEW tags */

  926. 	for (int i = 0; i < data_n; i++) {

  927. 		data_tags[i] &= ~(TAG_EDITED | TAG_NEW);

  928. 	}

  929. 	

  930. 	/* update tag values in data */

  931. 	for (int i = 0; i < data_n; i++) {

  932. 		set_entry_tag_col(i, data_tags[i]);

  933. 	}

  934. 

  935. 	set_activity_status(STATUS_LATEST, 0);

  936. 	btk_window_redraw(main_win);

  937. 

  938. 	return;

  939. }

  940. 

  941. void

  942. hotpot_unload()

  943. {

  944. 	if (data_n) {

  945. 		free(data);

  946. 		free(data_tags);

  947. 		free(data_spot);

  948. 		free(data_notes);

  949. 		free(data_rename);

  950. 		data_n = 0;

  951. 	}

  952. }

  953. 

  954. void

  955. move_dir(int dir_sel)

  956. {

  957. 	if (dir_sel < 0 || !dir_spot[dir_sel])

  958. 		return;

  959. 

  960. 	/* if first item selected ("..") go one dir up, unless at / */

  961. 	if (!dir_sel) {

  962. 		if (strlen(dir_current) <= 1)

  963. 			return;

  964. 		dir_current[strlen(dir_current) - 1] = '\0';

  965. 		*(strrchr(dir_current, '/')) = '\0';

  966. 	} else {

  967. 		char dir_sel_name[PATH_SIZE];

  968. 		strcpy(dir_sel_name, dir_list + dir_sel * NAME_SIZE);

  969. 		strcat(dir_current, dir_sel_name);

  970. 	}

  971. 

  972. 	strcat(dir_current, "/");

  973. 	parse_dir(dir_current, nav_mode);

  974. 	btk_window_redraw_cell(file_picker, dir_list_cell_id);

  975. 	btk_window_redraw_cell(file_picker, 2);

  976. 

  977. 	if (dir_sel) {

  978. 		btk_cell_list_deselect(dir_list_cell);

  979. 		set_file_picker_states(-1);

  980. 	}

  981. }

  982. 

  983. void

  984. open_ext_dir()

  985. {

  986. 	char *args[PATH_SIZE]={"./EXEC", open_dir, NULL};

  987. 	int pid = fork();

  988. 

  989. 	if (pid == 0) {

  990. 		execvp("xdg-open", args);

  991. 	} else if (pid < 0) {

  992. 		printf("ERROR - couldn't open hotpot directory in file explorer\n");

  993. 	}

  994. }

  995. 

  996. void

  997. open_ext_entry(int sel)

  998. {

  999. 	if (sel < 0)

  1000. 		return;

  1001. 

  1002. 	char file[PATH_SIZE + ITEM_SIZE];

  1003. 	strcpy(file, open_dir);

  1004. 	strcat(file, "/");

  1005. 	strcat(file, get_data_item(NAME_COL, sel));

  1006. 

  1007. 	char *args[PATH_SIZE]={"./EXEC", file, NULL};

  1008. 	int pid = fork();

  1009. 

  1010. 	if (pid == 0) {

  1011. 		execvp("xdg-open", args);

  1012. 	} else if (pid < 0) {

  1013. 		printf("ERROR - couldn't open item externaly\n");

  1014. 	}

  1015. }

  1016. 

  1017. int

  1018. parse_dir(char *dir_path, int mode)

  1019. {

  1020. 	DIR *d = opendir(dir_path);

  1021. 	if (!d) {

  1022. 		printf("ERROR - couldn't read directory");

  1023. 		return 1;

  1024. 	}

  1025. 

  1026. 	struct dirent *dir;

  1027. 	struct stat file_stats;

  1028. 	char file_path[PATH_SIZE + NAME_SIZE];

  1029. 	unsigned int dir_buffer_n = DIR_BUFFER_INC;

  1030. 	int c = 0;

  1031. 	int is_dir;

  1032. 

  1033. 	if (dir_list_n) {

  1034. 		free(dir_list);

  1035. 		free(dir_spot);

  1036. 	}

  1037. 

  1038. 	dir_list_n = 0;

  1039. 	dir_list = malloc(dir_buffer_n * NAME_SIZE);

  1040. 	dir_spot = malloc(dir_buffer_n * sizeof(int));

  1041. 

  1042. 	while ((dir = readdir(d))) {

  1043. 		sprintf(file_path, "%s%s", dir_path, dir->d_name);

  1044. 		stat(file_path, &file_stats);

  1045. 		is_dir = (file_stats.st_mode & S_IFMT) == S_IFDIR ? 1 : 0;

  1046. 		if (((mode & DIR_FILES) || is_dir) && c &&

  1047. 			((mode & DIR_HIDDEN) || dir->d_name[0] != '.' || c < 2)) {

  1048. 			strcpy(dir_list + dir_list_n * NAME_SIZE, dir->d_name);

  1049. 			if (is_dir) /* adding '/' to dir items to easily detect them when sorting */

  1050. 				strcat(dir_list + dir_list_n * NAME_SIZE, "/");

  1051. 			dir_spot[dir_list_n] = 0;	

  1052. 			dir_list_n++;

  1053. 		}

  1054. 		c++;

  1055. 		if (dir_list_n >= dir_buffer_n - 1) {

  1056. 			dir_buffer_n += DIR_BUFFER_INC;

  1057. 			dir_spot = realloc(dir_spot, dir_buffer_n * sizeof(int));

  1058. 			dir_list = realloc(dir_list, dir_buffer_n * NAME_SIZE);

  1059. 		}

  1060. 	}

  1061. 

  1062. 	/* sort dir list and set hilights */

  1063. 	char *a;

  1064. 	qsort(dir_list, dir_list_n, NAME_SIZE, cmp_str_for_qsort);

  1065. 	for (int i = 0; i < dir_list_n; i++) {

  1066. 		a = strchr(dir_list + i * NAME_SIZE, '/');

  1067. 		if (a) {

  1068. 			*a = '\0';

  1069. 			dir_spot[i] = find_dir_spot(dir_path, dir_list + i * NAME_SIZE);

  1070. 		}

  1071. 	}

  1072. 

  1073. 	return 0;

  1074. }

  1075. 

  1076. void

  1077. push_entry(int tag, data_entry_t entry)

  1078. {

  1079. 	if (!data) {

  1080. 		printf("ERROR - tried to push entry into NULL data array\n");

  1081. 		return;

  1082. 	}

  1083. 

  1084. 	if (data_n >= data_buffer_n - 1) {

  1085. 		data_buffer_n += DATA_BUFFER_INC;

  1086. 		data         = realloc(data, data_buffer_n * ITEM_SIZE * (DATA_COLS_N + 3));

  1087. 		data_notes   = realloc(data_notes, data_buffer_n * TEXT_SIZE);

  1088. 		data_tags    = realloc(data_tags, data_buffer_n * sizeof(int));

  1089. 		data_spot    = realloc(data_spot, data_buffer_n * sizeof(int));

  1090. 		data_rename  = realloc(data_rename, data_buffer_n * ITEM_SIZE);

  1091. 	}

  1092. 

  1093. 	if (!strcmp(entry.uid, "")) {

  1094. 		char new_uid[64];

  1095. 		sprintf(new_uid, "%X", ++last_uid);

  1096. 		strcpy(get_data_item(UID_COL, data_n), new_uid);

  1097. 	} else {

  1098. 		strcpy(get_data_item(UID_COL, data_n), entry.uid);

  1099. 	}

  1100. 

  1101. 	data_tags[data_n] = tag;

  1102. 	strcpy(data_rename + data_n * ITEM_SIZE, "");

  1103. 	strcpy(get_data_item(NAME_COL, data_n), entry.filename);

  1104. 	for (int i = 0; i < DATA_COLS_N; i++)

  1105. 		strcpy(get_data_item(i + 3, data_n), entry.misc[i]);

  1106. 	strcpy(data_notes + data_n * TEXT_SIZE, entry.notes);

  1107. 

  1108. 	data_n++;

  1109. }

  1110. 

  1111. void

  1112. quit()

  1113. {

  1114. 	hotpot_unload();

  1115. 	if (dir_list_n) {

  1116. 		free(dir_list);

  1117. 		free(dir_spot);

  1118. 	}

  1119. 

  1120. 	btk_window_destroy(entry_form);

  1121. 	btk_window_destroy(file_picker);

  1122. 	btk_window_destroy(main_win);

  1123. 	btk_window_destroy(settings);

  1124. 	btk_close(session);

  1125. 

  1126. 	exit(0);

  1127. }

  1128. 

  1129. void

  1130. settings_close()

  1131. {

  1132. 	btk_window_enable(main_win);

  1133. 	btk_unmap(session, settings);

  1134. }

  1135. 

  1136. void

  1137. settings_open()

  1138. {

  1139. 	btk_window_disable(main_win);

  1140. 	btk_map(session, settings);

  1141. }

  1142. 

  1143. void

  1144. set_activity_status(int status, int redraw)

  1145. {

  1146. 	switch (status) {

  1147. 	case STATUS_NONE:

  1148. 		strcpy(status_activity, "n/a");

  1149. 		activity_cell->state |=  BTK_CELL_STATE_DISABLED;

  1150. 		activity_cell->state &= ~BTK_CELL_STATE_BELL;

  1151. 		activity_cell->state &= ~BTK_CELL_STATE_ON;

  1152. 		break;

  1153. 	case STATUS_ERROR:

  1154. 		strcpy(status_activity, "error");

  1155. 		activity_cell->state &= ~BTK_CELL_STATE_DISABLED;

  1156. 		activity_cell->state |=  BTK_CELL_STATE_BELL;

  1157. 		activity_cell->state &= ~BTK_CELL_STATE_ON;

  1158. 		break;

  1159. 	case STATUS_LATEST:

  1160. 		strcpy(status_activity, "synced");

  1161. 		activity_cell->state &= ~BTK_CELL_STATE_DISABLED;

  1162. 		activity_cell->state &= ~BTK_CELL_STATE_BELL;

  1163. 		activity_cell->state &= ~BTK_CELL_STATE_ON;

  1164. 		break;

  1165. 	case STATUS_EDITED:

  1166. 		strcpy(status_activity, "unsynced");

  1167. 		activity_cell->state &= ~BTK_CELL_STATE_DISABLED;

  1168. 		activity_cell->state &= ~BTK_CELL_STATE_BELL;

  1169. 		activity_cell->state |= BTK_CELL_STATE_ON;

  1170. 		break;

  1171. 	case STATUS_BUSY:

  1172. 		strcpy(status_activity, "busy");

  1173. 		activity_cell->state &= ~BTK_CELL_STATE_DISABLED;

  1174. 		activity_cell->state |=  BTK_CELL_STATE_BELL;

  1175. 		activity_cell->state &= ~BTK_CELL_STATE_ON;

  1176. 		break;

  1177. 	}

  1178. 	

  1179. 	if (redraw)

  1180. 		btk_window_redraw_cell(main_win, activity_cell_id);	

  1181. }

  1182. 

  1183. void

  1184. set_edit_tag()

  1185. {

  1186. 	if (select_data < 0 || select_data >= data_n) {

  1187. 		printf("ERROR - can't tag out of bounds selection\n");

  1188. 		return;

  1189. 	}

  1190. 

  1191. 	data_tags[select_data] |= TAG_DEL;

  1192. 	btk_window_redraw_cell(main_win, table_cell_id);	

  1193. }

  1194. 

  1195. void

  1196. set_entry_tag_col(unsigned int id, int tag)

  1197. {

  1198. 	if (tag & TAG_DEL) {

  1199. 		strcpy(get_data_item(TAG_COL, id), "DEL");

  1200. 		data_spot[id] = 1;

  1201. 	} else if (tag & TAG_VISIBILITY) {

  1202. 		strcpy(get_data_item(TAG_COL, id), "FOCUS");

  1203. 		data_spot[id] = 4;

  1204. 	} else if (tag & TAG_EDITED){

  1205. 		strcpy(get_data_item(TAG_COL, id), "EDIT");

  1206. 		data_spot[id] = 1;

  1207. 	} else if (tag & TAG_STRAY){

  1208. 		strcpy(get_data_item(TAG_COL, id), "STRAY");

  1209. 		data_spot[id] = 3;

  1210. 	} else if (tag & TAG_NEW){

  1211. 		strcpy(get_data_item(TAG_COL, id), "NEW");

  1212. 		data_spot[id] = 2;

  1213. 	} else {

  1214. 		strcpy(get_data_item(TAG_COL, id), "");

  1215. 		data_spot[id] = 0;

  1216. 	}

  1217. }

  1218. 

  1219. void

  1220. set_file_picker_states(int sel)

  1221. {

  1222. 	nav_select = sel;

  1223. 

  1224. 	if (sel < 1) { /* separate to avoid segfault */

  1225. 		file_select_cell->state |= BTK_CELL_STATE_DISABLED;

  1226. 		btk_window_redraw_cell(file_picker, file_select_cell_id);

  1227. 		return;

  1228. 	}

  1229. 

  1230. 	switch (file_picker_mode) {

  1231. 	case 0:;

  1232. 		char forbidden_path[PATH_SIZE];

  1233. 		strcpy(forbidden_path, open_dir);

  1234. 		strcat(forbidden_path, "/");

  1235. 		if(!dir_spot[sel] && strcmp(dir_current, forbidden_path) != 0 && !file_exists()) {

  1236. 			file_select_cell->state &= ~(BTK_CELL_STATE_DISABLED);

  1237. 		} else {

  1238. 			file_select_cell->state |= BTK_CELL_STATE_DISABLED;

  1239. 		}

  1240. 		break;

  1241. 	case 1:

  1242. 		if (dir_spot[sel] == 1) {

  1243. 			file_select_cell->state &= ~(BTK_CELL_STATE_DISABLED);

  1244. 		} else {

  1245. 			file_select_cell->state |= BTK_CELL_STATE_DISABLED;

  1246. 		}

  1247. 		break;

  1248. 	case 2:

  1249. 		if (dir_spot[sel] == 1) {

  1250. 			file_select_cell->state |= BTK_CELL_STATE_DISABLED;

  1251. 		} else {

  1252. 			file_select_cell->state &= ~(BTK_CELL_STATE_DISABLED);

  1253. 		}

  1254. 		break;

  1255. 	}

  1256. 

  1257. 	btk_window_redraw_cell(file_picker, file_select_cell_id);

  1258. }

  1259. 

  1260. void

  1261. set_main_win_states(int redraw)

  1262. {

  1263. 	if (!(strcmp(open_dir, ""))) {

  1264. 		main_win->cells[4].state  |=  BTK_CELL_STATE_DISABLED;

  1265. 		main_win->cells[5].state  |=  BTK_CELL_STATE_DISABLED;

  1266. 		main_win->cells[6].state  |=  BTK_CELL_STATE_DISABLED;

  1267. 		main_win->cells[7].state  |=  BTK_CELL_STATE_DISABLED;

  1268. 		main_win->cells[10].state |=  BTK_CELL_STATE_DISABLED;

  1269. 		main_win->cells[16].state |=  BTK_CELL_STATE_DISABLED;

  1270. 		main_win->cells[17].state |=  BTK_CELL_STATE_DISABLED;

  1271. 		strcpy(status_open_file, "no hotpot opened");

  1272. 		strcpy(status_files_n, "n/a entries");

  1273. 		set_activity_status(STATUS_NONE, redraw);

  1274. 	} else {

  1275. 		main_win->cells[4].state  &= ~BTK_CELL_STATE_DISABLED;

  1276. 		main_win->cells[5].state  &= ~BTK_CELL_STATE_DISABLED;

  1277. 		main_win->cells[6].state  &= ~BTK_CELL_STATE_DISABLED;

  1278. 		main_win->cells[7].state  &= ~BTK_CELL_STATE_DISABLED;

  1279. 		main_win->cells[10].state &= ~BTK_CELL_STATE_DISABLED;

  1280. 		main_win->cells[16].state &= ~BTK_CELL_STATE_DISABLED;

  1281. 		main_win->cells[17].state &= ~BTK_CELL_STATE_DISABLED;

  1282. 		strcpy(status_open_file, open_dir);

  1283. 		sprintf(status_files_n, "%i entries", data_n);

  1284. 	}

  1285. 

  1286. 	if (data_n < 1 || select_data < 0) {

  1287. 		main_win->cells[11].state |=  BTK_CELL_STATE_DISABLED;

  1288. 		main_win->cells[12].state |=  BTK_CELL_STATE_DISABLED;

  1289. 		main_win->cells[19].state |=  BTK_CELL_STATE_DISABLED;

  1290. 	} else {

  1291. 		main_win->cells[11].state &= ~BTK_CELL_STATE_DISABLED;

  1292. 		main_win->cells[12].state &= ~BTK_CELL_STATE_DISABLED;

  1293. 		main_win->cells[19].state &= ~BTK_CELL_STATE_DISABLED;

  1294. 	}

  1295. 

  1296. 	if (redraw)

  1297. 		btk_window_redraw(main_win);

  1298. }

  1299. 

  1300. void

  1301. str_to_lower_case(char *str)

  1302. {

  1303. 	for (int i = 0; str[i] != '\0'; i++)

  1304. 		if(str[i] >= 'A' && str[i] <= 'Z')

  1305. 			str[i] += 32;

  1306. }

  1307. 

  1308. void

  1309. toggle_col(int val, btk_arg_t arg)

  1310. {

  1311. 	data_cols_ena[arg.i] = val;

  1312. 	btk_cell_table_update_geometry(table_cell);

  1313. 	btk_window_redraw_cell(main_win, table_cell_id);

  1314. }

  1315. 

  1316. void

  1317. toggle_del_tag()

  1318. {

  1319. 	if (select_data < 0 || select_data >= data_n) {

  1320. 		printf("ERROR - can't tag out of bounds selection\n");

  1321. 		return;

  1322. 	}

  1323. 

  1324. 	data_tags[select_data] ^= TAG_DEL;

  1325. 	set_entry_tag_col(select_data, data_tags[select_data]);

  1326. 	set_activity_status(STATUS_EDITED, 1);

  1327. 	btk_window_redraw_cell(main_win, table_cell_id);	

  1328. }

  1329. 

  1330. void

  1331. toggle_hidden(int i, btk_arg_t arg)

  1332. {

  1333. 	if (i) {

  1334. 		nav_mode |= DIR_HIDDEN;

  1335. 	} else {

  1336. 		nav_mode &= ~DIR_HIDDEN;

  1337. 	}

  1338. 	parse_dir(dir_current, nav_mode);

  1339. 	btk_window_redraw_cell(file_picker, dir_list_cell_id);

  1340. }

  1341. 

  1342. void

  1343. toggle_notes(int val, btk_arg_t arg)

  1344. {

  1345. 	if (val) {

  1346. 		table_cell->ca.h = 9;

  1347. 		notes_view_cell->state &= ~BTK_CELL_STATE_HIDDEN;

  1348. 	} else {

  1349. 		table_cell->ca.h = 15;

  1350. 		notes_view_cell->state |= BTK_CELL_STATE_HIDDEN;

  1351. 	}

  1352. 	btk_window_update_cell_area(main_win, table_cell);

  1353. 	btk_window_redraw(main_win);

  1354. }

  1355. 

  1356. void

  1357. toggle_visibility_tag()

  1358. {

  1359. 	if (select_data < 0 || select_data >= data_n) {

  1360. 		printf("ERROR - can't tag out of bounds selection\n");

  1361. 		return;

  1362. 	}

  1363. 

  1364. 	data_tags[select_data] ^= TAG_VISIBILITY;

  1365. 	set_entry_tag_col(select_data, data_tags[select_data]);

  1366. 	btk_window_redraw_cell(main_win, table_cell_id);

  1367. }

  1368. 

  1369. void

  1370. update_select_data(int sel)

  1371. {

  1372. 	select_data = sel;

  1373. 	if (sel > data_n)

  1374. 		select_data = -1;

  1375. 

  1376. 	if (select_data < 0) {

  1377. 		strcpy(select_note, "");

  1378. 		main_win->cells[11].state |= BTK_CELL_STATE_DISABLED;

  1379. 		main_win->cells[12].state |= BTK_CELL_STATE_DISABLED;

  1380. 		main_win->cells[19].state |= BTK_CELL_STATE_DISABLED;

  1381. 	} else {

  1382. 		strcpy(select_note,data_notes + sel * TEXT_SIZE);

  1383. 		main_win->cells[11].state &= ~BTK_CELL_STATE_DISABLED;

  1384. 		main_win->cells[12].state &= ~BTK_CELL_STATE_DISABLED;

  1385. 		main_win->cells[19].state &= ~BTK_CELL_STATE_DISABLED;

  1386. 	}

  1387. 	

  1388. 	btk_cell_editor_update_text(notes_view_cell);

  1389. 	btk_window_redraw_cell(main_win, notes_view_cell_id);	

  1390. 	btk_window_redraw_cell(main_win, 11);	

  1391. 	btk_window_redraw_cell(main_win, 12);	

  1392. 	btk_window_redraw_cell(main_win, 19);	

  1393. }