Context Navigation

source: tags/testbuild/SL/NDS/nds.cxx

Visit:

Last change on this file was 12848, checked in by westram, 10 years ago
reintegrates 'fix' into 'trunk' removes calls to `aw_string_selection` and `aw_string_selection2awar` (implementing another step for #179) adds: log:branches/fix@12839:12847
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 32.5 KB

Line
1	// ================================================================ //
2	// //
3	// File : AWT_nds.cxx //
4	// Purpose : //
5	// //
6	// Institute of Microbiology (Technical University Munich) //
7	// http://www.arb-home.de/ //
8	// //
9	// ================================================================ //
10
11	#include "nds.h"
12	#include <awt_config_manager.hxx>
13	#include <awt_sel_boxes.hxx>
14
15	#include <aw_awar.hxx>
16	#include <aw_file.hxx>
17	#include <aw_msg.hxx>
18	#include <aw_root.hxx>
19	#include <aw_select.hxx>
20	#include <arbdbt.h>
21	#include <items.h>
22	#include <arb_msg_fwd.h>
23
24
25	#define nds_assert(cond) arb_assert(cond)
26
27	#define NDS_PER_PAGE 10 // number of NDS definitions on each config-page
28	#define NDS_PAGES 6 // how many config-pages (each has NDS_PER_PAGE definitions)
29
30	#define NDS_COUNT (NDS_PER_PAGE*NDS_PAGES) // overall number of NDS definitions
31
32	#define AWAR_NDS_PAGE "tmp/viewkeys/page"
33
34	#if defined(DEBUG)
35	#define NDS_STRING_SIZE 200
36	#else
37	#define NDS_STRING_SIZE 4000
38	#endif // DEBUG
39
40	struct NodeTextBuilder {
41	char buf[NDS_STRING_SIZE]; // buffer used to generate output
42	char *bp;
43	int space_left;
44
45	long count;
46	int show_errors; // how many errors to show
47
48	long lengths[NDS_COUNT]; // length of generated string
49	char *dkeys[NDS_COUNT]; // database field name (may be empty)
50	bool rek[NDS_COUNT]; // 1->key is hierarchical (e.g. 'ali_16s/data')
51	char *parsing[NDS_COUNT]; // ACI/SRT program
52	bool at_group[NDS_COUNT]; // whether string shall appear at group NDS entries
53	bool at_leaf[NDS_COUNT]; // whether string shall appear at leaf NDS entries
54
55	void init_buffer() {
56	bp = buf;
57	space_left = NDS_STRING_SIZE-1;
58	}
59	char *get_buffer() {
60	bp[0] = 0;
61	return buf;
62	}
63
64	void insert_overflow_warning() {
65	nds_assert(space_left >= 0); // <0 means 'already warned'
66	while (space_left) {
67	*bp++ = ' ';
68	space_left--;
69	}
70
71	static const char *warning = "..<truncated>";
72	static int warn_len = 0;
73	if (!warn_len) warn_len = strlen(warning);
74
75	strcpy(buf+(NDS_STRING_SIZE-warn_len-1), warning);
76	space_left = -1;
77	}
78
79	void append(char c) {
80	if (space_left >= 1) {
81	*bp++ = c;
82	space_left--;
83	}
84	else if (!space_left) {
85	insert_overflow_warning();
86	}
87	}
88	void append(const char *str, int length = -1) {
89	nds_assert(str);
90	if (length == -1) length = strlen(str);
91	nds_assert(int(strlen(str)) == length);
92
93	if (space_left >= length) {
94	strcpy(bp, str);
95	bp += length;
96	space_left -= length;
97	}
98	else { // space_left < length
99	if (space_left >= 0) {
100	if (space_left>0) {
101	memcpy(bp, str, space_left);
102	bp += space_left;
103	space_left = 0;
104	}
105	insert_overflow_warning();
106	}
107	}
108	}
109
110	__ATTR__FORMAT(2) void appendf(const char *format, ...) { FORWARD_FORMATTED(append, format); }
111	};
112	static NodeTextBuilder *awt_nds_ms = 0;
113
114	inline const char viewkeyAwarName(int i, const char name) {
115	nds_assert(i >= 0 && i < NDS_PER_PAGE);
116	return GBS_global_string("tmp/viewkeys/viewkey_%i/%s", i, name);
117	}
118
119	inline AW_awar viewkeyAwar(AW_root aw_root, AW_default awdef, int i, const char *name, bool string_awar) {
120	const char *awar_name = viewkeyAwarName(i, name);
121	AW_awar *awar = 0;
122	if (string_awar) awar = aw_root->awar_string(awar_name, "", awdef);
123	else awar = aw_root->awar_int(awar_name, 0, awdef);
124	return awar;
125	}
126
127	static void map_viewkey(AW_root aw_root, AW_default awdef, int i, GBDATA gb_viewkey) {
128	// maps one NDS key data to one line of the config window
129
130	GBDATA *gb_key_text = GB_entry(gb_viewkey, "key_text");
131	GBDATA *gb_pars = GB_entry(gb_viewkey, "pars");
132	GBDATA *gb_len1 = GB_entry(gb_viewkey, "len1");
133	GBDATA *gb_group = GB_entry(gb_viewkey, "group");
134	GBDATA *gb_leaf = GB_entry(gb_viewkey, "leaf");
135
136	nds_assert(gb_key_text);
137	nds_assert(gb_pars);
138	nds_assert(gb_len1);
139	nds_assert(gb_group);
140	nds_assert(gb_leaf);
141
142	AW_awar *Awar;
143	Awar = viewkeyAwar(aw_root, awdef, i, "key_text", true); Awar->map(gb_key_text);
144	Awar = viewkeyAwar(aw_root, awdef, i, "pars", true); Awar->map(gb_pars);
145	Awar = viewkeyAwar(aw_root, awdef, i, "len1", false); Awar->map(gb_len1); Awar->set_minmax(0, 1000000);
146	Awar = viewkeyAwar(aw_root, awdef, i, "group", false); Awar->map(gb_group);
147	Awar = viewkeyAwar(aw_root, awdef, i, "leaf", false); Awar->map(gb_leaf);
148	}
149
150	static void map_viewkeys(AW_root aw_root, /AW_default/ GBDATA awdef, GBDATA *gb_main) {
151	// map visible viewkeys to internal db entries
152	static bool initialized = false;
153	AW_awar *awar_selected_page = 0;
154
155	if (!initialized) {
156	awar_selected_page = aw_root->awar_int(AWAR_NDS_PAGE, 0);
157	awar_selected_page->add_callback(makeRootCallback(map_viewkeys, awdef, gb_main)); // bind to self
158	initialized = true;
159	}
160	else {
161	awar_selected_page = aw_root->awar(AWAR_NDS_PAGE);
162	}
163
164	int page = awar_selected_page->read_int();
165	#if defined(DEBUG)
166	printf("map_viewkeys to page %i\n", page);
167	#endif // DEBUG
168	if (page<NDS_PAGES) {
169	GB_transaction ta(gb_main);
170
171	GBDATA *gb_arb_presets = GB_search(gb_main, "arb_presets", GB_CREATE_CONTAINER);
172	GBDATA *gb_viewkey = 0;
173
174	int i1 = page*NDS_PER_PAGE;
175	int i2 = i1+NDS_PER_PAGE-1;
176
177	for (int i = 0; i <= i2; i++) {
178	gb_viewkey = !gb_viewkey ? GB_entry(gb_arb_presets, "viewkey") : GB_nextEntry(gb_viewkey);
179	nds_assert(i<NDS_COUNT);
180	nds_assert(gb_viewkey);
181	if (i >= i1) map_viewkey(aw_root, awdef, i-i1, gb_viewkey);
182	}
183	}
184	}
185
186	void create_nds_vars(AW_root aw_root, AW_default awdef, GBDATA gb_main) {
187	GB_push_transaction(gb_main);
188
189	GBDATA *gb_viewkey = 0;
190	GBDATA *gb_arb_presets = GB_search(gb_main, "arb_presets", GB_CREATE_CONTAINER);
191
192	for (int i = 0; i<NDS_COUNT; ++i) {
193	gb_viewkey = !gb_viewkey ? GB_entry(gb_arb_presets, "viewkey") : GB_nextEntry(gb_viewkey);
194
195	if (!gb_viewkey) gb_viewkey = GB_create_container(gb_arb_presets, "viewkey");
196
197	{
198	int group = 0;
199	int leaf = 0;
200	bool was_group_name = false;
201	int default_len = 30;
202
203	GBDATA *gb_key_text = GB_entry(gb_viewkey, "key_text");
204	if (!gb_key_text) {
205	gb_key_text = GB_create(gb_viewkey, "key_text", GB_STRING);
206	const char *wanted = "";
207	switch (i) {
208	case 0: wanted = "name"; default_len = 12; leaf = 1; break;
209	case 1: wanted = "full_name"; leaf = 1; break;
210	case 2: wanted = ""; was_group_name = true; break;
211	case 3: wanted = "acc"; default_len = 20; leaf = 1; break;
212	case 4: wanted = "date"; break;
213	}
214	GB_write_string(gb_key_text, wanted);
215	}
216
217	if (strcmp(GB_read_char_pntr(gb_key_text), "group_name") == 0) {
218	GB_write_string(gb_key_text, "");
219	was_group_name = true; // means: change group/leaf + add 'taxonomy(1)' to ACI
220	}
221
222	GB_searchOrCreate_int(gb_viewkey, "len1", default_len);
223	GBDATA *gb_pars = GB_searchOrCreate_string(gb_viewkey, "pars", "");
224
225	if (was_group_name) {
226	group = 1;
227	leaf = 0;
228
229	const char *pars = GB_read_char_pntr(gb_pars);
230
231	if (pars[0] == 0) pars = "taxonomy(1)"; // empty ACI/SRT
232	else if (pars[0] == ':') pars = GBS_global_string("taxonomy(1)\|%s", pars); // was an SRT -> unsure what to do
233	else if (pars[0] == '\|') pars = GBS_global_string("taxonomy(1)%s", pars); // was an ACI -> prefix taxonomy
234	else pars = GBS_global_string("taxonomy(1)\|%s", pars); // other ACIs -> same
235
236	GB_write_string(gb_pars, pars);
237	}
238
239	{
240	GBDATA *gb_flag1 = GB_entry(gb_viewkey, "flag1");
241	if (gb_flag1) {
242	if (GB_read_int(gb_flag1)) { // obsolete
243	leaf = 1;
244	}
245	GB_ERROR error = GB_delete(gb_flag1);
246	if (error) aw_message(error);
247	}
248	}
249
250	{
251	GBDATA *gb_inherit = GB_entry(gb_viewkey, "inherit");
252	if (gb_inherit) { // 'inherit' is old NDS style -> convert & delete
253	if (was_group_name && GB_read_int(gb_inherit)) leaf = 1;
254	GB_ERROR error = GB_delete(gb_inherit);
255	if (error) aw_message(error);
256	}
257	}
258
259	GB_searchOrCreate_int(gb_viewkey, "group", group);
260	GB_searchOrCreate_int(gb_viewkey, "leaf", leaf);
261	}
262	}
263
264	aw_root->awar_string(AWAR_KEY_SELECT, "", awdef);
265	GB_pop_transaction(gb_main);
266
267	map_viewkeys(aw_root, awdef, gb_main); // call once
268	}
269
270	static void awt_pre_to_view(AW_root *aw_root) {
271	char *str = aw_root->awar(AWAR_SELECT_ACISRT_PRE)->read_string();
272	char *brk = strchr(str, '#');
273	if (brk) {
274	*(brk++) = 0;
275	aw_root->awar(AWAR_SELECT_ACISRT)->write_string(brk);
276	}
277	else {
278	aw_root->awar(AWAR_SELECT_ACISRT)->write_string(str);
279	}
280	free(str);
281	}
282	void AWT_popup_select_srtaci_window(AW_window aww, const char acisrt_awarname) {
283	static AW_window *win = 0;
284
285	if (!win) {
286	AW_root *aw_root = aww->get_root();
287	aw_root->awar_string(AWAR_SELECT_ACISRT);
288	aw_root->awar_string(AWAR_SELECT_ACISRT_PRE);
289	aw_root->awar(AWAR_SELECT_ACISRT)->map(acisrt_awarname);
290
291	AW_window_simple *aws = new AW_window_simple;
292	aws->init(aw_root, "SRT_ACI_SELECT", "SRT_ACI_SELECT");
293	aws->load_xfig("awt/srt_select.fig");
294	aws->button_length(13);
295
296	aws->callback(AW_POPDOWN);
297	aws->at("close");
298	aws->create_button("CLOSE", "CLOSE", "C");
299
300	aws->callback(makeHelpCallback("acisrt.hlp"));
301	aws->at("help");
302	aws->create_button("HELP", "HELP", "H");
303
304	aws->at("box");
305	AW_selection_list *programs = aws->create_selection_list(AWAR_SELECT_ACISRT_PRE, true);
306	GB_ERROR error;
307	{
308	StorableSelectionList storable_sellist(TypedSelectionList("sellst", programs, "SRT/ACI scripts", "srt_aci"));
309	error = storable_sellist.load(GB_path_in_ARBLIB("sellists/srt_aci*.sellst"), false);
310	}
311	if (error) aw_message(error);
312
313	aws->at("field");
314	aws->create_text_field(AWAR_SELECT_ACISRT);
315
316	aw_root->awar(AWAR_SELECT_ACISRT_PRE)->add_callback(awt_pre_to_view);
317	awt_pre_to_view(aw_root);
318	win = (AW_window*)aws;
319	}
320	win->activate();
321	}
322
323	static void nds_init_config(AWT_config_definition& cdef) {
324	for (int i = 0; i<NDS_PER_PAGE; ++i) {
325	cdef.add(viewkeyAwarName(i, "leaf"), "leaf", i);
326	cdef.add(viewkeyAwarName(i, "group"), "group", i);
327	cdef.add(viewkeyAwarName(i, "key_text"), "key_text", i);
328	cdef.add(viewkeyAwarName(i, "len1"), "len1", i);
329	cdef.add(viewkeyAwarName(i, "pars"), "pars", i);
330	}
331	}
332
333	static char *nds_store_config(AW_CL, AW_CL) {
334	AWT_config_definition cdef;
335	nds_init_config(cdef);
336	return cdef.read();
337	}
338
339	static void nds_restore_config(const char *stored, AW_CL, AW_CL) {
340	AWT_config_definition cdef;
341	nds_init_config(cdef);
342
343	AWT_config parsedCfg(stored);
344	if (parsedCfg.has_entry("inherit0")) {
345	aw_message("Converting stored config to new NDS format -- consider saving it again.");
346	// Note: The conversion applied here is also done in create_nds_vars()
347
348	GB_ERROR error = 0;
349
350	for (int i = 0; !error && i<NDS_COUNT; ++i) {
351	bool was_group_name = false;
352	{
353	const char *key_text_key = GBS_global_string("key_text%i", i);
354	const char *key_text = parsedCfg.get_entry(key_text_key);
355	if (strcmp(key_text, "group_name") == 0) {
356	was_group_name = true;
357	parsedCfg.set_entry(key_text_key, "");
358	}
359	}
360
361	bool leaf = false;
362	bool group = false;
363	int inherit = 0;
364
365	{
366	const char *inherit_key = GBS_global_string("inherit%i", i);
367	const char *inherit_value = parsedCfg.get_entry(inherit_key);
368
369	if (inherit_value) {
370	inherit = atoi(inherit_value);
371	parsedCfg.delete_entry(inherit_key);
372	}
373	else {
374	error = GB_export_errorf("Expected entry '%s' in saved config", inherit_key);
375	}
376	}
377
378	if (was_group_name) {
379	if (!error) {
380	leaf = inherit;
381	group = true;
382
383	char *aci_key = GBS_global_string_copy("pars%i", i);
384	const char *aci = parsedCfg.get_entry(aci_key);
385	char *new_aci = 0;
386
387	if (aci[0] == 0) { new_aci = strdup("taxonomy(1)"); }
388	else if (aci[0] == '\|') { new_aci = GBS_global_string_copy("taxonomy(1)%s", aci); }
389	else { new_aci = GBS_global_string_copy("taxonomy(1)\|%s", aci); }
390
391	parsedCfg.set_entry(aci_key, new_aci);
392
393	free(new_aci);
394	free(aci_key);
395	}
396	}
397	else {
398	leaf = true;
399	}
400
401	if (!error) {
402	const char *flag1_key = GBS_global_string("active%i", i);
403	const char *flag1_value = parsedCfg.get_entry(flag1_key);
404	if (flag1_value) {
405	int flag1 = atoi(flag1_value);
406	if (flag1 == 0) { leaf = group = false; }
407	parsedCfg.delete_entry(flag1_key);
408	}
409	else {
410	error = GB_export_errorf("Expected entry '%s' in saved config", flag1_key);
411	}
412	}
413
414	if (!error) {
415	const char *leaf_key = GBS_global_string("leaf%i", i);
416	parsedCfg.set_entry(leaf_key, GBS_global_string("%i", int(leaf)));
417	const char *group_key = GBS_global_string("group%i", i);
418	parsedCfg.set_entry(group_key, GBS_global_string("%i", int(group)));
419	}
420	}
421
422	if (!error) {
423	char *converted_cfg_str = parsedCfg.config_string();
424	cdef.write(converted_cfg_str);
425	free(converted_cfg_str);
426	}
427	else {
428	aw_message(error);
429	}
430	}
431	else {
432	cdef.write(stored);
433	}
434	}
435
436	AW_window AWT_create_nds_window(AW_root aw_root, GBDATA *gb_main) {
437	static AW_window_simple *aws = 0;
438	if (!aws) {
439	aws = new AW_window_simple;
440	aws->init(aw_root, "NDS_PROPS", "NDS");
441	aws->load_xfig("awt/nds.fig");
442	aws->auto_space(10, 5);
443
444	aws->callback(AW_POPDOWN);
445	aws->at("close");
446	aws->create_button("CLOSE", "CLOSE", "C");
447
448	aws->at("help");
449	aws->callback(makeHelpCallback("props_nds.hlp"));
450	aws->create_button("HELP", "HELP", "H");
451
452	aws->at("page");
453	aws->create_option_menu(AWAR_NDS_PAGE, true);
454	for (int p = 0; p < NDS_PAGES; p++) {
455	const char text = GBS_global_string("Entries %i - %i", pNDS_PER_PAGE+1, (p+1)*NDS_PER_PAGE);
456	aws->insert_option(text, "", p);
457	}
458	aws->update_option_menu();
459
460	AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "nds", nds_store_config, nds_restore_config, 0, 0);
461
462	// --------------------
463
464	aws->button_length(13);
465	int dummy, closey;
466	aws->at_newline();
467	aws->get_at_position(&dummy, &closey);
468
469	aws->create_button(0, "K");
470
471	aws->at_newline();
472
473	int leafx, groupx, fieldselectx, fieldx, columnx, srtx, srtux;
474
475	aws->auto_space(10, 0);
476
477	int i;
478	for (i=0; i<NDS_PER_PAGE; i++) {
479	aws->get_at_position(&leafx, &dummy);
480	aws->create_toggle(viewkeyAwarName(i, "leaf"));
481
482	aws->get_at_position(&groupx, &dummy);
483	aws->create_toggle(viewkeyAwarName(i, "group"));
484
485	{
486	const char *awar_name = strdup(viewkeyAwarName(i, "key_text"));
487
488	aws->button_length(20);
489	aws->get_at_position(&fieldx, &dummy);
490	aws->create_input_field(awar_name, 15);
491
492	aws->button_length(0);
493
494	FieldSelectionParam *fsp = new FieldSelectionParam(gb_main, awar_name, false); // awar_name belongs to fsp now
495	aws->callback(makeWindowCallback(popup_select_species_field_window, fsp)); // fsp belongs to callback now
496	aws->get_at_position(&fieldselectx, &dummy);
497
498	char *button_id = GBS_global_string_copy("SELECT_NDS_%i", i+1);
499	aws->create_button(button_id, "N");
500	free(button_id);
501	}
502
503	aws->get_at_position(&columnx, &dummy);
504	aws->create_input_field(viewkeyAwarName(i, "len1"), 4);
505
506	{
507	char *awar_name = strdup(viewkeyAwarName(i, "pars"));
508
509	aws->get_at_position(&srtx, &dummy);
510	aws->button_length(0);
511	aws->callback(makeWindowCallback(AWT_popup_select_srtaci_window, awar_name)); // awar_name belongs to cbs now
512	{
513	char *button_id = GBS_global_string_copy("SELECT_SRTACI_%i", i+1);
514	aws->create_button(button_id, "S");
515	free(button_id);
516	}
517
518	aws->get_at_position(&srtux, &dummy);
519	aws->at_set_to(true, false, -7, 30);
520	aws->create_input_field(awar_name, 40);
521	}
522
523	aws->at_unset_to();
524	aws->at_newline();
525	}
526
527	aws->at(leafx, closey);
528
529	aws->at_x(leafx);
530	aws->create_button(0, "LEAF");
531	aws->at_x(groupx);
532	aws->create_button(0, "GRP.");
533
534	aws->at_x(fieldx);
535	aws->create_button(0, "FIELD");
536
537	aws->at_x(fieldselectx);
538	aws->create_button(0, "SEL");
539
540	aws->at_x(columnx);
541	aws->create_button(0, "WIDTH");
542
543	aws->at_x(srtx);
544	aws->create_button(0, "SRT");
545
546	aws->at_x(srtux);
547	aws->create_button(0, "ACI/SRT PROGRAM");
548	}
549
550	return aws;
551	}
552
553
554
555	void make_node_text_init(GBDATA *gb_main) {
556	GBDATA gbz, gbe;
557	int count;
558
559	if (!awt_nds_ms) awt_nds_ms = (NodeTextBuilder *) GB_calloc(sizeof(NodeTextBuilder), 1);
560
561	GBDATA *gb_arb_presets = GB_search(gb_main, "arb_presets", GB_CREATE_CONTAINER);
562	count = 0;
563
564	for (gbz = GB_entry(gb_arb_presets, "viewkey"); gbz; gbz = GB_nextEntry(gbz)) {
565	// toggle set ?
566	bool at_leaf = *GBT_read_int(gbz, "leaf");
567	bool at_group = *GBT_read_int(gbz, "group");
568
569
570	if (at_leaf \|\| at_group) {
571	freeset(awt_nds_ms->dkeys[count], GB_read_string(GB_entry(gbz, "key_text")));
572
573	awt_nds_ms->rek[count] = (GB_first_non_key_char(awt_nds_ms->dkeys[count]) != 0);
574	awt_nds_ms->lengths[count] = *GBT_read_int(gbz, "len1");
575	awt_nds_ms->at_leaf[count] = at_leaf;
576	awt_nds_ms->at_group[count] = at_group;
577
578	gbe = GB_entry(gbz, "pars");
579	freenull(awt_nds_ms->parsing[count]);
580	if (gbe && GB_read_string_count(gbe)>1) awt_nds_ms->parsing[count] = GB_read_string(gbe);
581	count++;
582	}
583	}
584	awt_nds_ms->show_errors = 10;
585	awt_nds_ms->count = count;
586	}
587
588	static char quoted_if_containing_separator(const char text, char separator) {
589	bool contains_separator = strchr(text, separator) != NULL;
590	if (!contains_separator) return NULL;
591	return GBS_global_string_copy("\"%s\"", text);
592	}
593
594	const char make_node_text_nds(GBDATA gb_main, GBDATA * gbd, NDS_Type mode, GBT_TREE species, const char tree_name) {
595	awt_nds_ms->init_buffer();
596
597	if (!gbd) {
598	if (!species) return "<internal error: no tree-node, no db-entry>";
599	if (!species->name) return "<internal error: species w/o name>";
600	awt_nds_ms->appendf("<%s>", species->name); // zombie
601	}
602	else {
603	bool field_was_printed = false;
604	bool is_leaf = species ? species->is_leaf : true;
605
606	for (int i = 0; i < awt_nds_ms->count; i++) {
607	if (is_leaf) { if (!awt_nds_ms->at_leaf[i]) continue; }
608	else { if (!awt_nds_ms->at_group[i]) continue; }
609
610	char *str = 0; // the generated string
611	bool apply_aci = false; // whether aci shall be applied
612	bool align_left = true; // otherwise align right
613
614	{
615	const char *field_output = "";
616	const char *field_name = awt_nds_ms->dkeys[i];
617
618	if (field_name[0] == 0) { // empty field_name -> only do ACI/SRT
619	apply_aci = true;
620	}
621	else { // non-empty field_name
622	GBDATA *gbe;
623	if (awt_nds_ms->rek[i]) { // hierarchical key
624	gbe = GB_search(gbd, awt_nds_ms->dkeys[i], GB_FIND);
625	}
626	else { // flat entry
627	gbe = GB_entry(gbd, awt_nds_ms->dkeys[i]);
628	}
629	// silently ignore missing fields (and leave apply_aci false!)
630	if (gbe) {
631	apply_aci = true;
632	switch (GB_read_type(gbe)) {
633	case GB_INT: field_output = GBS_global_string("%li", GB_read_int(gbe)); align_left = false; break;
634	case GB_BYTE: field_output = GBS_global_string("%i", GB_read_byte(gbe)); align_left = false; break;
635
636	case GB_FLOAT: {
637	const char *format = "%5.4f";
638	if (mode == NDS_OUTPUT_TAB_SEPARATED) { // '.' -> ','
639	char *dotted = GBS_global_string_copy(format, GB_read_float(gbe));
640	char *dot = strchr(dotted, '.');
641	if (dot) *dot = ',';
642	field_output = GBS_static_string(dotted);
643	free(dotted);
644	}
645	else {
646	field_output = GBS_global_string(format, GB_read_float(gbe));
647	}
648	align_left = false;
649	break;
650	}
651	case GB_STRING:
652	field_output = GB_read_char_pntr(gbe);
653	if (!field_output) field_output="<read error>";
654	break;
655
656	default: {
657	char *as_string = GB_read_as_string(gbe);
658	field_output = GBS_static_string(as_string);
659	free(as_string);
660	}
661	}
662	}
663	else {
664	if (GB_have_error()) {
665	field_output = GB_await_error();
666	}
667	}
668	}
669	str = strdup(field_output);
670	}
671
672	// apply ACI/SRT program
673
674	GB_ERROR error = 0;
675	if (apply_aci) {
676	const char *aci_srt = awt_nds_ms->parsing[i];
677	if (aci_srt) {
678	char *aci_result = GB_command_interpreter(gb_main, str, aci_srt, gbd, tree_name);
679	if (!aci_result) aci_result = GBS_global_string_copy("<error: %s>", GB_await_error());
680	freeset(str, aci_result);
681	}
682	}
683
684	NDS_mask_nonprintable_chars(str);
685
686	// quote string, if it contains separator
687	{
688	char *quoted = NULL;
689	switch (mode) {
690	case NDS_OUTPUT_COMMA_SEPARATED:
691	quoted = quoted_if_containing_separator(str, ',');
692	break;
693
694	case NDS_OUTPUT_TAB_SEPARATED:
695	quoted = quoted_if_containing_separator(str, '\t');
696	break;
697
698	case NDS_OUTPUT_LEAFTEXT:
699	case NDS_OUTPUT_SPACE_PADDED:
700	break;
701	}
702
703	if (quoted) freeset(str, quoted);
704	}
705
706
707	bool skip_display = (mode == NDS_OUTPUT_LEAFTEXT && str[0] == 0);
708	if (!skip_display) {
709	switch (mode) {
710	case NDS_OUTPUT_LEAFTEXT:
711	if (!field_was_printed) break; // no comma no space if nothing printed yet
712	awt_nds_ms->append(','); // separate single fields by comma in compressed mode
713	// fall-through
714	case NDS_OUTPUT_SPACE_PADDED:
715	awt_nds_ms->append(' '); // print at least one space if not using tabs
716	break;
717
718	case NDS_OUTPUT_COMMA_SEPARATED:
719	if (i != 0) awt_nds_ms->append(','); // CSV output for star-calc/excel/...
720	break;
721
722	case NDS_OUTPUT_TAB_SEPARATED:
723	if (i != 0) awt_nds_ms->append('\t'); // tabbed output for star-calc/excel/...
724	break;
725	}
726
727	field_was_printed = true;
728
729	int str_len = strlen(str);
730	switch (mode) {
731	case NDS_OUTPUT_TAB_SEPARATED:
732	case NDS_OUTPUT_COMMA_SEPARATED:
733	awt_nds_ms->append(str, str_len);
734	break;
735
736	case NDS_OUTPUT_LEAFTEXT:
737	case NDS_OUTPUT_SPACE_PADDED: {
738	int nds_len = awt_nds_ms->lengths[i];
739	if (str_len>nds_len) { // string is too long -> shorten
740	str[nds_len] = 0;
741	str_len = nds_len;
742	}
743
744	if (mode == NDS_OUTPUT_SPACE_PADDED) { // may need alignment
745	const char spaced = GBS_global_string((align_left ? "%-s" : "%*s"), nds_len, str);
746	awt_nds_ms->append(spaced, nds_len);
747	}
748	else {
749	nds_assert(mode == NDS_OUTPUT_LEAFTEXT);
750	awt_nds_ms->append(str, str_len);
751	}
752	}
753	}
754	}
755
756	// show first XXX errors
757	if (error && awt_nds_ms->show_errors>0) {
758	awt_nds_ms->show_errors--;
759	aw_message(error);
760	}
761
762	free(str);
763	}
764	}
765
766	return awt_nds_ms->get_buffer();
767	}
768
769	static const char *createReplaceTable() {
770	static char replaceTable[256];
771
772	for (int i = 0; i<32; ++i) replaceTable[i] = '?';
773	for (int i = 32; i<256; ++i) replaceTable[i] = i;
774
775	const char LFREP = '#';
776
777	replaceTable['\n'] = LFREP;
778	replaceTable['\r'] = LFREP;
779	replaceTable['\t'] = ' ';
780
781	return replaceTable;
782	}
783
784	char NDS_mask_nonprintable_chars(char const str) {
785	// mask nonprintable characters in result of NDS.
786	//
787	// modifies and returns 'str'
788	//
789	// background: gtk renders LFs as such (i.e. renders multiple lines),
790	// motif printed a small box (i.e. rendered all text in one line)
791
792	static const char *replaceTable = createReplaceTable();
793	for (int i = 0; str[i]; ++i) {
794	str[i] = replaceTable[safeCharIndex(str[i])];
795	}
796	return str;
797	}
798
799	// --------------------------------------------------------------------------------
800
801	#ifdef UNIT_TESTS
802	#ifndef TEST_UNIT_H
803	#include <test_unit.h>
804	#endif
805
806	#define TEST_EXPECT_MASK_NONPRINTABLE(i,o) do { \
807	char *masked = strdup(i); \
808	NDS_mask_nonprintable_chars(masked); \
809	TEST_EXPECT_EQUAL(masked,o); \
810	free(masked); \
811	} while (0)
812
813	void TEST_mask_nds() {
814	TEST_EXPECT_MASK_NONPRINTABLE("plain text", "plain text");
815	TEST_EXPECT_MASK_NONPRINTABLE("with\nLF", "with#LF");
816	TEST_EXPECT_MASK_NONPRINTABLE("with\rLF", "with#LF");
817	TEST_EXPECT_MASK_NONPRINTABLE("with\r\nLF", "with##LF");
818	TEST_EXPECT_MASK_NONPRINTABLE("tab\tseparated", "tab separated");
819	TEST_EXPECT_MASK_NONPRINTABLE("\t\n\t\n", " # #");
820	}
821
822	#define TEST_EXPECT_NDS_EQUALS(specName,format,expected_NDS) do { \
823	GBDATA *gb_species = GBT_find_species(gb_main, specName); \
824	TEST_REJECT_NULL(gb_species); \
825	\
826	const char *nds = make_node_text_nds(gb_main, gb_species, format, NULL, NULL); \
827	TEST_EXPECT_EQUAL(nds, expected_NDS); \
828	} while(0)
829
830	#define TEST_EXPECT_NDS_EQUALS__BROKEN(specName,format,expected_NDS) do { \
831	GBDATA *gb_species = GBT_find_species(gb_main, specName); \
832	TEST_REJECT_NULL(gb_species); \
833	\
834	const char *nds = make_node_text_nds(gb_main, gb_species, format, NULL, NULL); \
835	TEST_EXPECT_EQUAL__BROKEN(nds, expected_NDS); \
836	} while(0)
837
838	void TEST_nds() {
839	GB_shell shell;
840	const char *testDB = "display/nds.arb"; // NDS definitions are in ../../UNIT_TESTER/run/display/nds.arb@arb_presets
841	GBDATA *gb_main = GB_open(testDB, "r");
842
843	TEST_REJECT_NULL(gb_main);
844
845	{
846	GB_transaction ta(gb_main);
847	make_node_text_init(gb_main);
848
849	TEST_EXPECT_NDS_EQUALS("MycChlor", NDS_OUTPUT_LEAFTEXT, "'MycChlor', Mycobacterium #phenolicus, acc=X79094");
850	TEST_EXPECT_NDS_EQUALS("MycChlor", NDS_OUTPUT_SPACE_PADDED, " 'MycChlor' Mycobacterium #phenolicus acc=X79094 ");
851	TEST_EXPECT_NDS_EQUALS("MycChlor", NDS_OUTPUT_TAB_SEPARATED, "'MycChlor'\tMycobacterium #phenolicus\tacc=X79094");
852	TEST_EXPECT_NDS_EQUALS("MycChlor", NDS_OUTPUT_COMMA_SEPARATED, "'MycChlor',Mycobacterium #phenolicus,acc=X79094");
853
854	TEST_EXPECT_NDS_EQUALS("ActUtahe", NDS_OUTPUT_LEAFTEXT, "'ActUtahe', Act;ino planes uta,hen.sis#, acc=X80823");
855	TEST_EXPECT_NDS_EQUALS("ActUtahe", NDS_OUTPUT_SPACE_PADDED, " 'ActUtahe' Act;ino planes uta,hen.sis# acc=X80823 ");
856	TEST_EXPECT_NDS_EQUALS("ActUtahe", NDS_OUTPUT_TAB_SEPARATED, "'ActUtahe'\tAct;ino planes uta,hen.sis#\tacc=X80823");
857	TEST_EXPECT_NDS_EQUALS("ActUtahe", NDS_OUTPUT_COMMA_SEPARATED, "'ActUtahe',\"Act;ino planes uta,hen.sis#\",acc=X80823"); // quote 2nd value (cause it contains a comma)
858
859	TEST_EXPECT_NDS_EQUALS("StpGrise", NDS_OUTPUT_LEAFTEXT, "'StpGrise', Strepto s griseus, acc=M76388 X55435 X6"); // acc truncated!
860	TEST_EXPECT_NDS_EQUALS("StpGrise", NDS_OUTPUT_SPACE_PADDED, " 'StpGrise' Strepto s griseus acc=M76388 X55435 X6");
861	TEST_EXPECT_NDS_EQUALS("StpGrise", NDS_OUTPUT_TAB_SEPARATED, "'StpGrise'\tStrepto s griseus\tacc=M76388 X55435 X61478"); // acc not truncated here
862	TEST_EXPECT_NDS_EQUALS("StpGrise", NDS_OUTPUT_COMMA_SEPARATED, "'StpGrise',Strepto s griseus,acc=M76388 X55435 X61478");
863	}
864
865	GB_close(gb_main);
866	}
867
868	#endif // UNIT_TESTS
869
870	// --------------------------------------------------------------------------------

Note: See TracBrowser for help on using the repository browser.

Download in other formats: