Changeset 7097

branches/refactor/ARBDB/Makefile

r7089	r7097
287	287	adcolumns.o: $(ARBHOME)/INCLUDE/arb_error.h
288	288	adcolumns.o: $(ARBHOME)/INCLUDE/arb_msg.h
	289	adcolumns.o: $(ARBHOME)/INCLUDE/arb_progress.h
289	290	adcolumns.o: $(ARBHOME)/INCLUDE/arb_string.h
290	291	adcolumns.o: $(ARBHOME)/INCLUDE/arbtools.h
…	…
511	512	adlang1.o: $(ARBHOME)/INCLUDE/arb_error.h
512	513	adlang1.o: $(ARBHOME)/INCLUDE/arb_msg.h
	514	adlang1.o: $(ARBHOME)/INCLUDE/arb_str.h
513	515	adlang1.o: $(ARBHOME)/INCLUDE/arb_string.h
514	516	adlang1.o: $(ARBHOME)/INCLUDE/arbtools.h
…	…
631	633	adname.o: $(ARBHOME)/INCLUDE/arb_error.h
632	634	adname.o: $(ARBHOME)/INCLUDE/arb_msg.h
	635	adname.o: $(ARBHOME)/INCLUDE/arb_progress.h
633	636	adname.o: $(ARBHOME)/INCLUDE/arb_string.h
634	637	adname.o: $(ARBHOME)/INCLUDE/arbtools.h
…	…
658	661	adoptimize.o: $(ARBHOME)/INCLUDE/arb_error.h
659	662	adoptimize.o: $(ARBHOME)/INCLUDE/arb_msg.h
	663	adoptimize.o: $(ARBHOME)/INCLUDE/arb_progress.h
660	664	adoptimize.o: $(ARBHOME)/INCLUDE/arb_string.h
661	665	adoptimize.o: $(ARBHOME)/INCLUDE/arbtools.h
…	…
741	745	adseqcompr.o: $(ARBHOME)/INCLUDE/arb_error.h
742	746	adseqcompr.o: $(ARBHOME)/INCLUDE/arb_msg.h
	747	adseqcompr.o: $(ARBHOME)/INCLUDE/arb_progress.h
743	748	adseqcompr.o: $(ARBHOME)/INCLUDE/arb_string.h
744	749	adseqcompr.o: $(ARBHOME)/INCLUDE/arbtools.h
…	…
934	939	adtree.o: $(ARBHOME)/INCLUDE/arb_error.h
935	940	adtree.o: $(ARBHOME)/INCLUDE/arb_msg.h
	941	adtree.o: $(ARBHOME)/INCLUDE/arb_progress.h
936	942	adtree.o: $(ARBHOME)/INCLUDE/arb_string.h
937	943	adtree.o: $(ARBHOME)/INCLUDE/arbtools.h

branches/refactor/ARBDB/ad_t_prot.h

r7084	r7097
79	79	GB_ERROR GBT_rename_species(const char oldname, const char newname, bool ignore_protection);
80	80	GB_ERROR GBT_abort_rename_session(void);
81		GB_ERROR GBT_commit_rename_session(~~int (show_status)(double gauge), int (show_status_text)(const char *)~~) __ATTR__USERESULT;
	81	GB_ERROR GBT_commit_rename_session(void) __ATTR__USERESULT;
82	82
83	83	/* adseqcompr.cxx */
…	…
123	123	void GBT_names_move(char **names, int old_index, int new_index);
124	124	void GBT_free_names(char **names);
	125	size_t GBT_count_names(const char **names);
125	126	char GBT_read_string(GBDATA gb_container, const char *fieldpath);
126	127	char GBT_read_as_string(GBDATA gb_container, const char *fieldpath);
…	…
169	170	char *GBT_get_tree_names(GBDATA Main);
170	171	char GBT_get_name_of_next_tree(GBDATA gb_main, const char *tree_name);
171		GB_CSTR GBT_get_names_of_species_in_tree(const GBT_TREE tree);
	172	GB_CSTR GBT_get_names_of_species_in_tree(const GBT_TREE tree, size_t *count);
172	173	char GBT_existing_tree(GBDATA gb_main, const char *tree_name);
173	174
174	175	/* adali.cxx */
	176	int GBT_count_alignments(GBDATA *gb_main);
175	177	GB_ERROR GBT_check_data(GBDATA Main, const char alignment_name);
176	178	char *GBT_get_alignment_names(GBDATA gbd);

branches/refactor/ARBDB/adali.cxx

r7084	r7097
29	29	#endif // DEVEL_RALF
30	30
	31	int GBT_count_alignments(GBDATA *gb_main) {
	32	int count = 0;
	33	GBDATA *gb_presets = GBT_find_or_create(gb_main, "presets", 7);
	34	for (GBDATA *gb_ali = GB_entry(gb_presets, "alignment");
	35	gb_ali;
	36	gb_ali = GB_nextEntry(gb_ali))
	37	{
	38	++count;
	39	}
	40	return count;
	41	}
31	42
32	43	GB_ERROR GBT_check_data(GBDATA Main, const char alignment_name) {

branches/refactor/ARBDB/adcolumns.cxx

r6656	r7097
11	11	#include <arbdbt.h>
12	12	#include <adGene.h>
	13	#include <arb_progress.h>
13	14
14	15	#include "gb_local.h"
…	…
273	274
274	275	static GB_ERROR gbt_insert_character(GBDATA gb_item_data, const char item_field, enum insDelTarget item_type, const insDel_params *params) {
275		GBDATA *gb_item;
276		GB_ERROR error = 0;
277		long item_count = GB_number_of_subentries(gb_item_data);
278		~~long count = 0~~;
	276	GBDATA *gb_item;
	277	GB_ERROR error = 0;
	278	long item_count = GB_number_of_subentries(gb_item_data);
	279	arb_progress progress(item_field, item_count);
279	280
280	281	for (gb_item = GB_entry(gb_item_data, item_field);
…	…
283	284	{
284	285	error = gbt_insert_character_item(gb_item, item_type, params);
285		count++;
286		GB_status((double)count/item_count);
	286	progress.inc_and_check_user_abort(error);
287	287	}
288	288	return error;
…	…
292	292	GB_ERROR error = 0;
293	293	GBDATA *gb_ali = GB_entry(gb_secstructs, params->ali_name);
	294
294	295	if (gb_ali) {
295		long item_count = GB_number_of_subentries(gb_ali)-1;
296		long count = 0;
	296	long item_count = GB_number_of_subentries(gb_ali)-1;
	297
	298	if (item_count<1) item_count = 1;
	299	arb_progress progress("secstructs", item_count);
	300
297	301	GBDATA *gb_item;
298
299		~~if (item_count<1) item_count = 1;~~
300
301	302	for (gb_item = GB_entry(gb_ali, "struct");
302	303	gb_item && !error;
…	…
311	312	}
312	313	}
313		count++;
314		GB_status((double)count/item_count);
	314	progress.inc_and_check_user_abort(error);
315	315	}
316	316	}
…	…
335	335
336	336	if (gb_name) {
	337	arb_progress progress(3); // SAI, species and secstructs
337	338	GBDATA *gb_len = GB_entry(gb_ali, "alignment_len");
338	339

branches/refactor/ARBDB/adlang1.cxx

r6806	r7097
20	20	#include <static_assert.h>
21	21	#include <arb_defs.h>
	22	#include <arb_str.h>
22	23
23	24	#define AWAR_TREE_REFRESH "tmp/focus/tree_refresh" // touch this awar to refresh the tree display
…	…
689	690	if (args->cparam>=2) return "len syntax: len[(\"characters not to count\")]";
690	691
691		for (i=0; i<256; i++) {
692		if (strchr(option, i)) tab[i] = 0;
693		else tab[i] = 1;
694		}
	692	for (i = 0; i<256; ++i) tab[i] = 1;
	693	for (i = 0; option[i]; ++i) tab[safeCharIndex(option[i])] = 0;
	694
695	695	GBL_CHECK_FREE_PARAM(*args->coutput, args->cinput);
696	696	for (i=0; i<args->cinput; i++) { // go through all orig streams
…	…
699	699	p = args->vinput[i].str;
700	700	while (*p) {
701		sum += tab[~~(unsigned int)*(p++~~)];
	701	sum += tab[safeCharIndex(*(p++))];
702	702	}
703	703	PASS_2_OUT(args, GBS_global_string_copy("%li", sum));

branches/refactor/ARBDB/adname.cxx

r6871	r7097
12	12
13	13	#include <arbdbt.h>
	14	#include <arb_progress.h>
14	15	#include <ad_config.h>
15	16
…	…
158	159	}
159	160
160		GB_ERROR GBT_commit_rename_session(int (show_status)(double gauge), int (show_status_text)(const char *)) {
161		// goes to header: __ATTR__USERESULT
	161	GB_ERROR GBT_commit_rename_session() { // goes to header: __ATTR__USERESULT
	162	arb_progress commit_progress("Renaming name references", 3);
	163	commit_progress.allow_title_reuse();
	164
162	165	GB_ERROR error = 0;
163	166
…	…
171	174	gb_assert(tree_count); // otherwise tree_names should be zero
172	175
173		~~if (show_status_text) show_status_text(GBS_global_string("Renaming species in %i tree%c", tree_count, "s"[tree_count<2]));~~
174		~~if (show_status) show_status(0.0~~);
175
176		for (count = 0; count<tree_count; ++count) {
	176	arb_progress progress(GBS_global_string("Renaming species in %i tree%c", tree_count, "s"[tree_count<2]),
	177	tree_count*3);
	178
	179	for (count = 0; count<tree_count && !error; ++count) {
177	180	char *tname = tree_names[count];
178	181	GBT_TREE *tree = GBT_read_tree(NameSession.gb_main, tname, -sizeof(GBT_TREE));
	182	++progress;
179	183
180	184	if (tree) {
…	…
183	187	currentTreeName = 0;
184	188
	189	++progress;
	190
185	191	GBT_write_tree(NameSession.gb_main, 0, tname, tree);
186	192	GBT_delete_tree(tree);
187		}
188		if (show_status) show_status((double)(count+1)/tree_count);
	193
	194	progress.inc_and_check_user_abort(error);
	195	}
	196	else {
	197	++progress;
	198	++progress;
	199	}
189	200	}
190	201	GBT_free_names(tree_names);
191	202	}
	203	commit_progress.inc_and_check_user_abort(error);
192	204	}
193	205	// rename configurations
…	…
200	212	gb_assert(config_count); // otherwise config_names should be zero
201	213
202		if (show_status_text) show_status_text(GBS_global_string("Renaming species in %i config%c", config_count, "s"[config_count<2]));
203		if (show_status) show_status(0.0);
	214	arb_progress progress(GBS_global_string("Renaming species in %i config%c", config_count, "s"[config_count<2]), config_count);
204	215
205	216	for (count = 0; !error && count<config_count; ++count) {
…	…
241	252	}
242	253	}
243		~~if (show_status) show_status((double)(count+1)/config_count~~);
	254	progress.inc_and_check_user_abort(error);
244	255	}
245	256	GBT_free_names(config_names);
246	257	}
247	258	}
	259	commit_progress.inc_and_check_user_abort(error);
248	260
249	261	// rename links in pseudo-species
…	…
265	277	}
266	278	}
	279	commit_progress.inc_and_check_user_abort(error);
267	280
268	281	gbt_free_rename_session_data();

branches/refactor/ARBDB/adoptimize.cxx

r6661	r7097
16	16	#include "gb_compress.h"
17	17	#include "gb_dict.h"
	18	#include "arb_progress.h"
18	19
19	20	#if defined(DEBUG)
…	…
2428	2429	#else
2429	2430	// create dictionaries for all indices (this is the normal operation)
2430		for (idx = gbdByKey_cnt-1; idx >= 1 && !error; --idx)
	2431	arb_progress progress("Optimizing key data", gbdByKey_cnt);
	2432	for (idx = gbdByKey_cnt-1; idx >= 1 && !error; --idx, progress.inc_and_check_user_abort(error))
2431	2433	#endif
2432	2434
…	…
2446	2448
2447	2449	#ifndef TEST_ONE
2448		~~GB_status(idx/(double)gbdByKey_cnt);~~
2449	2450	if (!gbk[idx].cnt) continue; // there are no entries with this quark
2450	2451

branches/refactor/ARBDB/adseqcompr.cxx

r6659	r7097
10	10
11	11	#include <arbdbt.h>
	12	#include <arb_progress.h>
12	13
13	14	#include "gb_key.h"
…	…
169	170	}
170	171
171		void g_b_create_master(CompressionTree node, Sequence seqs, MasterSequence **masters,
172		int masterCount, int *builtMasters, int my_master,
173		const char ali_name, long seq_len, int aborted)
174		{
175		if (*aborted) {
176		return;
177		}
178
	172	void g_b_create_master(CompressionTree node, Sequence seqs, MasterSequence *masters, int my_master, const char ali_name, long seq_len, arb_progress& progress) {
179	173	if (node->is_leaf) {
180	174	if (node->index >= 0) {
…	…
186	180	}
187	181	else {
	182	if (progress.aborted()) return;
	183
188	184	if (node->index>=0) {
189	185	masters[node->index]->master = my_master;
190	186	my_master = node->index;
191	187	}
192		g_b_create_master(node->leftson, seqs, masters, m~~asterCount, builtMasters, my_master, ali_name, seq_len, aborted~~);
193		g_b_create_master(node->rightson, seqs, masters, m~~asterCount, builtMasters, my_master, ali_name, seq_len, aborted~~);
194		if (node->index>=0 && !*aborted) { // build me
	188	g_b_create_master(node->leftson, seqs, masters, my_master, ali_name, seq_len, progress);
	189	g_b_create_master(node->rightson, seqs, masters, my_master, ali_name, seq_len, progress);
	190	if (node->index>=0 && !progress.aborted()) { // build me
195	191	char *data;
196	192	Consensus *gcon = g_b_new_Consensus(seq_len);
…	…
207	203	free(data);
208	204
209		(*builtMasters)++;
210		aborted \|= GB_status(builtMasters/(double)masterCount);
	205	++progress;
211	206	}
212	207	}
…	…
433	428	}
434	429	else {
	430	arb_progress tree_progress("Compressing sequences", 4);
	431
435	432	// Distribute masters in tree
436	433	int mastercount = 0;
437	434	int max_compSteps = 0; // in one branch
438	435	int seqcount = 0;
439
440		~~GB_status("Create master sequences");~~
441		~~GB_status(0.0);~~
442	436
443	437	init_indices_and_count_sons(tree, &seqcount, ali_name);
…	…
527	521	}
528	522	seqs = (Sequence )GB_calloc(sizeof(seqs), leafcount);
529		{
530		int builtMasters = 0;
531		int aborted = 0;
532		GB_status(GBS_global_string("Building %i master sequences", mastercount));
533		g_b_create_master(tree, seqs, masters, mastercount, &builtMasters, -1, ali_name, ali_len, &aborted);
534		if (aborted) error = "User abort";
535		}
536		}
	523
	524	if (!error) {
	525	arb_progress progress("Building master sequences", mastercount);
	526	g_b_create_master(tree, seqs, masters, -1, ali_name, ali_len, progress);
	527
	528	error = progress.error_if_aborted();
	529	}
	530	}
	531	tree_progress.inc_and_check_user_abort(error);
537	532
538	533	// Compress sequences in tree
539	534	if (!error) {
540		GB_status(GBS_global_string("Compressing %i sequences in tree", seqcount));
541		GB_status(0.0);
542
543		for (si=0; si<seqcount; si++) {
	535	arb_progress progress("Compressing sequences in tree", seqcount);
	536
	537	for (si=0; si<seqcount && !error; si++) {
544	538	int mi = seqs[si].master;
545	539	MasterSequence *master = masters[mi];
…	…
569	563	}
570	564
571		if (GB_status((si+1)/(double)seqcount)) {
572		error = "User abort";
573		break;
574		}
575		}
576		}
	565	progress.inc_and_check_user_abort(error);
	566	}
	567	}
	568	tree_progress.inc_and_check_user_abort(error);
577	569
578	570	// Compress rest of sequences
…	…
581	573	int speciesNotInTree = 0;
582	574
583		GB_status("Compressing sequences NOT in tree");
584		GB_status(0.0);
	575	SmartPtr<arb_progress> progress;
585	576
586	577	for (pass = 1; pass <= 2; ++pass) {
…	…
613	604	sumorg += seq_len;
614	605
615		if (GB_status(count/(double)speciesNotInTree)) {
616		error = "User abort";
617		break;
618		}
	606	progress->inc_and_check_user_abort(error);
619	607	}
620	608	}
621	609	if (pass == 1) {
622	610	speciesNotInTree = count;
623		if (GB_status(GBS_global_string("Compressing %i sequences NOT in tree", speciesNotInTree))) {
624		error = "User abort";
625		break;
626		}
	611	progress = new arb_progress("Compressing sequences NOT in tree", speciesNotInTree);
627	612	}
628	613	}
629	614	}
	615	tree_progress.inc_and_check_user_abort(error);
630	616
631	617	if (!error) {
632		GB_status(GBS_global_string("Compressing %i master-sequences", mastercount));
633		GB_status(0.0);
	618	arb_progress progress("Compressing master-sequences", mastercount);
634	619
635	620	// Compress all masters
…	…
664	649	}
665	650
666		if (GB_status((si+1)/(double)mastercount)) {
667		error = "User abort";
668		break;
669		}
	651	progress.inc_and_check_user_abort(error);
670	652	}
671	653	else { // count size of top master
…	…
705	687	}
706	688	}
707
	689	tree_progress.inc_and_check_user_abort(error);
708	690
709	691	if (!error) {

branches/refactor/ARBDB/adtools.cxx

r6808	r7097
438	438	}
439	439
	440	size_t GBT_count_names(const char **names) {
	441	size_t count = 0;
	442	if (names) while (names[count]) ++count;
	443	return count;
	444	}
	445
440	446
441	447	char GBT_read_string(GBDATA gb_container, const char *fieldpath) {

branches/refactor/ARBDB/adtree.cxx

r7090	r7097
10	10
11	11	#include <arbdbt.h>
	12	#include <arb_progress.h>
12	13	#include "gb_local.h"
13	14
…	…
582	583
583	584	struct link_tree_data {
584		GB_HASH *species_hash;
585		GB_HASH *seen_species; // used to count duplicates
586		int nodes; // if != 0 -> update status
587		int counter;
588		int zombies; // counts zombies
589		int duplicates; // counts duplicates
	585	GB_HASH *species_hash;
	586	GB_HASH *seen_species; // used to count duplicates
	587	arb_progress *progress;
	588	int zombies; // counts zombies
	589	int duplicates; // counts duplicates
590	590	};
591	591
…	…
593	593	GB_ERROR error = 0;
594	594	if (tree->is_leaf) {
595		~~if (ltd->nodes) { // update status?~~
596		~~ltd->counter++;~~
597		~~GB_status(ltd->counter/(double)ltd->nodes);~~
598		}
599
600	595	tree->gb_node = 0;
601	596	if (tree->name) {
…	…
609	604	}
610	605	}
	606
	607	if (ltd->progress) ++(*ltd->progress);
611	608	}
612	609	else {
…	…
630	627	ltd.zombies = 0;
631	628	ltd.duplicates = 0;
632		~~ltd.counter = 0;~~
633	629
634	630	if (show_status) {
635		GB_status("Relinking tree to database");
636		ltd.nodes = leafs;
637		}
638		else {
639		ltd.nodes = 0;
	631	ltd.progress = new arb_progress("Relinking tree to database", leafs);
	632	}
	633	else {
	634	ltd.progress = NULL;
640	635	}
641	636
…	…
643	638	if (ltd.seen_species) GBS_free_hash(ltd.seen_species);
644	639
645		if (zombies) *zombies = ltd.zombies;
	640	if (zombies) *zombies = ltd.zombies;
646	641	if (duplicates) *duplicates = ltd.duplicates;
	642
	643	delete ltd.progress;
647	644
648	645	return error;
…	…
852	849	}
853	850
854		GB_CSTR GBT_get_names_of_species_in_tree(const GBT_TREE tree) {
	851	GB_CSTR GBT_get_names_of_species_in_tree(const GBT_TREE tree, size_t *count) {
855	852	/* creates an array of all species names in a tree,
856	853	* The names are not allocated (so they may change as side effect of renaming species) */
857	854
858		size_t ~~size~~ = GBT_count_leafs(tree);
	855	size_t size = GBT_count_leafs(tree);
859	856	GB_CSTR result = (GB_CSTR )GB_calloc(sizeof(char *), size + 1);
	857
860	858	IF_ASSERTION_USED(GB_CSTR *check =) fill_species_name_array(result, tree);
861	859	gb_assert(check - size == result);
	860
	861	if (count) *count = size;
	862
862	863	return result;
863	864	}

branches/refactor/ARB_GDE/GDE_arbdb_io.cxx

r6920	r7097
3	3
4	4	#include <aw_msg.hxx>
5		#include <a~~w_status.hxx~~>
	5	#include <arb_progress.h>
6	6	#include <AW_rename.hxx>
7	7	#include <AP_filter.hxx>
…	…
194	194	int bad_names = 0;
195	195
	196	arb_progress progress("Read data from DB", numberspecies);
	197	GB_ERROR error = 0;
196	198	if (the_species) {
197		for (gb_species = the_species[number]; gb_species; gb_species = the_species[++number]) {
198		if ((number/10)*10==number) {
199		if (aw_status((double)number/(double)numberspecies)) {
200		return 1;
201		}
202		}
	199	for (gb_species = the_species[number]; gb_species && !error; gb_species = the_species[++number]) {
203	200	gb_name = GB_entry(gb_species, "name");
204	201
…	…
235	232	this_elem->col_lut = Default_PROColor_LKUP;
236	233	}
	234	progress.inc_and_check_user_abort(error);
237	235	}
238	236	}
…	…
240	238	unsigned char *species_name;
241	239
242		for (species_name=the_names[number]; species_name; species_name=the_names[++number]) {
243		if ((number/10)*10==number) {
244		if (aw_status((double)number/(double)numberspecies)) {
245		return 1;
246		}
247		}
248
	240	for (species_name=the_names[number]; species_name && !error; species_name=the_names[++number]) {
249	241	curelem = Arbdb_get_curelem(dataset);
250	242	this_elem = &(dataset->element[curelem]);
…	…
274	266	this_elem->col_lut = Default_PROColor_LKUP;
275	267	}
276		}
277		}
278
279		if (bad_names) {
280		aw_message(GBS_global_string("Problematic names found: %i\n"
281		"External program call may fail or produce invalid results.\n"
282		"You might want to use 'Generate new names' and read the associated help.",
283		bad_names));
284		}
285
286		{
287		unsigned long i;
288		for (i=0; i<dataset->numelements; i++) {
289		dataset->maxlen = MAX(dataset->maxlen,
290		dataset->element[i].seqlen+dataset->element[i].offset);
291		}
292		for (i=0; i<numberspecies; i++)
	268	progress.inc_and_check_user_abort(error);
	269	}
	270	}
	271
	272	if (!error) {
	273	if (bad_names) {
	274	aw_message(GBS_global_string("Problematic names found: %i\n"
	275	"External program call may fail or produce invalid results.\n"
	276	"You might want to use 'Generate new names' and read the associated help.",
	277	bad_names));
	278	}
	279
293	280	{
294		delete sequfilt[i];
295		}
296		free(sequfilt);
297		}
	281	unsigned long i;
	282	for (i=0; i<dataset->numelements; i++) {
	283	dataset->maxlen = MAX(dataset->maxlen,
	284	dataset->element[i].seqlen+dataset->element[i].offset);
	285	}
	286	for (i=0; i<numberspecies; i++)
	287	{
	288	delete sequfilt[i];
	289	}
	290	free(sequfilt);
	291	}
	292	}
	293
298	294	delete allocatedFilter;
	295	if (error) {
	296	aw_message(error);
	297	return 1; // = aborted
	298	}
299	299	return 0;
	300
300	301	}
301	302

branches/refactor/ARB_GDE/GDE_event.cxx

r6861	r7097
7	7	#include <aw_awar.hxx>
8	8	#include <aw_msg.hxx>
9		#include <a~~w_status.hxx~~>
	9	#include <arb_progress.h>
10	10	#include <AP_filter.hxx>
11	11
…	…
275	275	} change_mode = ACCEPT_CHANGE;
276	276
	277	arb_progress progress("importing", dataset->numelements-oldnumelements);
277	278	for (i = oldnumelements; !error && i < dataset->numelements; i++) {
278	279	NA_Sequence *sequ = dataset->element+i;
…	…
413	414	}
414	415	free(savename);
	416	progress.inc_and_check_user_abort(error);
415	417	}
416	418
…	…
483	485	bool marked = (aw_root->awar(AWAR_GDE_SPECIES)->read_int() != 0);
484	486	long cutoff_stop_codon = aw_root->awar(AWAR_GDE_CUTOFF_STOPCODON)->read_int();
485
486		GmenuItem *current_item;
487		current_item=gmenuitem;
488
489		aw_openstatus(current_item->label);
490		aw_status((double)0);
	487	GmenuItem *current_item = gmenuitem;
	488	arb_progress progress(current_item->label);
491	489
492	490	int j;
…	…
504	502	freedup(alignment_name, DataSet->alignment_name);
505	503
506		~~aw_status~~("reading database");
	504	progress.subtitle("reading database");
507	505	if (db_access.get_sequences) {
508	506	stop = ReadArbdb2(DataSet, filter2, compress, cutoff_stop_codon);
…	…
572	570
573	571	// call and go...
574		~~aw_status~~("calling external program");
	572	progress.subtitle("calling external program");
575	573	printf("Action: %s\n", Action);
576	574	system(Action);
…	…
625	623	}
626	624
627		~~aw_closestatus();~~
628	625	GDE_export(DataSet, alignment_name, oldnumelements);
629		}
630		~~else {~~
631		~~aw_closestatus();~~
632	626	}
633	627

branches/refactor/ARB_GDE/Makefile

r7089	r7097
89	89	GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/arb_error.h
90	90	GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/arb_msg.h
	91	GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/arb_progress.h
91	92	GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/arb_string.h
92	93	GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
100	101	GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
101	102	GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/AW_rename.hxx
102		~~GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
103	103	GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/cb.h
104	104	GDE_arbdb_io.o: $(ARBHOME)/INCLUDE/dupstr.h
…	…
119	119	GDE_event.o: $(ARBHOME)/INCLUDE/arb_error.h
120	120	GDE_event.o: $(ARBHOME)/INCLUDE/arb_msg.h
	121	GDE_event.o: $(ARBHOME)/INCLUDE/arb_progress.h
121	122	GDE_event.o: $(ARBHOME)/INCLUDE/arb_string.h
122	123	GDE_event.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
130	131	GDE_event.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
131	132	GDE_event.o: $(ARBHOME)/INCLUDE/aw_root.hxx
132		~~GDE_event.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
133	133	GDE_event.o: $(ARBHOME)/INCLUDE/aw_window.hxx
134	134	GDE_event.o: $(ARBHOME)/INCLUDE/awt_filter.hxx

branches/refactor/AWT/AWT_canio.cxx

r6858	r7097
14	14	#include <aw_awar.hxx>
15	15	#include <aw_msg.hxx>
16		#include <a~~w_status.hxx~~>
	16	#include <arb_progress.h>
17	17	#include <aw_root.hxx>
18	18	#include <arbdbt.h>
…	…
411	411	}
412	412
413		a~~w_openstatu~~s("Printing");
	413	arb_progress progress("Printing");
414	414
415	415	if (!xfig) error = GB_await_error();
…	…
418	418	ntw->init_device(device); // draw screen
419	419
420		~~aw_status~~("Get Picture Size");
	420	progress.subtitle("Get Picture Size");
421	421	device->reset();
422	422
…	…
450	450
451	451	// ----------------------------------------
452		~~aw_status~~("Exporting Data");
	452	progress.subtitle("Exporting Data");
453	453
454	454	device->set_filter(awr->awar(AWAR_PRINT_TREE_HANDLES)->read_int()
…	…
462	462
463	463	// ----------------------------------------
464		~~aw_status~~("Converting to Postscript");
	464	progress.subtitle("Converting to Postscript");
465	465
466	466	{
…	…
484	484
485	485	if (!error) {
486		~~aw_status~~("Printing");
	486	progress.subtitle("Printing");
487	487
488	488	switch (printdest) {
…	…
506	506	}
507	507	}
508		~~aw_closestatus();~~
509	508	if (xfig) {
510	509	GB_unlink_or_warn(xfig, &error);

branches/refactor/AWT/AWT_query_and_functions.cxx

r7059	r7097
19	19	#include <aw_msg.hxx>
20	20	#include <aw_awars.hxx>
21		#include <a~~w_status.hxx~~>
	21	#include <arb_progress.h>
22	22	#include <aw_root.hxx>
23	23
…	…
116	116	#endif // DEVEL_RALF
117	117
118		static int awt_count_items(DbQuery *cbs, AWT_QUERY_RANGE range) {
	118	static int awt_count_items(DbQuery *cbs, AWT_QUERY_RANGE range, AWT_QUERY_MODES mode) {
119	119	int count = 0;
120	120	GBDATA *gb_main = cbs->gb_main;
…	…
130	130	gb_item = selector->get_next_item(gb_item))
131	131	{
132		count++;
	132	switch (mode) {
	133	case AWT_QUERY_GENERATE: ++count; break;
	134	case AWT_QUERY_ENLARGE: count += !IS_QUERIED(gb_item, cbs); break;
	135	case AWT_QUERY_REDUCE: count += IS_QUERIED(gb_item, cbs); break;
	136	}
133	137	}
134	138	}
…	…
998	1002
999	1003	if (!error) {
1000		size_t item_count = awt_count_items(cbs, range);
1001		size_t searched_count = 0;
1002
1003		aw_openstatus("Searching");
1004		aw_status(0.0);
	1004	size_t item_count = awt_count_items(cbs, range, mode);
	1005	arb_progress progress("Searching", item_count);
1005	1006
1006	1007	if (cbs->gb_ref && // merge tool only
…	…
1079	1080	}
1080	1081
1081		~~if (aw_status(searched_count++/double(item_count))) error = "aborted"~~;
	1082	progress.inc_and_check_user_abort(error);
1082	1083	}
1083	1084	}
…	…
1252	1253	else CLEAR_QUERIED(gb_item, cbs);
1253	1254
1254		if (aw_status(searched_count++/double(item_count))) error = "aborted";
1255		}
1256		}
1257		}
1258
1259		aw_closestatus();
	1255	progress.inc_and_check_user_abort(error);
	1256	}
	1257	}
	1258	}
1260	1259	}
1261	1260
…	…
1561	1560
1562	1561	if (!error) {
1563		~~long count = 0;~~
1564	1562	long ncount = cbs->aws->get_root()->awar(cbs->awar_count)->read_int();
1565	1563	char *deftag = cbs->aws->get_root()->awar(cbs->awar_deftag)->read_string();
…	…
1574	1572	int double_pars = cbs->aws->get_root()->awar(cbs->awar_double_pars)->read_int();
1575	1573
1576		aw_openstatus("Pars Fields");
1577
	1574	arb_progress progress("Parse fields", ncount);
1578	1575	AW_root *aw_root = cbs->aws->get_root();
1579	1576	AWT_QUERY_RANGE range = (AWT_QUERY_RANGE)aw_root->awar(cbs->awar_where)->read_int();
…	…
1588	1585	{
1589	1586	if (IS_QUERIED(gb_item, cbs)) {
1590		~~if (aw_status((count++)/(double)ncount)) {~~
1591		~~error = "Aborted by user";~~
1592		~~break;~~
1593		}
1594	1587	GBDATA *gb_new = GB_search(gb_item, key, GB_FIND);
1595	1588	char *str = gb_new ? GB_read_as_string(gb_new) : strdup("");
…	…
1626	1619	}
1627	1620	free(str);
	1621	progress.inc_and_check_user_abort(error);
1628	1622	}
1629	1623	}
1630	1624	}
1631	1625
1632
1633		~~aw_closestatus();~~
1634	1626	delete tag;
1635	1627	free(deftag);
…	…
2586	2578	cbs->tree_name = awtqs->tree_name ? aw_root->awar(awtqs->tree_name)->read_string() : 0;
2587	2579	cbs->selector = awtqs->selector;
2588		cbs->hit_description = GBS_create_hash(awt_count_items(cbs, AWT_QUERY_ALL_SPECIES), GB_IGNORE_CASE);
	2580	cbs->hit_description = GBS_create_hash(awt_count_items(cbs, AWT_QUERY_ALL_SPECIES, AWT_QUERY_GENERATE), GB_IGNORE_CASE);
2589	2581
2590	2582	GB_push_transaction(gb_main);

branches/refactor/AWT/Makefile

r7089	r7097
97	97	AWT_canio.o: $(ARBHOME)/INCLUDE/arb_error.h
98	98	AWT_canio.o: $(ARBHOME)/INCLUDE/arb_msg.h
	99	AWT_canio.o: $(ARBHOME)/INCLUDE/arb_progress.h
99	100	AWT_canio.o: $(ARBHOME)/INCLUDE/arb_string.h
100	101	AWT_canio.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
111	112	AWT_canio.o: $(ARBHOME)/INCLUDE/aw_position.hxx
112	113	AWT_canio.o: $(ARBHOME)/INCLUDE/aw_root.hxx
113		~~AWT_canio.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
114	114	AWT_canio.o: $(ARBHOME)/INCLUDE/aw_window.hxx
115	115	AWT_canio.o: $(ARBHOME)/INCLUDE/cb.h
…	…
360	360	AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/arb_error.h
361	361	AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/arb_msg.h
	362	AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/arb_progress.h
362	363	AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/arb_string.h
363	364	AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
376	377	AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/aw_root.hxx
377	378	AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/aw_select.hxx
378		~~AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
379	379	AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/aw_window.hxx
380	380	AWT_query_and_functions.o: $(ARBHOME)/INCLUDE/cb.h

branches/refactor/AWTI/AWTI_export.cxx

r7058	r7097
18	18	#include <aw_window.hxx>
19	19	#include <aw_msg.hxx>
20		#include <a~~w_status.hxx~~>
	20	#include <arb_progress.h>
21	21	#include <aw_root.hxx>
22	22	#include <arbdbt.h>
…	…
40	40	adfiltercbstruct acbs = (adfiltercbstruct)res_from_awt_create_select_filter;
41	41
42		a~~w_openstatu~~s("Exporting data");
	42	arb_progress progress("Exporting data");
43	43
44	44	AW_root *awr = aww->get_root();
…	…
59	59	db_name, formname, outname, multiple, &real_outname);
60	60	free(db_name);
61		~~aw_closestatus();~~
62	61	if (error) aw_message(error);
63	62

branches/refactor/AWTI/AWTI_import.cxx

r7059	r7097
19	19	#include <AW_rename.hxx>
20	20	#include <aw_msg.hxx>
21		#include <a~~w_status.hxx~~>
	21	#include <arb_progress.h>
22	22	#include <aw_root.hxx>
23	23	#include <GenomeImport.h>
…	…
391	391	char *sys = GBS_string_eval(awtcig.ifo2->system, srt, 0);
392	392
393		a~~w_status~~(GBS_global_string("exec '%s'", awtcig.ifo2->system));
	393	arb_progress::show_comment(GBS_global_string("exec '%s'", awtcig.ifo2->system));
394	394
395	395	error = GB_system(sys);
…	…
419	419	char *sys = GBS_string_eval(awtcig.ifo->system, srt, 0);
420	420
421		a~~w_status~~(GBS_global_string("Converting File %s", awtcig.ifo->system));
	421	arb_progress::show_comment(GBS_global_string("Converting File %s", awtcig.ifo->system));
422	422
423	423	error = GB_system(sys);
…	…
704	704
705	705	counter++;
706		~~sprintf(text, "Reading species %i", counter);~~
707	706	if (counter % 10 == 0) {
708		if (aw_status(text)) break;
	707	sprintf(text, "Reading species %i", counter);
	708	arb_progress::show_comment(text);
709	709	}
710	710
…	…
957	957	GB_commit_transaction(GB_MAIN);
958	958
959		a~~w_openstatus("Reading input files"~~);
	959	arb_progress progress("Reading input files", count);
960	960
961	961	for (int curr = 0; !error && fnames[curr]; ++curr) {
…	…
965	965	{
966	966	const char *lslash = strrchr(fnames[curr], '/');
967		~~aw_status~~(GBS_global_string("%i/%i: %s", curr+1, count, lslash ? lslash+1 : fnames[curr]));
	967	progress.subtitle(GBS_global_string("%i/%i: %s", curr+1, count, lslash ? lslash+1 : fnames[curr]));
968	968	}
969	969
…	…
985	985	}
986	986
987		~~aw_status((curr+1)/double(count)~~);
	987	progress.inc_and_check_user_abort(error);
988	988	}
989	989
…	…
994	994	GB_warningf("%i of %i files were imported with success", successfull_imports, (successfull_imports+failed_imports));
995	995	}
996
997		~~aw_closestatus();~~
998	996
999	997	// now open another transaction to "undo" the transaction close above
…	…
1047	1045	}
1048	1046
1049		~~bool status_open = false;~~
1050	1047	if (!error) {
1051		aw_openstatus("Reading input files");
1052		status_open = true;
	1048	arb_progress progress("Reading input files");
1053	1049
1054	1050	error = awtc_read_data(ali_name, ali_protection);
1055
1056	1051	if (error) {
1057	1052	error = GBS_global_string("Error: %s\nwhile reading file %s", error, awtcig.current_file[-1]);
…	…
1078	1073	awtcig.filenames = 0;
1079	1074	awtcig.current_file = 0;
1080
1081		~~if (status_open) aw_closestatus();~~
1082	1075	}
1083	1076	}
…	…
1101	1094	aww->hide(); // import window stays open in case of error
1102	1095
1103		a~~w_openstatus("Checking and Scanning database");~~
1104		~~aw_status~~("Pass 1: Check entries");
	1096	arb_progress progress("Checking and Scanning database", 2+ask_generate_names); // 2 or 3 passes
	1097	progress.subtitle("Pass 1: Check entries");
1105	1098
1106	1099	// scan for hidden/unknown fields :
…	…
1109	1102
1110	1103	GBT_mark_all(GB_MAIN, 1);
1111		~~sleep(1~~);
1112		~~aw_status~~("Pass 2: Check sequence lengths");
	1104	progress.inc();
	1105	progress.subtitle("Pass 2: Check sequence lengths");
1113	1106	GBT_check_data(GB_MAIN, 0);
1114		~~sleep(1);~~
1115	1107
1116	1108	GB_commit_transaction(GB_MAIN);
	1109	progress.inc();
1117	1110
1118	1111	if (ask_generate_names) {
…	…
1120	1113	"Generate new short names (recommended),Use found names")==0)
1121	1114	{
1122		~~aw_status~~("Pass 3: Generate unique names");
	1115	progress.subtitle("Pass 3: Generate unique names");
1123	1116	error = AW_select_nameserver(GB_MAIN, awtcig.gb_other_main);
1124	1117	if (!error) {
1125		error = AWTC_pars_names(GB_MAIN, 1);
1126		}
1127		}
1128		}
1129
1130		aw_closestatus();
	1118	error = AWTC_pars_names(GB_MAIN);
	1119	}
	1120	}
	1121	progress.inc();
	1122	}
1131	1123	}
1132	1124
…	…
1175	1167
1176	1168	if (last_valid_gbmain) { // detect default write protection for alignment
1177		GB_transaction ta(last_valid_gbmain);
1178		GBDATA *gb_ali = GBT_get_alignment(last_valid_gbmain, ali_name);
1179		int ~~protection_to_use = 4;~~ // default protection
	1169	GB_transaction ta(last_valid_gbmain);
	1170	GBDATA *gb_ali = GBT_get_alignment(last_valid_gbmain, ali_name);
	1171	int protection_to_use = 4; // default protection
1180	1172
1181	1173	if (gb_ali) {
…	…
1184	1176	protection_to_use = GB_read_int(gb_write_security);
1185	1177	}
	1178	}
	1179	else {
	1180	GB_clear_error();
1186	1181	}
1187	1182	awr->awar(AWAR_ALI_PROTECTION)->write_int(protection_to_use);

branches/refactor/AWTI/Makefile

r7089	r7097
40	40	AWTI_export.o: $(ARBHOME)/INCLUDE/arb_error.h
41	41	AWTI_export.o: $(ARBHOME)/INCLUDE/arb_msg.h
	42	AWTI_export.o: $(ARBHOME)/INCLUDE/arb_progress.h
42	43	AWTI_export.o: $(ARBHOME)/INCLUDE/arb_str.h
43	44	AWTI_export.o: $(ARBHOME)/INCLUDE/arb_string.h
…	…
54	55	AWTI_export.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
55	56	AWTI_export.o: $(ARBHOME)/INCLUDE/aw_root.hxx
56		~~AWTI_export.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
57	57	AWTI_export.o: $(ARBHOME)/INCLUDE/aw_window.hxx
58	58	AWTI_export.o: $(ARBHOME)/INCLUDE/awt_filter.hxx
…	…
72	72	AWTI_import.o: $(ARBHOME)/INCLUDE/arb_error.h
73	73	AWTI_import.o: $(ARBHOME)/INCLUDE/arb_msg.h
	74	AWTI_import.o: $(ARBHOME)/INCLUDE/arb_progress.h
74	75	AWTI_import.o: $(ARBHOME)/INCLUDE/arb_string.h
75	76	AWTI_import.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
87	88	AWTI_import.o: $(ARBHOME)/INCLUDE/aw_root.hxx
88	89	AWTI_import.o: $(ARBHOME)/INCLUDE/aw_select.hxx
89		~~AWTI_import.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
90	90	AWTI_import.o: $(ARBHOME)/INCLUDE/aw_window.hxx
91	91	AWTI_import.o: $(ARBHOME)/INCLUDE/awt.hxx

branches/refactor/CORE/Makefile

r7084	r7097
11	11	$(CPPLIB) $(cflags) -c $< $(AINCLUDES) $(POST_COMPILE)
12	12
13		.cxx.genh:
14		../MAKEBIN/aisc_mkpt -P -G -A -w $(subst .genh,.h,$@) $< > $@
15
16		.genh.h:
17		../SOURCE_TOOLS/mv_if_diff $< $@
18
19		GENERATED_HEADERS=\
20		arb_msg.h \
21		arb_string.h \
22		arb_signal.h \
23
24		proto: $(GENERATED_HEADERS)
	13	proto:
	14	../MAKEBIN/aisc_mkpt -P -G -A -w arb_msg.h arb_msg.cxx > arb_msg.genh
	15	../MAKEBIN/aisc_mkpt -P -G -A -w arb_string.h arb_string.cxx > arb_string.genh
	16	../MAKEBIN/aisc_mkpt -P -G -A -w arb_signal.h arb_signal.cxx > arb_signal.genh
	17	../SOURCE_TOOLS/mv_if_diff arb_msg.genh arb_msg.h
	18	../SOURCE_TOOLS/mv_if_diff arb_string.genh arb_string.h
	19	../SOURCE_TOOLS/mv_if_diff arb_signal.genh arb_signal.h
25	20
26	21	clean:
…	…
46	41	arb_handlers.o: arb_core.h
47	42	arb_handlers.o: arb_handlers.h
	43	arb_handlers.o: arb_msg.h
	44	arb_handlers.o: $(ARBHOME)/INCLUDE/arb_assert.h
	45	arb_handlers.o: $(ARBHOME)/INCLUDE/attributes.h
48	46	arb_handlers.o: $(ARBHOME)/INCLUDE/dupstr.h
	47	arb_handlers.o: $(ARBHOME)/INCLUDE/smartptr.h
	48	arb_handlers.o: $(ARBHOME)/INCLUDE/test_global.h
49	49
50	50	arb_msg.o: arb_core.h
…	…
52	52	arb_msg.o: arb_msg.h
53	53	arb_msg.o: arb_string.h
54		~~arb_msg.o: core.h~~
55	54	arb_msg.o: $(ARBHOME)/INCLUDE/arb_assert.h
56	55	arb_msg.o: $(ARBHOME)/INCLUDE/arb_backtrace.h
…	…
61	60
62	61	arb_progress.o: arb_core.h
	62	arb_progress.o: arb_handlers.h
	63	arb_progress.o: arb_msg.h
63	64	arb_progress.o: arb_progress.h
64	65	arb_progress.o: $(ARBHOME)/INCLUDE/arb_assert.h
	66	arb_progress.o: $(ARBHOME)/INCLUDE/arb_error.h
	67	arb_progress.o: $(ARBHOME)/INCLUDE/arbtools.h
	68	arb_progress.o: $(ARBHOME)/INCLUDE/attributes.h
65	69	arb_progress.o: $(ARBHOME)/INCLUDE/dupstr.h
	70	arb_progress.o: $(ARBHOME)/INCLUDE/smartptr.h
66	71	arb_progress.o: $(ARBHOME)/INCLUDE/test_global.h
67	72	arb_progress.o: $(ARBHOME)/INCLUDE/test_unit.h

branches/refactor/CORE/arb_handlers.cxx

r7084	r7097
10	10	// ================================================================ //
11	11
12		#include "arb_handlers.h"
	12	#include <arb_handlers.h>
	13	#include <arb_msg.h>
	14	#include <arb_assert.h>
	15	#include <smartptr.h>
	16	#include <unistd.h>
	17
13	18
14	19	// AISC_MKPT_PROMOTE:#ifndef ARB_CORE_H
…	…
16	21	// AISC_MKPT_PROMOTE:#endif
17	22
18		static void gb_error_to_stderr(const char *msg) {
	23	static void to_stderr(const char *msg) {
	24	fflush(stdout);
19	25	fprintf(stderr, "%s\n", msg);
	26	fflush(stderr);
	27	}
	28	static void to_stdout(const char *msg) {
	29	fprintf(stdout, "%s\n", msg);
20	30	}
21	31
22		gb_error_handler_type gb_error_handler = gb_error_to_stderr;
23		gb_warning_func_type gb_warning_func;
24		gb_information_func_type gb_information_func;
25		gb_status_gauge_func_type gb_status_gauge_func;
26		gb_status_msg_func_type gb_status_msg_func;
	32	// -------------------------
	33	// ARB_stdout_status
27	34
	35	const int HEIGHT = 12; // 12 can be devided by 2, 3, 4 (so subtitles tend to be at start of line)
	36	const int WIDTH = 70;
	37	const char CHAR = '.';
28	38
29		void GB_install_error_handler(gb_error_handler_type aw_message_handler) {
30		gb_error_handler = aw_message_handler;
31		}
	39	#if defined(DEBUG)
	40	static int openCount = 0;
	41	static int set_gauge_called = 0;
	42	#endif
32	43
33		void GB_install_warning(gb_warning_func_type warn) {
34		gb_warning_func = warn;
35		}
	44	class BasicStatus {
	45	char *subtitle;
	46	int printed;
	47	const char *cursor;
36	48
37		void GB_install_information(gb_information_func_type info) {
38		gb_information_func = info;
39		}
	49	public:
	50	void open(const char *title) {
	51	#if defined(DEBUG)
	52	arb_assert(++openCount <= 1);
	53	set_gauge_called = 0;
	54	#endif
	55
	56	printf("Progress: %s\n", title);
	57	printed = 0;
	58	cursor = NULL;
	59	subtitle = NULL;
	60	}
	61	void close() {
	62	freenull(subtitle);
	63	printf("[done]\n");
	64	#if defined(DEBUG)
	65	printf("set_gauge_called=%i\n", set_gauge_called);
	66	arb_assert(set_gauge_called<1000); // crazy caller ?
	67	arb_assert(--openCount >= 0);
	68	#endif
	69	fflush(stdout);
	70	}
40	71
41		void GB_install_status(gb_status_gauge_func_type gauge_fun, gb_status_msg_func_type msg_fun) {
42		gb_status_gauge_func = gauge_fun;
43		gb_status_msg_func = msg_fun;
44		}
	72	~BasicStatus() {
	73	#if defined(DEBUG)
	74	if (openCount)
	75	#endif
	76	close();
	77	}
45	78
	79	int next_LF() const { return printed-printed%WIDTH+WIDTH; }
	80
	81	void set_subtitle(const char *stitle) {
	82	arb_assert(openCount == 1);
	83	if (cursor) {
	84	int offset = cursor - subtitle;
	85	subtitle[strlen(subtitle)-1] = 0;
	86	freeset(subtitle, GBS_global_string_copy("%s/%s}", subtitle, stitle));
	87	cursor = subtitle+offset;
	88	}
	89	else {
	90	freeset(subtitle, GBS_global_string_copy("{%s}", stitle));
	91	cursor = subtitle;
	92	}
	93	}
	94	void set_gauge(double gauge) {
	95	#if defined(DEBUG)
	96	arb_assert(openCount == 1);
	97	set_gauge_called++;
	98	#endif
	99
	100	int wanted = int(gaugeWIDTHHEIGHT);
	101	int nextLF = next_LF();
	102
	103	if (printed<wanted) {
	104	while (printed<wanted) {
	105	if (cursor && cursor[0]) {
	106	fputc(*cursor++, stdout);
	107	}
	108	else {
	109	cursor = 0;
	110	fputc(CHAR, stdout);
	111	}
	112	printed++;
	113	if (printed == nextLF) {
	114	printf(" [%5.1f%%]\n", printed100.0/(WIDTHHEIGHT));
	115	nextLF = next_LF();
	116	}
	117	}
	118	fflush(stdout);
	119	#if defined(DEBUG)
	120	// usleep(25000); // uncomment to see slow status
	121	#endif
	122	}
	123	}
	124	};
	125
	126	static BasicStatus status;
	127
	128	static void basic_openstatus(const char *title) { status.open(title); }
	129	static void basic_closestatus() { status.close(); }
	130	static bool basic_set_title(const char /title*/) { return false; }
	131	static bool basic_set_subtitle(const char *stitle) { status.set_subtitle(stitle); return false; }
	132	static bool basic_set_gauge(double gauge) { status.set_gauge(gauge); return false; }
	133	static bool basic_user_abort() { return false; }
	134
	135	static arb_status_implementation ARB_stdout_status = {
	136	AST_FORWARD,
	137	basic_openstatus,
	138	basic_closestatus,
	139	basic_set_title,
	140	basic_set_subtitle,
	141	basic_set_gauge,
	142	basic_user_abort
	143	};
	144
	145	static arb_handlers stderr_handlers = {
	146	to_stderr,
	147	to_stdout,
	148	to_stdout,
	149	ARB_stdout_status,
	150	};
	151
	152	arb_handlers *active_arb_handlers = &stderr_handlers;
	153	void ARB_install_handlers(arb_handlers& handlers) { active_arb_handlers = &handlers; }
	154

branches/refactor/CORE/arb_handlers.h

r7084	r7097
16	16	#include <arb_core.h>
17	17	#endif
	18	#ifndef ATTRIBUTES_H
	19	#include <attributes.h>
	20	#endif
18	21
19		void GB_install_error_handler(gb_error_handler_type aw_message_handler);
20		void GB_install_warning(gb_warning_func_type warn);
21		void GB_install_information(gb_information_func_type info);
22		void GB_install_status(gb_status_gauge_func_type gauge_fun, gb_status_msg_func_type msg_fun);
	22	enum arb_status_type {
	23	AST_FORWARD, // gauge may only increment (not decrement)
	24	AST_RANDOM, // random gauge allowed
	25	};
	26
	27	struct arb_status_implementation {
	28	arb_status_type type;
	29	void (openstatus)(const char title); // opens the status window and sets title
	30	void (*closestatus)(); // close the status window
	31	bool (set_title)(const char title); // set the title (return true on user abort)
	32	bool (set_subtitle)(const char title); // set the subtitle (return true on user abort)
	33	bool (*set_gauge)(double gauge); // set the gauge (=percent) (return true on user abort)
	34	bool (*user_abort)(); // return true on user abort
	35	};
	36
	37	struct arb_handlers {
	38	gb_error_handler_type show_error;
	39	gb_warning_func_type show_warning;
	40	gb_information_func_type show_message;
	41	arb_status_implementation status;
	42	};
	43
	44	extern arb_handlers *active_arb_handlers;
	45
	46	void ARB_install_handlers(arb_handlers& handlers);
23	47
24	48	#else

branches/refactor/CORE/arb_msg.cxx

r7084	r7097
16	16	#include <smartptr.h>
17	17	#include <arb_handlers.h>
18		~~#include "core.h"~~
19
20	18
21	19	/* AISC_MKPT_PROMOTE:#ifndef _GLIBCXX_CSTDLIB */
…	…
301	299
302	300	GB_ERROR GB_export_IO_error(const char action, const char filename) {
303		// goes to header: __ATTR__DEPRECATED
	301	// goes to header: __ATTR__DEPRECATED_LATER
304	302	return GB_export_error(GB_IO_error(action, filename));
305	303	}
…	…
311	309
312	310	GB_ERROR GB_print_error() {
313		// goes to header: __~~XATTR__DEPRECATED~~
	311	// goes to header: __ATTR__DEPRECATED_LATER
314	312	if (GB_error_buffer) {
315	313	fflush(stdout);
…	…
320	318
321	319	GB_ERROR GB_get_error() {
322		// goes to header: __ATTR__DEPRECATED
	320	// goes to header: __ATTR__DEPRECATED_LATER
323	321
324	322	/* This function is deprecated.
…	…
410	408
411	409	char *full_message = GBS_global_string_copy("Internal ARB Error: %s", message);
412		~~gb_error_handle~~r(full_message);
413		~~gb_error_handle~~r("ARB is most likely unstable now (due to this error).\n"
414		"If you've made changes to the database, consider to save it using a different name.\n"
415		"Try to fix the cause of the error and restart ARB.");
	410	active_arb_handlers->show_error(full_message);
	411	active_arb_handlers->show_error("ARB is most likely unstable now (due to this error).\n"
	412	"If you've made changes to the database, consider to save it using a different name.\n"
	413	"Try to fix the cause of the error and restart ARB.");
416	414
417	415	#ifdef ASSERTION_USED
…	…
466	464	* see also : GB_information
467	465	*/
468
469		if (gb_warning_func) {
470		gb_warning_func(message);
471		}
472		else {
473		fputs(message, stdout);
474		fputc('\n', stdout);
475		}
	466	active_arb_handlers->show_warning(message);
476	467	}
477	468	void GB_warningf(const char *templat, ...) {
…	…
489	480
490	481	void GB_information(const char *message) {
491		if (gb_information_func) {
492		gb_information_func(message);
493		}
494		else {
495		fputs(message, stdout);
496		fputc('\n', stdout);
497		}
	482	active_arb_handlers->show_message(message);
498	483	}
499	484	void GB_informationf(const char *templat, ...) {
…	…
514	499	}
515	500
516		~~int GB_status(double val) {~~
517		~~int result = 0;~~
518
519		~~/* if program uses GUI this uses aw_status(),~~
520		* otherwise it uses simple status to stdout
521		*
522		* return value : 0 = ok, 1 = userAbort
523		*/
524
525		~~if (gb_status_gauge_func) {~~
526		~~result = gb_status_gauge_func(val);~~
527		}
528		~~else {~~
529		~~char buffer[100];~~
530		~~int i;~~
531		~~static int lastv = 0;~~
532		~~int v = (int)(val*80);~~
533		~~if (v == lastv) return 0;~~
534		~~lastv = v;~~
535		~~for (i=0; i<v; i++) buffer[i] = '+';~~
536		~~for (; i<80; i++) buffer[i] = '-';~~
537		~~buffer[i] = 0;~~
538		~~fprintf(stdout, "%s\n", buffer);~~
539		}
540		~~return result;~~
541		}
542
543		~~int GB_status(const char *message) {~~
544		~~int result = 0;~~
545
546		~~if (gb_status_msg_func) {~~
547		~~result = gb_status_msg_func(message);~~
548		}
549		~~else {~~
550		~~fputs(message, stdout);~~
551		~~fputc('\n', stdout);~~
552		}
553
554		~~return result;~~
555		}
556

branches/refactor/CORE/arb_msg.h

r7084	r7097
30	30	GB_ERROR GB_export_errorf(const char *templat, ...) __ATTR__FORMAT(1) __ATTR__DEPRECATED_LATER;
31	31	GB_ERROR GB_IO_error(const char action, const char filename);
32		GB_ERROR GB_export_IO_error(const char action, const char filename) __ATTR__DEPRECATED;
33		GB_ERROR GB_print_error(void);
34		GB_ERROR GB_get_error(void) __ATTR__DEPRECATED;
	32	GB_ERROR GB_export_IO_error(const char action, const char filename) __ATTR__DEPRECATED_LATER;
	33	GB_ERROR GB_print_error(void) __ATTR__DEPRECATED_LATER;
	34	GB_ERROR GB_get_error(void) __ATTR__DEPRECATED_LATER;
35	35	bool GB_have_error(void);
36	36	GB_ERROR GB_await_error(void);
…	…
50	50	void GB_information(const char *message);
51	51	void GB_informationf(const char *templat, ...) __ATTR__FORMAT(1);
52		~~int GB_status(double val);~~
53		~~int GB_status(const char *message);~~
54	52
55	53	#else

branches/refactor/CORE/arb_progress.cxx

r7084	r7097
10	10	// ================================================================ //
11	11
12		#include "arb_progress.h"
13		#include <cstdio>
14
	12	#include <arb_progress.h>
	13	#include <arb_handlers.h>
	14	#include <arb_msg.h>
	15	#include <algorithm>
	16
	17	// ----------------
	18	// counter
	19
	20	struct null_counter: public arb_progress_counter {
	21	null_counter(arb_parent_progress *progress_) : arb_progress_counter(progress_) {}
	22
	23	void inc() {}
	24	void implicit_inc() {}
	25	void done() {}
	26	void restart(int) {}
	27	void force_update() {}
	28	void auto_subtitles(const char *) {}
	29	bool has_auto_subtitles() { return false; }
	30	void child_updates_gauge(double ) {
	31	arb_assert(0); // wont
	32	}
	33
	34	#if defined(DUMP_PROGRESS)
	35	void dump() {
	36	fprintf(stderr, "null_counter\n");
	37	}
	38	#endif
	39
	40	arb_progress_counter* clone(arb_parent_progress *parent_, int ) const { return new null_counter(parent_); }
	41	};
	42
	43	struct no_counter : public null_counter {
	44	no_counter(arb_parent_progress *progress_) : null_counter(progress_) {}
	45	void inc() {
	46	arb_assert(0); // this is no_counter - so explicit inc() is prohibited!
	47	}
	48	void child_updates_gauge(double gauge) { progress->update_gauge(gauge); }
	49
	50	#if defined(DUMP_PROGRESS)
	51	void dump() {
	52	fprintf(stderr, "no_counter (=wrapper)\n");
	53	}
	54	#endif
	55	};
	56
	57	class concrete_counter: public arb_progress_counter {
	58	int explicit_counter; // incremented by calls to inc() etc.
	59	int implicit_counter; // incremented by child_done()
	60	int maxcount; // == 0 -> does not really count (just a wrapper for child progresses)
	61	double autoUpdateEvery;
	62	double nextAutoUpdate;
	63	char *auto_subtitle_prefix;
	64	int last_auto_counter;
	65
	66	int dispositive_counter() const { return std::max(implicit_counter, explicit_counter); }
	67
	68	void init(int overallCount) {
	69	arb_assert(overallCount>0);
	70
	71	implicit_counter = 0;
	72	explicit_counter = 0;
	73	maxcount = overallCount;
	74	autoUpdateEvery = overallCount/500.0; // update status approx. 500 times
	75	nextAutoUpdate = 0;
	76	}
	77
	78	bool refresh_if_needed(double my_counter) {
	79	if (my_counter<nextAutoUpdate) return false;
	80	progress->update_gauge(my_counter/maxcount);
	81	if (auto_subtitle_prefix) {
	82	int count = int(my_counter+1);
	83	if (count>last_auto_counter) {
	84	const char *autosub = GBS_global_string("%s #%i/%i", auto_subtitle_prefix, count, maxcount);
	85	progress->set_text(LEVEL_SUBTITLE, autosub);
	86	last_auto_counter = count;
	87	}
	88	}
	89	nextAutoUpdate += autoUpdateEvery;
	90	return true;
	91	}
	92	void update_display_if_needed() {
	93	int dcount = dispositive_counter();
	94	arb_assert(dcount <= maxcount);
	95	refresh_if_needed(dcount);
	96	}
	97
	98	void force_update() {
	99	int oldNext = nextAutoUpdate;;
	100	nextAutoUpdate = 0;
	101	update_display_if_needed();
	102	nextAutoUpdate = oldNext;
	103	}
	104
	105	public:
	106	concrete_counter(arb_parent_progress *parent, int overall_count)
	107	: arb_progress_counter(parent),
	108	auto_subtitle_prefix(NULL),
	109	last_auto_counter(0)
	110	{
	111	arb_assert(overall_count>0);
	112	init(overall_count);
	113	}
	114	~concrete_counter() {
	115	free(auto_subtitle_prefix);
	116	#if defined(TEST_COUNTERS)
	117	if (!progress->accept_invalid_counters) {
	118	arb_assert(implicit_counter \|\| explicit_counter); // progress was never incremented
	119
	120	arb_assert(implicit_counter <= maxcount); // overflow
	121	arb_assert(explicit_counter <= maxcount); // overflow
	122
	123	arb_assert(dispositive_counter() == maxcount); // progress did not finish
	124	}
	125	#endif
	126	}
	127
	128	#if defined(DUMP_PROGRESS)
	129	void dump() {
	130	fprintf(stderr,
	131	"concrete_counter: explicit=%i, implicit=%i, maxcount=%i\n",
	132	explicit_counter, implicit_counter, maxcount);
	133	}
	134	#endif
	135
	136	void auto_subtitles(const char *prefix) {
	137	arb_assert(!auto_subtitle_prefix);
	138	freedup(auto_subtitle_prefix, prefix);
	139	force_update();
	140	}
	141	bool has_auto_subtitles() { return auto_subtitle_prefix; }
	142
	143	void inc() { explicit_counter += 1; update_display_if_needed(); }
	144	void implicit_inc() { implicit_counter += 1; update_display_if_needed(); }
	145
	146	void done() {
	147	implicit_counter = explicit_counter = maxcount;
	148	force_update();
	149	}
	150
	151	void restart(int overallCount) {
	152	init(overallCount);
	153	force_update();
	154	}
	155
	156	arb_progress_counter* clone(arb_parent_progress *parent, int overall_count) const{
	157	return new concrete_counter(parent, overall_count);
	158	}
	159	void child_updates_gauge(double child_gauge) {
	160	refresh_if_needed(dispositive_counter()+child_gauge);
	161	}
	162	};
	163
	164	// -----------------
	165	// progress
	166
	167
	168	class child_progress : public arb_parent_progress {
	169	arb_parent_progress *parent;
	170
	171	public:
	172	child_progress(arb_parent_progress parent_, const char title, int overall_count)
	173	: arb_parent_progress(overall_count
	174	? (arb_progress_counter*)new concrete_counter(this, overall_count)
	175	: (arb_progress_counter*)new no_counter(this),
	176	title),
	177	parent(parent_)
	178	{
	179	set_text(LEVEL_TITLE, title);
	180	#if defined(DUMP_PROGRESS)
	181	freedup(name, GBS_global_string("child: %s", title));
	182	#endif
	183	}
	184	~child_progress() {
	185	parent->child_terminated();
	186	}
	187
	188	SmartPtr<arb_parent_progress> create_child_progress(const char *title, int overall_count) {
	189	return new child_progress(this, title, overall_count);
	190	}
	191
	192	#if defined(DUMP_PROGRESS)
	193	void dump() {
	194	arb_parent_progress::dump();
	195	fprintf(stderr, "is child of\n");
	196	parent->dump();
	197	}
	198	#endif
	199
	200	bool aborted() const { return parent->aborted(); }
	201	void set_text(int level, const char *text) { parent->child_sets_text(level+has_title-1, text); }
	202
	203	void update_gauge(double gauge) { parent->child_updates_gauge(gauge); }
	204	};
	205
	206	class initial_progress: public arb_parent_progress {
	207	bool user_abort;
	208
	209	public:
	210	initial_progress(const char title, arb_progress_counter counter_)
	211	: arb_parent_progress(counter_, title),
	212	user_abort(false)
	213	{
	214	arb_assert(title); // initial progress should have a title
	215	impl->openstatus(title);
	216	#if defined(DUMP_PROGRESS)
	217	freedup(name, GBS_global_string("initial: %s", title));
	218	#endif
	219	}
	220	~initial_progress() {
	221	update_gauge(1.0); // due to numeric issues it often only counts up to 99.999%
	222	impl->closestatus();
	223	}
	224
	225	SmartPtr<arb_parent_progress> create_child_progress(const char *title, int overall_count) {
	226	return new child_progress(this, title, overall_count);
	227	}
	228
	229	bool aborted() const { return user_abort; }
	230	void set_text(int level, const char *text) {
	231	if (!text) return;
	232	switch (level+has_title-1) {
	233	case LEVEL_TITLE: impl->set_title(text); break;
	234	case LEVEL_SUBTITLE: impl->set_subtitle(text); break;
	235	}
	236	}
	237
	238	void update_gauge(double gauge) { user_abort = impl->set_gauge(gauge); }
	239	};
	240
	241	struct initial_wrapping_progress: public initial_progress {
	242	initial_wrapping_progress(const char *title)
	243	: initial_progress(title, new no_counter(this)) {}
	244	};
	245	struct initial_counting_progress : public initial_progress {
	246	initial_counting_progress(const char *title, int overall_count)
	247	: initial_progress(title, new concrete_counter(this, overall_count)) {}
	248	};
	249
	250	class null_progress: public arb_parent_progress {
	251	public:
	252	null_progress(arb_progress_counter *counter_)
	253	: arb_parent_progress(counter_, false)
	254	{
	255	#if defined(DUMP_PROGRESS)
	256	freedup(name, "null_progress");
	257	#endif
	258	}
	259
	260	SmartPtr<arb_parent_progress> create_child_progress(const char*, int overall_count) {
	261	return new null_progress(clone_counter(overall_count));
	262	}
	263	bool aborted() const { return false; }
	264	void set_text(int,const char*) {}
	265	void update_gauge(double) {}
	266	};
15	267
16	268	// -------------------------
17		// ARB_basic_status
18
19		const int HEIGHT = 10;
20		const int WIDTH = 70;
21		const char CHAR = '.';
22
23		static int printed = 0;
24
25		static void basic_openstatus(const char *title) {
26		printf("Progress: %s\n", title);
27		printed = 0;
28		}
29		static void basic_closestatus() {
30		printf("[done]\n");
31		}
32		static bool basic_set_subtitle(const char *) { return false; }
33		static bool basic_set_gauge(double gauge) {
34		int wanted = int(gaugeWIDTHHEIGHT);
35		int nextLF = printed-printed%WIDTH+WIDTH;
36		while (printed<wanted) {
37		fputc(CHAR, stdout);
38		printed++;
39		if (printed == nextLF) {
40		printf(" [%5.1f%%]\n", printed100.0/(WIDTHHEIGHT));
41		nextLF = printed-printed%WIDTH+WIDTH;
42		}
43		}
44		return false;
45		}
46		static bool basic_user_abort() { return false; }
47
48		arb_status_implementation ARB_basic_status = {
49		basic_openstatus,
50		basic_closestatus,
51		basic_set_subtitle,
52		basic_set_gauge,
53		basic_user_abort
54		};
55
56		// ------------------------
57		// ARB_null_status
58
59		static void null_openstatus(const char *) {}
60		static void null_closestatus() {}
61		static bool null_set_subtitle(const char *) { return false; }
62		static bool null_set_gauge(double ) { return false; }
63		static bool null_user_abort() { return false; }
64
65		arb_status_implementation ARB_null_status = {
66		null_openstatus,
67		null_closestatus,
68		null_set_subtitle,
69		null_set_gauge,
70		null_user_abort
71		};
72
73		// ---------------------
74		// arb_progress
75
76		arb_status_implementation *arb_progress::impl = &ARB_basic_status;
77		arb_progress::arb_progress *opened = NULL;
	269	// progress factory
	270
	271	arb_parent_progress *arb_parent_progress::recent = NULL;
	272	arb_status_implementation *arb_parent_progress::impl = NULL; // defines implementation to display status
	273
	274	SmartPtr<arb_parent_progress> arb_parent_progress::create(const char *title, int overall_count) {
	275	if (recent) {
	276	return recent->create_child_progress(title, overall_count);
	277	}
	278
	279	impl = &active_arb_handlers->status;
	280
	281	if (overall_count == 0) return new initial_wrapping_progress(title);
	282	return new initial_counting_progress(title, overall_count);
	283
	284	}
	285
	286	SmartPtr<arb_parent_progress> arb_parent_progress::create_suppressor() {
	287	return new null_progress(new null_counter(NULL));
	288	}
78	289
79	290	// --------------------------------------------------------------------------------
…	…
82	293	#include <test_unit.h>
83	294
84		void TEST_arb_progress() {
85		arb_progress outer("outer", 100);
86		for (int i = 0; i<100; ++i) {
87		++outer;
88		}
89		}
	295	const int OUTERCOUNT = 100;
	296	const int INNERCOUNT = 200;
	297
	298	void TEST_simple_arb_progress() {
	299	const int SIMPLECOUNT = OUTERCOUNT*INNERCOUNT;
	300
	301	arb_progress simple("simple", SIMPLECOUNT);
	302	for (int i = 0; i<SIMPLECOUNT; ++i) {
	303	simple.inc();
	304	}
	305	}
	306
	307	#if defined(TEST_COUNTERS)
	308	void TEST_aborted_arb_progress() {
	309	const int SIMPLECOUNT = OUTERCOUNT*INNERCOUNT;
	310
	311	arb_progress simple("simple", SIMPLECOUNT);
	312	GB_ERROR error = NULL;
	313	for (int i = 0; i<SIMPLECOUNT && !error; ++i) {
	314	if (i > 10) {
	315	error = "someError";
	316	}
	317	simple.inc_and_check_user_abort(error);
	318	}
	319	TEST_ASSERT_EQUAL(error, "someError");
	320	}
	321	#endif
	322
	323	void TEST_nested_arb_progress() {
	324	for (int explicit_incr = 0; explicit_incr<2; ++explicit_incr) {
	325	arb_progress outer(explicit_incr ? "explicit" : "only implicit", OUTERCOUNT);
	326	if (explicit_incr) outer.auto_subtitles("expl");
	327	for (int i = 0; i<OUTERCOUNT; ++i) {
	328	arb_progress inner("inner", INNERCOUNT);
	329	for (int j = 0; j<INNERCOUNT; ++j) {
	330	++inner;
	331	}
	332	if (explicit_incr) outer.inc();
	333	}
	334	}
	335	}
	336
	337	static int nested_progress_count = 0;
	338
	339	static void spawn_numerous_nested_progresses(int level, int recurse) {
	340	const int SUBPROGRESSES = 3;
	341	arb_progress progress(GBS_global_string("progress level %i", level), SUBPROGRESSES);
	342	nested_progress_count++;
	343
	344	if (recurse) {
	345	for (int sp = 0; sp<SUBPROGRESSES; ++sp) {
	346	spawn_numerous_nested_progresses(level+1, recurse-1);
	347	}
	348	}
	349	else {
	350	progress.done();
	351	}
	352	}
	353
	354	void TEST_deep_nested_arb_progress() {
	355	nested_progress_count = 0;
	356	spawn_numerous_nested_progresses(0, 5); // spawns 364 nested progresses
	357	printf("nested_progress_count=%i\n", nested_progress_count);
	358	}
	359
	360	void TEST_wrapping_arb_progress() {
	361	arb_progress progress("wrapper");
	362	for (int i = 0; i<3; ++i) {
	363	arb_progress inner("inner", INNERCOUNT);
	364	for (int j = 0; j<INNERCOUNT; ++j) {
	365	++inner;
	366	}
	367	}
	368	}
	369
	370
90	371
91	372	#endif // UNIT_TESTS

branches/refactor/CORE/arb_progress.h

r7084	r7097
16	16	#include <arb_assert.h>
17	17	#endif
18
19		struct arb_status_implementation {
20		void (openstatus)(const char title); // opens the status window and sets title
21		void (*closestatus)(); // close the status window
22		bool (set_subtitle)(const char title); // set the subtitle (return true on user abort)
23		bool (*set_gauge)(double gauge); // set the gauge (=percent) (return true on user abort)
24		bool (*user_abort)(); // return true on user abort
25		};
26
27		extern arb_status_implementation ARB_basic_status;
28		extern arb_status_implementation ARB_null_status;
	18	#ifndef ARB_ERROR_H
	19	#include <arb_error.h>
	20	#endif
	21	#ifndef ARBTOOLS_H
	22	#include <arbtools.h>
	23	#endif
	24
	25	#if defined(DEBUG)
	26	#if defined(DEVEL_RALF)
	27	#define DUMP_PROGRESS
	28	#define TEST_COUNTERS
	29	#endif
	30	#endif
	31
	32
	33	class arb_parent_progress;
	34	struct arb_status_implementation;
	35
	36	class arb_progress_counter {
	37	protected:
	38	arb_parent_progress *progress;
	39	public:
	40	arb_progress_counter(arb_parent_progress *progress_)
	41	: progress(progress_)
	42	{}
	43	virtual ~arb_progress_counter() {}
	44
	45	virtual void inc() = 0;
	46	virtual void implicit_inc() = 0;
	47	virtual void child_updates_gauge(double gauge) = 0;
	48	virtual void done() = 0;
	49	virtual void force_update() = 0;
	50	virtual void restart(int overall_count) = 0;
	51	virtual void auto_subtitles(const char *prefix) = 0;
	52	virtual bool has_auto_subtitles() = 0;
	53
	54	#if defined(DUMP_PROGRESS)
	55	virtual void dump() = 0;
	56	#endif
	57
	58	virtual arb_progress_counter clone(arb_parent_progress parent, int overall_count) const = 0;
	59	};
	60
	61	const int LEVEL_TITLE = 0;
	62	const int LEVEL_SUBTITLE = 1;
	63
	64	class arb_parent_progress : Noncopyable {
	65	arb_parent_progress *prev_recent;
	66	bool reuse_allowed; // display may be reused by childs
	67
	68	protected:
	69	#if defined(DUMP_PROGRESS)
	70	char *name;
	71	#endif
	72
	73	bool has_title;
	74	arb_progress_counter *counter;
	75
	76	static arb_parent_progress *recent;
	77	static arb_status_implementation *impl; // defines implementation to display status
	78
	79	virtual SmartPtr<arb_parent_progress> create_child_progress(const char *title, int overall_count) = 0;
	80
	81	arb_parent_progress(arb_progress_counter *counter_, bool has_title_)
	82	: reuse_allowed(false),
	83	has_title(has_title_),
	84	counter(counter_)
	85	{
	86	prev_recent = recent;
	87	recent = this;
	88
	89	#if defined(DUMP_PROGRESS)
	90	name = NULL;
	91	#endif
	92
	93	#if defined(TEST_COUNTERS)
	94	accept_invalid_counters = false;
	95	#endif
	96	}
	97	public:
	98	#if defined(TEST_COUNTERS)
	99	bool accept_invalid_counters; // if true, do not complain about unfinished counters
	100	#endif
	101
	102	virtual ~arb_parent_progress() {
	103	delete counter;
	104	recent = prev_recent;
	105	#if defined(DUMP_PROGRESS)
	106	free(name);
	107	#endif
	108	}
	109
	110	static SmartPtr<arb_parent_progress> create(const char *title, int overall_count);
	111	static SmartPtr<arb_parent_progress> create_suppressor();
	112
	113	virtual bool aborted() const = 0;
	114	virtual void set_text(int level, const char *text) = 0;
	115	virtual void update_gauge(double gauge) = 0;
	116
	117	#if defined(DUMP_PROGRESS)
	118	virtual void dump() {
	119	fprintf(stderr, "progress '%s'\n", name);
	120	fprintf(stderr, "counter: ");
	121	counter->dump();
	122	}
	123	#endif
	124
	125	void child_sets_text(int level, const char *text) {
	126	set_text(level+1-reuse_allowed+counter->has_auto_subtitles(), text);
	127	}
	128	void allow_title_reuse() { reuse_allowed = true; }
	129
	130	void child_updates_gauge(double gauge) { counter->child_updates_gauge(gauge); }
	131	void child_terminated() { counter->implicit_inc(); }
	132
	133	arb_progress_counter *clone_counter(int overall_count) { return counter->clone(this, overall_count); }
	134	void initial_update() { counter->force_update(); }
	135	void force_update() { counter->force_update(); }
	136
	137	void inc() { counter->inc(); }
	138	void done() { counter->done(); }
	139	void auto_subtitles(const char *prefix) { counter->auto_subtitles(prefix); }
	140
	141	static void show_comment(const char *comment) {
	142	if (recent) recent->set_text(LEVEL_SUBTITLE, comment);
	143	}
	144	};
29	145
30	146	class arb_progress {
31		static arb_status_implementation *impl;
32		static arb_progress *opened;
33
34		int counter;
35		int maxcount;
36		int autoUpdateEvery;
37		int nextAutoUpdate;
38		bool user_abort;
39
40		void track_abort(bool status_result) { if (status_result) user_abort = true; }
41		void init(int overallCount) {
42		counter = 0;
43		maxcount = overallCount;
44		autoUpdateEvery = overallCount <= 250 ? 1 : int(overallCount/250.0+0.5);
45		nextAutoUpdate = counter+autoUpdateEvery;
46		}
47
48		void update() { track_abort(impl->set_gauge(counter/double(maxcount))); }
49
50		public:
51		arb_progress(const char *title, int overall_count)
52		: user_abort(false)
53		{
54		init(overall_count);
55		impl->openstatus(title);
56		update();
57		}
58		~arb_progress() { impl->closestatus(); }
59
60		void inc(int incr = 1) {
61		counter += incr;
62		arb_assert(counter <= maxcount);
63		if (counter >= nextAutoUpdate) {
64		update();
65		nextAutoUpdate += autoUpdateEvery;
66		}
67		}
68		const arb_progress& operator++() { inc(); return *this; }
69		bool aborted() const { return user_abort; }
70		void restart(int overallCount) { init(overallCount); update(); }
	147	SmartPtr<arb_parent_progress> used;
	148
	149	void setup(const char *title, int overall_count) {
	150	used = arb_parent_progress::create(title, overall_count);
	151	used->initial_update();
	152	}
	153	void accept_invalid_counters() {
	154	#if defined(TEST_COUNTERS)
	155	used->accept_invalid_counters = true;
	156	#endif
	157	}
	158
	159	public:
	160	// ------------------------------
	161	// recommended interface:
	162
	163	arb_progress(const char *title, int overall_count) {
	164	// open a progress indicator
	165	//
	166	// expects to be incremented 'overall_count' times
	167	// incrementation is done either
	168	// - explicitely by calling one of the inc...()-functions below or
	169	// - implicitely by creating another arb_progress while this one remains
	170	//
	171	// if you can't ahead-determine the exact number of incrementations,
	172	// specify an upper-limit and call .done() before dtor.
	173
	174	arb_assert(overall_count>0);
	175	setup(title, overall_count);
	176	}
	177	explicit arb_progress(const char *title) {
	178	// open a wrapping progress indicator
	179	//
	180	// expects NOT to be incremented explicitely!
	181	// if arb_progresses are created while this exists, they reuse the progress window.
	182	// Useful to avoid spamming the user with numerous popping-up progress windows.
	183	setup(title, 0);
	184	}
	185	explicit arb_progress(int overall_count) {
	186	// open counting progress (reuses text of parent progress).
	187	//
	188	// Useful to separate text- from gauge-display or
	189	// to summarize several consecutive child-progresses into one.
	190	setup(NULL, overall_count);
	191	}
	192	arb_progress() {
	193	// plain wrapper (avoids multiple implicit increments of its parent).
	194	//
	195	// usage-conditions:
	196	// * caller increments progress in a loop and
	197	// * loop calls one or more callees and callees open multiple progress bars.
	198	//
	199	// in this case the parent progress would be implicitely incremented several times
	200	// per loop, resulting in wrong gauge.
	201	//
	202	// if you know the number of opened progresses, use arb_progress(int),
	203	// otherwise add one wrapper-progress into the loop.
	204	setup(NULL, 0);
	205	}
	206
	207	void allow_title_reuse() { used->allow_title_reuse(); }
	208
	209	void subtitle(const char *stitle) { used->set_text(LEVEL_SUBTITLE, stitle); }
	210
	211	GB_ERROR error_if_aborted() {
	212	return aborted() ? "Operation aborted on user request" : NULL;
	213	}
	214
	215	GB_ERROR inc_and_error_if_aborted() {
	216	inc();
	217	return error_if_aborted();
	218	}
	219
	220	void inc_and_check_user_abort(GB_ERROR& error) { if (!error) error = inc_and_error_if_aborted(); else accept_invalid_counters(); }
	221	void inc_and_check_user_abort(ARB_ERROR& error) { if (!error) error = inc_and_error_if_aborted(); else accept_invalid_counters(); }
	222
	223	bool aborted() {
	224	// true if user pressed "Abort"
	225	bool aborted_ = used->aborted();
	226	#if defined(TEST_COUNTERS)
	227	if (aborted_) accept_invalid_counters();
	228	#endif
	229	return aborted_;
	230	}
	231
	232	void auto_subtitles(const char *prefix) {
	233	// automatically update subtitles ("prefix #/#")
	234	// prefix = NULL -> switch off
	235	used->auto_subtitles(prefix);
	236	}
	237	static void show_comment(const char *comment) {
	238	// Like subtitle(), but w/o needing to know anything about a eventually open progress
	239	// e.g. used to show ARB is connecting to ptserver
	240	arb_parent_progress::show_comment(comment);
	241	}
	242
	243	// ------------------------------
	244	// less recommended interface:
	245
	246	void inc() { used->inc(); } // increment progress
	247	const arb_progress& operator++() { inc(); return *this; } // ++progress
	248
	249	void done() { used->done(); } // set "done" (aka 100%). Useful when exiting some loop early
	250	void dump() {
	251	fprintf(stderr, "--------------------\n");
	252	used->dump();
	253	}
	254	void force_update() { used->force_update(); }
	255	};
	256
	257	class arb_suppress_progress {
	258	SmartPtr<arb_parent_progress> suppressor;
	259	public:
	260	arb_suppress_progress() { suppressor = arb_parent_progress::create_suppressor(); }
71	261	};
72	262

branches/refactor/DIST/DI_clusters.cxx

r6858	r7097
24	24	#include <aw_awars.hxx>
25	25	#include <aw_msg.hxx>
26		#include <a~~w_status.hxx~~>
	26	#include <arb_progress.h>
27	27	#include <aw_root.hxx>
28	28
…	…
152	152	GB_ERROR error = NULL;
153	153
	154	arb_progress progress("Detecting clusters");
	155
154	156	// calculate ClusterTree
155	157	ClusterTreeRoot *tree = NULL;
…	…
175	177	}
176	178
177		~~aw_openstatus~~("Loading tree");
	179	progress.subtitle("Loading tree");
178	180	{
179	181	char *tree_name = aw_root->awar(AWAR_DIST_TREE_CURR_NAME)->read_string();
…	…
183	185
184	186	if (!error) error = tree->linkToDB(0, 0);
185		~~aw_closestatus();~~
186	187	}
187	188

branches/refactor/DIST/DI_clustertree.cxx

r6858	r7097
11	11
12	12	#include "di_clustertree.hxx"
13		#include <a~~w_status.hxx~~>
	13	#include <arb_progress.h>
14	14	#include <set>
15	15	#include <cmath>
…	…
77	77	#endif // DEBUG
78	78
79		aw_status_counter cluster_progress(root->get_cluster_count());
80		aw_openstatus("Searching clusters");
81		aw_status(0.0);
	79	arb_progress cluster_progress(root->get_cluster_count());
	80	cluster_progress.auto_subtitles("Cluster");
82	81
83	82	GB_ERROR error = NULL;
…	…
118	117	}
119	118
120		~~aw_closestatus();~~
121
122	119	return error;
123	120	}
…	…
182	179	}
183	180
184		void ClusterTree::detect_clusters(a~~w_status_counter~~& progress) {
	181	void ClusterTree::detect_clusters(arb_progress& progress) {
185	182	if (state == CS_MAYBE_CLUSTER) {
186	183	cl_assert(!is_leaf);
…	…
272	269
273	270	progress.inc();
274		if (progress.aborted~~_by_user~~()) throw "aborted on userrequest";
	271	if (progress.aborted()) throw "aborted on userrequest";
275	272	}
276	273

branches/refactor/DIST/DI_main.cxx

r6858	r7097
18	18	#include <aw_root.hxx>
19	19	#include <aw_msg.hxx>
20		~~#include <aw_status.hxx>~~
21	20	#include <arbdb.h>
22	21

branches/refactor/DIST/DI_matr.cxx

r6858	r7097
32	32	#include <aw_file.hxx>
33	33	#include <aw_msg.hxx>
34		#include <a~~w_status.hxx~~>
	34	#include <arb_progress.h>
35	35	#include <aw_root.hxx>
36	36
…	…
64	64	AP_matrix DI_dna_matrix(AP_MAX);
65	65
66		static void delete_matrix_cb(AW_root *~~dummy~~)
	66	static void delete_matrix_cb(AW_root *)
67	67	{
68	68	delete DI_MATRIX::ROOT;
…	…
282	282	}
283	283	else {
284		species_in_sort_tree = GBT_get_names_of_species_in_tree(sort_tree);
	284	species_in_sort_tree = GBT_get_names_of_species_in_tree(sort_tree, NULL);
285	285
286	286	{
…	…
461	461	return "There are no species selected";
462	462	}
463		long row, col, pos, s_len;
464
465		const unsigned char seq1, seq2;
466		s_len = aliview->get_length();
	463
	464	arb_progress progress("rates", (nentries*(nentries+1))/2);
	465	GB_ERROR error = NULL;
	466
	467	long s_len = aliview->get_length();
	468
467	469	this->clear(hrates);
468	470	this->clear(nrates);
469	471	this->clear(pairs);
470		for (row = 0; row<nentries; row++) {
471		double gauge = (double)row/(double)nentries;
472		if (aw_status(gauge*gauge)) return "Aborted by user";
473		for (col=0; col<row; col++) {
474		seq1 = entries[row]->sequence_parsimony->get_usequence();
475		seq2 = entries[col]->sequence_parsimony->get_usequence();
476		for (pos = 0; pos < s_len; pos++) {
	472
	473	for (long row = 0; row<nentries && !error; row++) {
	474	for (long col=0; col<row; col++) {
	475	const unsigned char *seq1 = entries[row]->sequence_parsimony->get_usequence();
	476	const unsigned char *seq2 = entries[col]->sequence_parsimony->get_usequence();
	477	for (long pos = 0; pos < s_len; pos++) {
477	478	if (filter[pos]>=0) {
478	479	hrates[seq1][seq2]++;
…	…
483	484	seq1++; seq2++;
484	485	}
485		}
486		}
487		for (row = 0; row<nentries; row++) {
488		seq1 = entries[row]->sequence_parsimony->get_usequence();
489		for (pos = 0; pos < s_len; pos++) {
	486	progress.inc_and_check_user_abort(error);
	487	}
	488	}
	489	for (long row = 0; row<nentries; row++) {
	490	const unsigned char *seq1 = entries[row]->sequence_parsimony->get_usequence();
	491	for (long pos = 0; pos < s_len; pos++) {
490	492	if (filter[pos]>=0) {
491	493	pairs[seq1[pos]][seq1[filter[pos]]]++;
…	…
493	495	}
494	496	}
495		return 0;
	497	return error;
496	498	}
497	499
…	…
511	513	}
512	514	else {
513		aw_openstatus("Calculating Distance Matrix");
514		aw_status("Calculating global rate matrix");
	515	arb_progress progress("Calculating distance matrix");
515	516
516	517	fprintf(out, "Pairs in helical regions:\n");
…	…
538	539	for (pos = 0; pos<MAXDISTDEBUG; pos++) distdebug[pos] = 0.0;
539	540
540		for (row = 0; row<nentries; row++) {
541		if (nentries > 100 \|\| ((row&0xf) == 0)) {
542		double gauge = (double)row/(double)nentries;
543		if (aw_status(gauge*gauge)) {
544		error = "Aborted by user";
545		break;
546		}
547		}
	541	arb_progress dist_progress("distance", (nentries*(nentries+1))/2);
	542	for (row = 0; row<nentries && !error; row++) {
548	543	fprintf (out, "\n%s ", entries[row]->name);
549	544
550		for (col=0; col<row; col++) {
	545	for (col=0; col<row && !error; col++) {
551	546	const unsigned char seq1, seq2;
552	547
…	…
581	576	distdebug[dist*MAXDISTDEBUG/all] = (double)hdist/(double)hall2;
582	577	}
	578	dist_progress.inc_and_check_user_abort(error);
583	579	}
584	580	}
…	…
596	592	}
597	593
598		~~aw_closestatus();~~
599	594	fclose(out);
600	595	}
…	…
693	688	};
694	689
695		for (row = 0; row<nentries; row++) {
696		if (nentries > 100 \|\| ((row&0xf) == 0)) {
697		double gauge = (double)row/(double)nentries;
698		if (aw_status(gauge*gauge)) {
699		aw_closestatus();
700		if (aborted_flag) *aborted_flag = true;
701		return "Aborted by user";
702		}
703		}
704		for (col=0; col<=row; col++) {
	690	arb_progress progress("Calculating distance matrix", (nentries*(nentries+1))/2);
	691	GB_ERROR error = NULL;
	692	for (row = 0; row<nentries && !error; row++) {
	693	for (col=0; col<=row && !error; col++) {
705	694	columns = 0;
706	695
…	…
846	835	default:;
847	836	} /* switch */
848		}
849		}
850		return 0;
	837	progress.inc_and_check_user_abort(error);
	838	}
	839	}
	840	if (aborted_flag && progress.aborted()) *aborted_flag = true;
	841	return error;
851	842	}
852	843
…	…
902	893	return "Error";
903	894	}
904		if (!bootstrap_flag) {
905		aw_openstatus("Calculating Matrix");
906		aw_status("Read the database");
907		}
908
	895	arb_progress progress("Calculating matrix");
	896
909	897	char *cancel = aw_root->awar(AWAR_DIST_CANCEL_CHARS)->read_string();
910	898
…	…
925	913	GB_pop_transaction(GLOBAL_gb_main);
926	914	bool aborted = false;
927		if (~~aw_status~~()) {
	915	if (progress.aborted()) {
928	916	phm->unload();
929	917	error = "Aborted by user";
…	…
936	924	else error = phm->calculate(aw_root, cancel, 0.0, trans, &aborted);
937	925	}
938		~~if (!bootstrap_flag) aw_closestatus();~~
939	926	delete DI_MATRIX::ROOT;
940	927
…	…
998	985
999	986	if (!error) {
1000		~~aw_openstatus("Mark species by distance");~~
1001		~~aw_status("Calculating distances");~~
1002		~~aw_status(0.0);~~
1003
1004	987	DI_MATRIX *old_root = DI_MATRIX::ROOT;
1005	988	DI_MATRIX::ROOT = 0;
1006	989
1007		size_t speciesCount = GBT_get_species_count(GLOBAL_gb_main);
1008		size_t count = 0;
1009		bool markedSelected = false;
	990	size_t speciesCount = GBT_get_species_count(GLOBAL_gb_main);
	991	bool markedSelected = false;
	992
	993	arb_progress progress("Mark species by distance", speciesCount);
1010	994
1011	995	for (GBDATA *gb_species = GBT_first_species(GLOBAL_gb_main);
…	…
1039	1023
1040	1024	delete phm;
1041		~~aw_status(++count/(double)speciesCount~~);
	1025	progress.inc_and_check_user_abort(error);
1042	1026	}
1043	1027
1044	1028	di_assert(DI_MATRIX::ROOT == 0);
1045	1029	DI_MATRIX::ROOT = old_root;
1046
1047		~~aw_closestatus();~~
1048	1030	}
1049	1031
…	…
1176	1158	};
1177	1159
1178		~~static int di_calculate_tree_show_status(int loop_count, int bootstrap_count) {~~
1179		~~// returns value of aw_status()~~
1180		~~int result = 0;~~
1181		~~if (bootstrap_count) {~~
1182		~~result = aw_status(GBS_global_string("Tree #%i of %i", loop_count, bootstrap_count));~~
1183		~~if (!result) result = aw_status(loop_count/double(bootstrap_count));~~
1184		}
1185		~~else {~~
1186		~~result = aw_status(GBS_global_string("Tree #%i of %u", loop_count, UINT_MAX));~~
1187		~~if (!result) result = aw_status(loop_count/double(UINT_MAX));~~
1188		}
1189		~~return result;~~
1190		}
1191
1192	1160	static void di_calculate_tree_cb(AW_window *aww, AW_CL cl_weightedFilter, AW_CL bootstrap_flag)
1193	1161	{
…	…
1197	1165	char **all_names = 0;
1198	1166	int loop_count = 0;
1199		~~bool close_stat = false;~~
1200	1167	int bootstrap_count = aw_root->awar(AWAR_DIST_BOOTSTRAP_COUNT)->read_int();
1201	1168
…	…
1206	1173	}
1207	1174
1208		~~int starttime = time(0);~~
1209		~~int trees_per_second = -1;~~
1210		~~int last_status_upd = 0;~~
1211
1212	1175	WeightedFilter weighted_filter = (WeightedFilter)cl_weightedFilter;
	1176
	1177	SmartPtr<arb_progress> progress;
1213	1178
1214	1179	if (!error) {
1215	1180	{
1216		~~const char *stat_msg = 0;~~
1217	1181	if (bootstrap_flag) {
1218		if (bootstrap_count) stat_msg = "Calculating bootstrap trees";
1219		else stat_msg = "Calculating bootstrap trees (KILL to stop)";
1220		}
1221		else stat_msg = "Calculating tree";
1222
1223		aw_openstatus(stat_msg);
1224		close_stat = true;
	1182	if (bootstrap_count) {
	1183	progress = new arb_progress("Calculating bootstrap trees", bootstrap_count);
	1184	}
	1185	else {
	1186	progress = new arb_progress("Calculating bootstrap trees (KILL to stop)", INT_MAX);
	1187	}
	1188	progress->auto_subtitles("tree");
	1189	}
	1190	else {
	1191	progress = new arb_progress("Calculating tree");
	1192	}
1225	1193	}
1226	1194
1227	1195	if (bootstrap_flag) {
1228		~~loop_count++;~~
1229		~~di_calculate_tree_show_status(loop_count, bootstrap_count);~~
1230
1231	1196	di_assert(DI_MATRIX::ROOT == 0);
1232	1197
…	…
1245	1210	}
1246	1211	}
	1212	loop_count++;
	1213	progress->inc();
1247	1214	}
1248	1215	}
…	…
1250	1217	do {
1251	1218	if (error) break;
1252
1253		~~if (bootstrap_flag) {~~
1254		~~bool show_update = true;~~
1255		~~if (trees_per_second == -1) {~~
1256		~~int timediff = time(0)-starttime;~~
1257		~~if (timediff>10) {~~
1258		~~trees_per_second = loop_count/timediff;~~
1259		}
1260		}
1261		~~else {~~
1262		~~if ((loop_count-last_status_upd)*4 < trees_per_second) {~~
1263		~~show_update = false; // do not update more often than 4 times a second~~
1264		}
1265		}
1266
1267		~~loop_count++;~~
1268		~~if (show_update) { // max. once per second~~
1269		~~if (di_calculate_tree_show_status(loop_count, bootstrap_count)) {~~
1270		~~break; // user abort~~
1271		}
1272		~~last_status_upd = loop_count;~~
1273		}
1274
1275		}
1276	1219
1277	1220	delete DI_MATRIX::ROOT;
…	…
1300	1243	insert_ctree(tree, 1);
1301	1244	GBT_delete_tree(tree); tree = 0;
	1245	loop_count++;
	1246	progress->inc();
	1247	if (!bootstrap_count) {
	1248	int t = time(0);
	1249	static int tlast = 0;
	1250
	1251	if (t>tlast) {
	1252	progress->force_update();
	1253	tlast = t;
	1254	}
	1255	}
1302	1256	}
1303	1257	free(names);
1304
1305	1258	} while (bootstrap_flag && loop_count != bootstrap_count);
1306	1259
…	…
1327	1280	if (tree) GBT_delete_tree(tree);
1328	1281
1329		if (close_stat) aw_closestatus();
1330		aw_status(); // remove 'abort' flag
	1282	// aw_status(); // remove 'abort' flag (@@@ got no equiv for arb_progress yet. really needed?)
1331	1283
1332	1284	if (bootstrap_flag) {
…	…
1342	1294
1343	1295	if (error) aw_message(error);
	1296	progress->done();
1344	1297	}
1345	1298
…	…
1353	1306	}
1354	1307	AW_root *aw_root = aww->get_root();
1355		char *use = aw_root->awar(AWAR_DIST_ALIGNMENT)->read_string();
1356		long ali_len = GBT_get_alignment_len(GLOBAL_gb_main, use);
	1308	char *use = aw_root->awar(AWAR_DIST_ALIGNMENT)->read_string();
	1309	long ali_len = GBT_get_alignment_len(GLOBAL_gb_main, use);
	1310
1357	1311	if (ali_len<=0) {
1358	1312	GB_pop_transaction(GLOBAL_gb_main);
…	…
1362	1316	}
1363	1317
1364		aw_openstatus("Analyzing data...");
1365		aw_status("Read the database");
1366
1367		char *filter_str = aw_root->awar(AWAR_DIST_FILTER_FILTER)->read_string();
1368		char *cancel = aw_root->awar(AWAR_DIST_CANCEL_CHARS)->read_string();
	1318	arb_progress progress("Analyzing data");
	1319
	1320	char *filter_str = aw_root->awar(AWAR_DIST_FILTER_FILTER)->read_string();
	1321	char *cancel = aw_root->awar(AWAR_DIST_CANCEL_CHARS)->read_string();
1369	1322
1370	1323	AliView *aliview;
…	…
1406	1359	GB_pop_transaction(GLOBAL_gb_main);
1407	1360
1408		~~aw_status~~("Search Correction");
	1361	progress.subtitle("Search Correction");
1409	1362
1410	1363	DI_TRANSFORMATION trans;
…	…
1412	1365
1413	1366	phm->analyse();
1414		~~aw_closestatus();~~
1415
1416	1367	delete phm;
1417	1368

branches/refactor/DIST/DI_mldist.cxx

r6858	r7097
14	14	#include <AP_seq_simple_pro.hxx>
15	15	#include <aw_msg.hxx>
16		#include <a~~w_status.hxx~~>
	16	#include <arb_progress.h>
17	17
18	18	#include <cmath>
…	…
212	212	}
213	213
214		const char di_mldist::makedists(bool aborted_flag)
	214	GB_ERROR di_mldist::makedists(bool *aborted_flag)
215	215	{
216	216	/* compute the distances */
217		long i, j, k, iterations;
218		double delta, slope, curv;
219		int b1=0, b2=0;
220		double tt=0;
221		int pos;
	217	long i, j, k, iterations;
	218	double delta, slope, curv;
	219	int b1 = 0, b2=0;
	220	double tt = 0;
	221	int pos;
	222
	223	arb_progress progress("Calculating distances", (spp*(spp+1))/2);
	224	GB_ERROR error = NULL;
222	225
223	226	for (i = 0; i < spp; i++) {
224	227	matrix->set(i, i, 0.0);
225		{
226		~~double gauge = (double)i/(double)spp;~~
227		~~if (aw_status(gauge*gauge)) {~~
228		~~if (aborted_flag) *aborted_flag = true;~~
229		~~return "Aborted by user";~~
230		}
231		}
232	228	{
233	229	/* move all unknown characters to del */
…	…
293	289	}
294	290	} while (iterations < 20);
	291
	292	progress.inc_and_check_user_abort(error);
295	293	}
296	294	matrix->set(i, j, fracchange * tt);
297	295	}
298		return 0;
	296
	297	if (aborted_flag && error) *aborted_flag = true;
	298	return error;
299	299	}
300	300

branches/refactor/DIST/DI_protdist.cxx

r6858	r7097
12	12	#include "di_matr.hxx"
13	13	#include <aw_msg.hxx>
14		#include <a~~w_status.hxx~~>
	14	#include <arb_progress.h>
15	15	#include <cmath>
16	16
…	…
657	657	}
658	658
659		const char di_protdist::makedists(bool aborted_flag) {
	659	GB_ERROR di_protdist::makedists(bool *aborted_flag) {
660	660	/* compute the distances.
661	661	* sets 'aborted_flag' to true, if it is non-NULL and user aborts the calculation
662	662	*/
663		long i, j, k, m, n, iterations;
664		double delta, slope, curv;
665		int b1=0, b2=0;
666		double tt=0;
667		int pos;
	663	long i, j, k, m, n, iterations;
	664	double delta, slope, curv;
	665	int b1 = 0, b2=0;
	666	double tt = 0;
	667	int pos;
	668
	669	arb_progress progress("Calculating distances", (spp*(spp+1))/2);
	670	GB_ERROR error = NULL;
668	671
669	672	for (i = 0; i < spp; i++) {
670	673	matrix->set(i, i, 0.0);
671		{
672		~~double gauge = (double)i/(double)spp;~~
673		~~if (aw_status(gauge*gauge)) {~~
674		~~if (aborted_flag) *aborted_flag = true;~~
675		~~return "Aborted by user";~~
676		}
677		}
678	674	{
679	675	/* move all unknown characters to del */
…	…
788	784	}
789	785	matrix->set(i, j, fracchange * tt);
790		}
791		}
792		return 0;
	786	progress.inc_and_check_user_abort(error);
	787	}
	788	}
	789	if (aborted_flag && error) *aborted_flag = true;
	790	return error;
793	791	}
794	792

branches/refactor/DIST/Makefile

r7089	r7097
56	56	DI_clusters.o: $(ARBHOME)/INCLUDE/arb_error.h
57	57	DI_clusters.o: $(ARBHOME)/INCLUDE/arb_msg.h
	58	DI_clusters.o: $(ARBHOME)/INCLUDE/arb_progress.h
58	59	DI_clusters.o: $(ARBHOME)/INCLUDE/arb_string.h
59	60	DI_clusters.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
69	70	DI_clusters.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
70	71	DI_clusters.o: $(ARBHOME)/INCLUDE/aw_root.hxx
71		~~DI_clusters.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
72	72	DI_clusters.o: $(ARBHOME)/INCLUDE/aw_window.hxx
73	73	DI_clusters.o: $(ARBHOME)/INCLUDE/awt_sel_boxes.hxx
…	…
88	88	DI_clustertree.o: $(ARBHOME)/INCLUDE/arb_error.h
89	89	DI_clustertree.o: $(ARBHOME)/INCLUDE/arb_msg.h
	90	DI_clustertree.o: $(ARBHOME)/INCLUDE/arb_progress.h
90	91	DI_clustertree.o: $(ARBHOME)/INCLUDE/arb_string.h
91	92	DI_clustertree.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
95	96	DI_clustertree.o: $(ARBHOME)/INCLUDE/arbtools.h
96	97	DI_clustertree.o: $(ARBHOME)/INCLUDE/attributes.h
97		~~DI_clustertree.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
98	98	DI_clustertree.o: $(ARBHOME)/INCLUDE/downcast.h
99	99	DI_clustertree.o: $(ARBHOME)/INCLUDE/dupstr.h
…	…
170	170	DI_main.o: $(ARBHOME)/INCLUDE/aw_preset.hxx
171	171	DI_main.o: $(ARBHOME)/INCLUDE/aw_root.hxx
172		~~DI_main.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
173	172	DI_main.o: $(ARBHOME)/INCLUDE/aw_window.hxx
174	173	DI_main.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
200	199	DI_matr.o: $(ARBHOME)/INCLUDE/arb_error.h
201	200	DI_matr.o: $(ARBHOME)/INCLUDE/arb_msg.h
	201	DI_matr.o: $(ARBHOME)/INCLUDE/arb_progress.h
202	202	DI_matr.o: $(ARBHOME)/INCLUDE/arb_string.h
203	203	DI_matr.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
216	216	DI_matr.o: $(ARBHOME)/INCLUDE/aw_preset.hxx
217	217	DI_matr.o: $(ARBHOME)/INCLUDE/aw_root.hxx
218		~~DI_matr.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
219	218	DI_matr.o: $(ARBHOME)/INCLUDE/aw_window.hxx
220	219	DI_matr.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
247	246	DI_mldist.o: $(ARBHOME)/INCLUDE/arb_error.h
248	247	DI_mldist.o: $(ARBHOME)/INCLUDE/arb_msg.h
	248	DI_mldist.o: $(ARBHOME)/INCLUDE/arb_progress.h
249	249	DI_mldist.o: $(ARBHOME)/INCLUDE/arb_string.h
250	250	DI_mldist.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
257	257	DI_mldist.o: $(ARBHOME)/INCLUDE/aw_color_groups.hxx
258	258	DI_mldist.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
259		~~DI_mldist.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
260	259	DI_mldist.o: $(ARBHOME)/INCLUDE/downcast.h
261	260	DI_mldist.o: $(ARBHOME)/INCLUDE/dupstr.h
…	…
277	276	DI_protdist.o: $(ARBHOME)/INCLUDE/arb_error.h
278	277	DI_protdist.o: $(ARBHOME)/INCLUDE/arb_msg.h
	278	DI_protdist.o: $(ARBHOME)/INCLUDE/arb_progress.h
279	279	DI_protdist.o: $(ARBHOME)/INCLUDE/arb_string.h
280	280	DI_protdist.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
287	287	DI_protdist.o: $(ARBHOME)/INCLUDE/aw_color_groups.hxx
288	288	DI_protdist.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
289		~~DI_protdist.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
290	289	DI_protdist.o: $(ARBHOME)/INCLUDE/downcast.h
291	290	DI_protdist.o: $(ARBHOME)/INCLUDE/dupstr.h

branches/refactor/DIST/di_clustertree.hxx

r7006	r7097
35	35	class AP_sequence;
36	36	class ClusterTree;
37		class a~~w_status_counter~~;
	37	class arb_progress;
38	38
39	39	enum ClusterState {
…	…
182	182
183	183	void init_tree();
184		void detect_clusters(a~~w_status_counter~~& progress);
	184	void detect_clusters(arb_progress& progress);
185	185
186	186	const NodeValues *get_branch_depths() {

branches/refactor/DIST/di_mldist.hxx

r6509	r7097
11	11	#ifndef DI_MLDIST_HXX
12	12	#define DI_MLDIST_HXX
	13
	14	#ifndef ARB_CORE_H
	15	#include <arb_core.h>
	16	#endif
13	17
14	18	const int DI_ML_RESOLUTION = 1000; // max res
…	…
76	80	~di_mldist();
77	81
78		const char makedists(bool aborted_flag); // calculate the distance matrix
	82	GB_ERROR makedists(bool *aborted_flag); // calculate the distance matrix
79	83	};
80	84

branches/refactor/DIST/di_protdist.hxx

r6509	r7097
101	101	~di_protdist();
102	102
103		const char makedists(bool aborted_flag); // calculate the distance matrix
	103	GB_ERROR makedists(bool *aborted_flag); // calculate the distance matrix
104	104	};
105	105

branches/refactor/EDIT4/ED4_base.cxx

r6858	r7097
3	3	#include <aw_awar.hxx>
4	4	#include <aw_msg.hxx>
5		#include <a~~w_status.hxx~~>
	5	#include <arb_progress.h>
6	6	#include <aw_root.hxx>
7	7
…	…
916	916	}
917	917
918		void ED4_manager::create_consensus(ED4_group_manager upper_group_manager, a~~w_status_counter~~ progress) {
	918	void ED4_manager::create_consensus(ED4_group_manager upper_group_manager, arb_progress progress) {
919	919	// creates consensus
920	920	// is called by group manager
…	…
928	928	group_manager_for_child = group_manager;
929	929
930		if (progress) {
931		progress->inc();
932		if (progress->aborted_by_user()) ED4_exit();
933		}
	930	if (progress) progress->inc();
934	931	}
935	932	int i;
…	…
947	944	e4_assert(!group_manager_for_child->table().empty());
948	945	free(db_pointer);
	946
	947	if (progress) progress->inc();
949	948	}
950	949	}

branches/refactor/EDIT4/ED4_cursor.cxx

r6858	r7097
6	6	#include <AW_helix.hxx>
7	7	#include <aw_msg.hxx>
8		#include <a~~w_status.hxx~~>
	8	#include <arb_progress.h>
9	9	#include <aw_root.hxx>
10	10
…	…
600	600	void ED4_finish_and_show_notFoundMessage() {
601	601	if (not_found_counter != 0) {
602		GBS_strcat(not_found_message, GBS_global_string("(skipped display of %zu more species)\n", not_found_counter-MAX_SHOWN_MISSING_SPECIES));
	602	if (not_found_counter>MAX_SHOWN_MISSING_SPECIES) {
	603	GBS_strcat(not_found_message, GBS_global_string("(skipped display of %zu more species)\n", not_found_counter-MAX_SHOWN_MISSING_SPECIES));
	604	}
603	605	char *out_message = GBS_strclose(not_found_message);
604	606	aw_message(out_message);
…	…
695	697
696	698	if (marked) {
697		GBDATA *gb_species = GBT_first_marked_species(GLOBAL_gb_main);
698		~~int count = 0~~;
699		char *buffer = new char[BUFFERSIZE+1];
700		char *bp = buffer;
	699	GBDATA *gb_species = GBT_first_marked_species(GLOBAL_gb_main);
	700	char *buffer = new char[BUFFERSIZE+1];
	701	char *bp = buffer;
	702
701	703	ED4_multi_species_manager *insert_into_manager = ED4_new_species_multi_species_manager();
702	704	ED4_group_manager *group_man = insert_into_manager->get_parent(ED4_L_GROUP)->to_group_manager();
703		int group_depth = insert_into_manager->calc_group_depth();
704		int ~~index = 0~~;
705		~~ED4_index y~~ = 0;
706		ED4_index ~~lot~~ = 0;
707		~~int inserted~~ = 0;
708		~~char *default_alignment = GBT_get_default_alignment(GLOBAL_gb_main)~~;
709
710		aw_openstatus("ARB_EDIT4");
711		a~~w_status("Loading species..."~~);
	705
	706	int group_depth = insert_into_manager->calc_group_depth();
	707	int index = 0;
	708	ED4_index y = 0;
	709	ED4_index lot = 0;
	710	int inserted = 0;
	711	char *default_alignment = GBT_get_default_alignment(GLOBAL_gb_main);
	712
	713	arb_progress progress("Loading species", marked);
712	714
713	715	ED4_init_notFoundMessage();
714	716
715	717	while (gb_species) {
716		~~count++;~~
717		~~GB_status(double(count)/double(marked));~~
718
719	718	const char *name = GBT_read_name(gb_species);
720	719	ED4_species_name_terminal *name_term = ED4_find_species_name_terminal(name);
…	…
753	752	}
754	753	gb_species = GBT_next_marked_species(gb_species);
	754	progress.inc();
755	755	}
756	756
…	…
762	762	}
763	763
764		~~aw_closestatus();~~
765	764	aw_message(GBS_global_string("Loaded %i of %i marked species.", inserted, marked));
766	765

branches/refactor/EDIT4/ED4_main.cxx

r6858	r7097
33	33	#include <aw_awars.hxx>
34	34	#include <aw_msg.hxx>
35		~~#include <aw_status.hxx>~~
36	35	#include <aw_root.hxx>
37	36	#include <arbdbt.h>

branches/refactor/EDIT4/ED4_no_class.cxx

r6861	r7097
27	27	#include <aw_awars.hxx>
28	28	#include <aw_msg.hxx>
29		#include <a~~w_status.hxx~~>
	29	#include <arb_progress.h>
30	30	#include <aw_root.hxx>
31	31
…	…
1870	1870	}
1871	1871	else {
1872		error = AWTC_generate_one_name(GLOBAL_gb_main, new_species_full_name, acc, addid, new_species_name~~, true, true~~);
	1872	error = AWTC_generate_one_name(GLOBAL_gb_main, new_species_full_name, acc, addid, new_species_name);
1873	1873	if (!error) { // name was created
1874	1874	if (!nameIsUnique(new_species_name, gb_species_data)) {
…	…
1923	1923	SpeciesMergeList sml = 0; // list of species in group
1924	1924
1925		~~aw_openstatus("Merging fields");~~
1926
1927	1925	error = group_man->route_down_hierarchy(add_species_to_merge_list, (AW_CL)&sml, (AW_CL)gb_species_data);
1928	1926	if (!error && !sml) {
…	…
1944	1942	SpeciesMergeList sl = sml;
1945	1943	int sl_length = SpeciesMergeListLength(sml);
1946		int *fieldStat = new int[sl_length]; // 0 = not used yet ; -1 = don't has field ; 1..n = field content, same number means same content
	1944	int *fieldStat = new int[sl_length]; // 0 = not used yet ; -1 = don't has field ; 1..n = field content, same number means same content
	1945
	1946	arb_progress progress("Merging fields", sl_length);
1947	1947
1948	1948	while (sl && !error) { // with all species do..
…	…
1964	1964	fieldEnd[0] = 0;
1965	1965
1966		~~aw_status(fieldName);~~
1967	1966	GBDATA *gb_field = GB_search(sl->species, fieldName, GB_FIND);
1968	1967	e4_assert(gb_field); // field has to exist, cause it was found before
…	…
2112	2111	free(newFields);
2113	2112	sl = sl->next;
2114		~~if (aw_status() == 1) error = "Aborted by user"~~;
	2113	progress.inc_and_check_user_abort(error);
2115	2114	}
2116	2115	free(doneFields);
…	…
2118	2117	}
2119	2118	freeSpeciesMergeList(sml); sml = 0;
2120		~~aw_closestatus();~~
2121	2119	}
2122	2120	}

branches/refactor/EDIT4/ED4_root.cxx

r6858	r7097
33	33	#include <aw_preset.hxx>
34	34	#include <aw_msg.hxx>
35		#include <a~~w_status.hxx~~>
	35	#include <arb_progress.h>
36	36	#include <aw_root.hxx>
37	37	#include <arb_version.h>
…	…
439	439	total_no_of_species += species_count;
440	440
441		a~~w_status_counter species_progress(total_no_of_species~~);
	441	arb_progress startup_progress("EDIT4 startup");
442	442
443	443	GB_push_transaction(GLOBAL_gb_main);
…	…
486	486
487	487	{
488		ED4_area_manager *top_area_manager = new ED4_area_manager("Top_Area_Manager", 0, y, 0, 0, device_manager);
489		device_manager->children->append_member(top_area_manager);
490		top_area_man = top_area_manager;
491
492		top_spacer_terminal = new ED4_spacer_terminal("Top_Spacer", 0, 0, 100, 10, top_area_manager);
493		top_area_manager->children->append_member(top_spacer_terminal);
494
495		top_multi_species_manager = new ED4_multi_species_manager("Top_MultiSpecies_Manager", x, 0, 0, 0, top_area_manager);
496		top_area_manager->children->append_member(top_multi_species_manager);
497
498		top_multi_spacer_terminal_beg = new ED4_spacer_terminal("Top_Multi_Spacer_Terminal_Beg", 0, 0, 0, 3, top_multi_species_manager);
499		top_multi_species_manager->children->append_member(top_multi_spacer_terminal_beg);
500
501		y+=3;
502
503
504		aw_openstatus("Reading species from database");
505		aw_status((double)0);
506
507		reference = new AWT_reference(GLOBAL_gb_main);
508		database->scan_string(top_multi_species_manager, ref_terminals.get_ref_sequence_info(), ref_terminals.get_ref_sequence(),
509		area_string_top, &index, &y, species_progress);
510		GB_pop_transaction(GLOBAL_gb_main);
511
512		const int TOP_MID_LINE_HEIGHT = 3;
513		int TOP_MID_SPACER_HEIGHT = font_group.get_max_height()-TOP_MID_LINE_HEIGHT;
514
515		top_mid_line_terminal = new ED4_line_terminal("Top_Mid_Line_Terminal", 0, y, 0, TOP_MID_LINE_HEIGHT, device_manager); // width will be set below
516		device_manager->children->append_member(top_mid_line_terminal);
517
518		y += TOP_MID_LINE_HEIGHT;
519
520
521		top_mid_spacer_terminal = new ED4_spacer_terminal("Top_Middle_Spacer", 0, y, 880, TOP_MID_SPACER_HEIGHT, device_manager);
522		device_manager->children->append_member(top_mid_spacer_terminal);
523
524		// needed to avoid text-clipping problems:
525		main_manager->set_top_middle_spacer_terminal(top_mid_spacer_terminal);
526		main_manager->set_top_middle_line_terminal(top_mid_line_terminal);
527
528		y += TOP_MID_SPACER_HEIGHT; // add top-mid_spacer_terminal height
529
530		top_multi_species_manager->generate_id_for_groups();
531		}
532
533		// ******** Top Area end ********
534
535
536		// ******** Middle Area beginning ********
537
538		{
539		middle_area_manager = new ED4_area_manager("Middle_Area_Manager", 0, y, 0, 0, device_manager);
540		device_manager->children->append_member(middle_area_manager);
541		middle_area_man = middle_area_manager;
542
543		tree_terminal = new ED4_tree_terminal("Tree", 0, 0, 2, change, middle_area_manager);
544		middle_area_manager->children->append_member(tree_terminal);
545
546		mid_multi_species_manager = new ED4_multi_species_manager("Middle_MultiSpecies_Manager", x, 0, 0, 0, middle_area_manager);
547		middle_area_manager->children->append_member(mid_multi_species_manager);
548
549		mid_multi_spacer_terminal_beg = new ED4_spacer_terminal("Mid_Multi_Spacer_Terminal_Beg", 0, 0, 0, 3, mid_multi_species_manager);
550		mid_multi_species_manager->children->append_member(mid_multi_spacer_terminal_beg);
551
552		y+=3; // dummy height, to create a dummy layout ( to preserve order of objects )
553
554		scroll_links.link_for_ver_slider = middle_area_manager;
555
556		help = y;
557		index = 0;
	488	arb_progress species_progress("Loading species", total_no_of_species);
558	489	{
559		GB_transaction dummy(GLOBAL_gb_main);
560		database->scan_string(mid_multi_species_manager, ref_terminals.get_ref_sequence_info(), ref_terminals.get_ref_sequence(),
561		area_string_middle, &index, &y, species_progress);
562		}
563
564		aw_closestatus();
	490	ED4_area_manager *top_area_manager = new ED4_area_manager("Top_Area_Manager", 0, y, 0, 0, device_manager);
	491	device_manager->children->append_member(top_area_manager);
	492	top_area_man = top_area_manager;
	493
	494	top_spacer_terminal = new ED4_spacer_terminal("Top_Spacer", 0, 0, 100, 10, top_area_manager);
	495	top_area_manager->children->append_member(top_spacer_terminal);
	496
	497	top_multi_species_manager = new ED4_multi_species_manager("Top_MultiSpecies_Manager", x, 0, 0, 0, top_area_manager);
	498	top_area_manager->children->append_member(top_multi_species_manager);
	499
	500	top_multi_spacer_terminal_beg = new ED4_spacer_terminal("Top_Multi_Spacer_Terminal_Beg", 0, 0, 0, 3, top_multi_species_manager);
	501	top_multi_species_manager->children->append_member(top_multi_spacer_terminal_beg);
	502
	503	y+=3;
	504
	505	reference = new AWT_reference(GLOBAL_gb_main);
	506	database->scan_string(top_multi_species_manager, ref_terminals.get_ref_sequence_info(), ref_terminals.get_ref_sequence(),
	507	area_string_top, &index, &y, species_progress);
	508	GB_pop_transaction(GLOBAL_gb_main);
	509
	510	const int TOP_MID_LINE_HEIGHT = 3;
	511	int TOP_MID_SPACER_HEIGHT = font_group.get_max_height()-TOP_MID_LINE_HEIGHT;
	512
	513	top_mid_line_terminal = new ED4_line_terminal("Top_Mid_Line_Terminal", 0, y, 0, TOP_MID_LINE_HEIGHT, device_manager); // width will be set below
	514	device_manager->children->append_member(top_mid_line_terminal);
	515
	516	y += TOP_MID_LINE_HEIGHT;
	517
	518
	519	top_mid_spacer_terminal = new ED4_spacer_terminal("Top_Middle_Spacer", 0, y, 880, TOP_MID_SPACER_HEIGHT, device_manager);
	520	device_manager->children->append_member(top_mid_spacer_terminal);
	521
	522	// needed to avoid text-clipping problems:
	523	main_manager->set_top_middle_spacer_terminal(top_mid_spacer_terminal);
	524	main_manager->set_top_middle_line_terminal(top_mid_line_terminal);
	525
	526	y += TOP_MID_SPACER_HEIGHT; // add top-mid_spacer_terminal height
	527
	528	top_multi_species_manager->generate_id_for_groups();
	529	}
	530
	531	// ******** Top Area end ********
	532
	533
	534	// ******** Middle Area beginning ********
565	535
566	536	{
567		ED4_spacer_terminal *mid_bot_spacer_terminal = new ED4_spacer_terminal("Middle_Bot_Spacer_Terminal", 0, y, 880, 10, device_manager);
568		device_manager->children->append_member(mid_bot_spacer_terminal);
569		}
570
571		tree_terminal->extension.size[HEIGHT] = y - help;
572
573		mid_multi_species_manager->generate_id_for_groups();
574		y += 10; // add top-mid_spacer_terminal height
575
576		mid_bot_line_terminal = new ED4_line_terminal("Mid_Bot_Line_Terminal", 0, y, 0, 3, device_manager); // width will be set below
577		device_manager->children->append_member(mid_bot_line_terminal);
578		y += 3;
579
580		total_bottom_spacer = new ED4_spacer_terminal("Total_Bottom_Spacer_terminal", 0, y, 0, 10000, device_manager);
581		device_manager->children->append_member(total_bottom_spacer);
582		y += 10000;
583		}
584
585		// ******** Middle Area end ********
586
587		if (scroll_links.link_for_hor_slider) {
588		long ext_width = long(scroll_links.link_for_hor_slider->extension.size[WIDTH]);
589
590		top_multi_spacer_terminal_beg->extension.size[WIDTH] = ext_width + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
591		mid_multi_spacer_terminal_beg->extension.size[WIDTH] = ext_width + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
592		total_bottom_spacer->extension.size[WIDTH] = ext_width + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
593
594		top_mid_line_terminal->extension.size[WIDTH] = ext_width + TREETERMINALSIZE + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
595		mid_bot_line_terminal->extension.size[WIDTH] = ext_width + TREETERMINALSIZE + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
596
597		}
598
599		tree_terminal->set_links(NULL, mid_multi_species_manager); // set links
600		top_spacer_terminal->set_links(tree_terminal, top_multi_species_manager);
601		top_mid_spacer_terminal->set_links(middle_area_manager, NULL);
602		total_bottom_spacer->set_links(mid_bot_line_terminal, 0);
	537	middle_area_manager = new ED4_area_manager("Middle_Area_Manager", 0, y, 0, 0, device_manager);
	538	device_manager->children->append_member(middle_area_manager);
	539	middle_area_man = middle_area_manager;
	540
	541	tree_terminal = new ED4_tree_terminal("Tree", 0, 0, 2, change, middle_area_manager);
	542	middle_area_manager->children->append_member(tree_terminal);
	543
	544	mid_multi_species_manager = new ED4_multi_species_manager("Middle_MultiSpecies_Manager", x, 0, 0, 0, middle_area_manager);
	545	middle_area_manager->children->append_member(mid_multi_species_manager);
	546
	547	mid_multi_spacer_terminal_beg = new ED4_spacer_terminal("Mid_Multi_Spacer_Terminal_Beg", 0, 0, 0, 3, mid_multi_species_manager);
	548	mid_multi_species_manager->children->append_member(mid_multi_spacer_terminal_beg);
	549
	550	y+=3; // dummy height, to create a dummy layout ( to preserve order of objects )
	551
	552	scroll_links.link_for_ver_slider = middle_area_manager;
	553
	554	help = y;
	555	index = 0;
	556	{
	557	GB_transaction dummy(GLOBAL_gb_main);
	558	database->scan_string(mid_multi_species_manager, ref_terminals.get_ref_sequence_info(), ref_terminals.get_ref_sequence(),
	559	area_string_middle, &index, &y, species_progress);
	560	}
	561
	562	{
	563	ED4_spacer_terminal *mid_bot_spacer_terminal = new ED4_spacer_terminal("Middle_Bot_Spacer_Terminal", 0, y, 880, 10, device_manager);
	564	device_manager->children->append_member(mid_bot_spacer_terminal);
	565	}
	566
	567	tree_terminal->extension.size[HEIGHT] = y - help;
	568
	569	mid_multi_species_manager->generate_id_for_groups();
	570	y += 10; // add top-mid_spacer_terminal height
	571
	572	mid_bot_line_terminal = new ED4_line_terminal("Mid_Bot_Line_Terminal", 0, y, 0, 3, device_manager); // width will be set below
	573	device_manager->children->append_member(mid_bot_line_terminal);
	574	y += 3;
	575
	576	total_bottom_spacer = new ED4_spacer_terminal("Total_Bottom_Spacer_terminal", 0, y, 0, 10000, device_manager);
	577	device_manager->children->append_member(total_bottom_spacer);
	578	y += 10000;
	579	}
	580
	581	// ******** Middle Area end ********
	582
	583	if (scroll_links.link_for_hor_slider) {
	584	long ext_width = long(scroll_links.link_for_hor_slider->extension.size[WIDTH]);
	585
	586	top_multi_spacer_terminal_beg->extension.size[WIDTH] = ext_width + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
	587	mid_multi_spacer_terminal_beg->extension.size[WIDTH] = ext_width + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
	588	total_bottom_spacer->extension.size[WIDTH] = ext_width + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
	589
	590	top_mid_line_terminal->extension.size[WIDTH] = ext_width + TREETERMINALSIZE + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
	591	mid_bot_line_terminal->extension.size[WIDTH] = ext_width + TREETERMINALSIZE + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
	592
	593	}
	594
	595	tree_terminal->set_links(NULL, mid_multi_species_manager); // set links
	596	top_spacer_terminal->set_links(tree_terminal, top_multi_species_manager);
	597	top_mid_spacer_terminal->set_links(middle_area_manager, NULL);
	598	total_bottom_spacer->set_links(mid_bot_line_terminal, 0);
	599	}
603	600	}
604	601
…	…
609	606	// build consensi
610	607	{
611		aw_openstatus("Initializing consensi");
612		aw_status((double)0);
613
614		aw_status_counter progress(total_no_of_groups+1); // 1 is root_group_man
615
616		root_group_man->create_consensus(root_group_man, &progress);
	608	arb_progress consensi_progress("Initializing consensi", total_no_of_species+total_no_of_groups+1); // 1 is root_group_man
	609
	610	root_group_man->create_consensus(root_group_man, &consensi_progress);
617	611	e4_assert(root_group_man->table().ok());
618
619		aw_closestatus();
	612	consensi_progress.done(); // if there is a "top"-group, progress increment is one to low
620	613	}
621	614

branches/refactor/EDIT4/EDB_root_bact.cxx

r6858	r7097
13	13
14	14	#include <aw_msg.hxx>
15		#include <a~~w_status.hxx~~>
	15	#include <arb_progress.h>
16	16	#include <arbdbt.h>
17	17	#include <ad_config.h>
…	…
328	328	ED4_index length_of_terminals, / height of terminals is meant */
329	329	int group_depth,
330		a~~w_status_counter~~ *progress)
	330	arb_progress *progress)
331	331	{
332	332	#define SHIPSIZE 1024
…	…
398	398	if (progress) {
399	399	progress->inc();
400		if (progress->aborted~~_by_user~~()) ED4_exit();
	400	if (progress->aborted()) ED4_exit();
401	401	}
402	402
…	…
423	423	int *index,
424	424	ED4_index *y,
425		a~~w_status_counter&~~ progress)
	425	arb_progress& progress)
426	426	{
427	427	ED4_multi_species_manager *multi_species_manager = NULL;

branches/refactor/EDIT4/Makefile

r7089	r7097
70	70	ED4_base.o: $(ARBHOME)/INCLUDE/arb_error.h
71	71	ED4_base.o: $(ARBHOME)/INCLUDE/arb_msg.h
	72	ED4_base.o: $(ARBHOME)/INCLUDE/arb_progress.h
72	73	ED4_base.o: $(ARBHOME)/INCLUDE/arb_string.h
73	74	ED4_base.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
86	87	ED4_base.o: $(ARBHOME)/INCLUDE/aw_preset.hxx
87	88	ED4_base.o: $(ARBHOME)/INCLUDE/aw_root.hxx
88		~~ED4_base.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
89	89	ED4_base.o: $(ARBHOME)/INCLUDE/aw_window.hxx
90	90	ED4_base.o: $(ARBHOME)/INCLUDE/cb.h
…	…
143	143	ED4_cursor.o: $(ARBHOME)/INCLUDE/arb_error.h
144	144	ED4_cursor.o: $(ARBHOME)/INCLUDE/arb_msg.h
	145	ED4_cursor.o: $(ARBHOME)/INCLUDE/arb_progress.h
145	146	ED4_cursor.o: $(ARBHOME)/INCLUDE/arb_string.h
146	147	ED4_cursor.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
160	161	ED4_cursor.o: $(ARBHOME)/INCLUDE/aw_position.hxx
161	162	ED4_cursor.o: $(ARBHOME)/INCLUDE/aw_root.hxx
162		~~ED4_cursor.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
163	163	ED4_cursor.o: $(ARBHOME)/INCLUDE/aw_window.hxx
164	164	ED4_cursor.o: $(ARBHOME)/INCLUDE/BI_helix.hxx
…	…
318	318	ED4_main.o: $(ARBHOME)/INCLUDE/aw_preset.hxx
319	319	ED4_main.o: $(ARBHOME)/INCLUDE/aw_root.hxx
320		~~ED4_main.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
321	320	ED4_main.o: $(ARBHOME)/INCLUDE/aw_window.hxx
322	321	ED4_main.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
494	493	ED4_no_class.o: $(ARBHOME)/INCLUDE/arb_error.h
495	494	ED4_no_class.o: $(ARBHOME)/INCLUDE/arb_msg.h
	495	ED4_no_class.o: $(ARBHOME)/INCLUDE/arb_progress.h
496	496	ED4_no_class.o: $(ARBHOME)/INCLUDE/arb_string.h
497	497	ED4_no_class.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
513	513	ED4_no_class.o: $(ARBHOME)/INCLUDE/aw_root.hxx
514	514	ED4_no_class.o: $(ARBHOME)/INCLUDE/aw_select.hxx
515		~~ED4_no_class.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
516	515	ED4_no_class.o: $(ARBHOME)/INCLUDE/aw_window.hxx
517	516	ED4_no_class.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
649	648	ED4_root.o: $(ARBHOME)/INCLUDE/arb_error.h
650	649	ED4_root.o: $(ARBHOME)/INCLUDE/arb_msg.h
	650	ED4_root.o: $(ARBHOME)/INCLUDE/arb_progress.h
651	651	ED4_root.o: $(ARBHOME)/INCLUDE/arb_string.h
652	652	ED4_root.o: $(ARBHOME)/INCLUDE/arb_version.h
…	…
668	668	ED4_root.o: $(ARBHOME)/INCLUDE/aw_preset.hxx
669	669	ED4_root.o: $(ARBHOME)/INCLUDE/aw_root.hxx
670		~~ED4_root.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
671	670	ED4_root.o: $(ARBHOME)/INCLUDE/aw_window.hxx
672	671	ED4_root.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
909	908	EDB_root_bact.o: $(ARBHOME)/INCLUDE/arb_error.h
910	909	EDB_root_bact.o: $(ARBHOME)/INCLUDE/arb_msg.h
	910	EDB_root_bact.o: $(ARBHOME)/INCLUDE/arb_progress.h
911	911	EDB_root_bact.o: $(ARBHOME)/INCLUDE/arb_string.h
912	912	EDB_root_bact.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
922	922	EDB_root_bact.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
923	923	EDB_root_bact.o: $(ARBHOME)/INCLUDE/aw_position.hxx
924		~~EDB_root_bact.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
925	924	EDB_root_bact.o: $(ARBHOME)/INCLUDE/aw_window.hxx
926	925	EDB_root_bact.o: $(ARBHOME)/INCLUDE/dupstr.h

branches/refactor/EDIT4/ed4_class.hxx

r7084	r7097
82	82	class BI_ecoli_ref;
83	83	class AW_helix;
84		class a~~w_status_counter~~;
	84	class arb_progress;
85	85	class ST_ML;
86	86	class ed_key;
…	…
107	107	ED4_index *length_of_terminals,
108	108	int group_depth,
109		a~~w_status_counter~~ *progress);
	109	arb_progress *progress);
110	110
111	111	ED4_returncode fill_data(ED4_multi_species_manager *multi_species_manager,
…	…
134	134	int *index,
135	135	ED4_index *y,
136		a~~w_status_counter&~~ progress);
	136	arb_progress& progress);
137	137
138	138	ED4_returncode create_group_header(ED4_multi_species_manager *parent,
…	…
891	891	virtual ED4_returncode move_requested_by_parent(ED4_move_info *mi);
892	892
893		void create_consensus(ED4_group_manager upper_group_manager, a~~w_status_counter~~ progress);
	893	void create_consensus(ED4_group_manager upper_group_manager, arb_progress progress);
894	894
895	895	virtual ARB_ERROR route_down_hierarchy(ED4_cb cb, AW_CL cd1, AW_CL cd2);

branches/refactor/GENOM/GEN_map.cxx

r7070	r7097
25	25	#include <awt_input_mask.hxx>
26	26	#include <aw_msg.hxx>
27		#include <a~~w_status.hxx~~>
	27	#include <arb_progress.h>
28	28	#include <aw_root.hxx>
29	29	#include <adGene.h>
…	…
677	677
678	678	struct EG2PS_data {
679		// used for status:
680		int count;
681		int marked_genes;
682
	679	arb_progress progress;
683	680	GBDATA *gb_species_data;
684	681	char *ali;
685	682	UniqueNameDetector existing;
686	683	GB_HASH *pseudo_hash;
687
688		int duplicateSpecies; // counts created gene-species with identical ACC
689		bool nameProblem; // nameserver and DB disagree about names
	684	int duplicateSpecies; // counts created gene-species with identical ACC
	685	bool nameProblem; // nameserver and DB disagree about names
690	686
691	687	EG2PS_data(const char ali_, GBDATA gb_species_data_, int marked_genes_)
692		: count(0)
693		, marked_genes(marked_genes_)
694		, gb_species_data(gb_species_data_)
695		, ali(strdup(ali_))
696		, existing(gb_species_data, marked_genes)
697		, duplicateSpecies(0)
698		, nameProblem(false)
	688	: progress(marked_genes_),
	689	gb_species_data(gb_species_data_),
	690	ali(strdup(ali_)),
	691	existing(gb_species_data, marked_genes_),
	692	duplicateSpecies(0),
	693	nameProblem(false)
699	694	{
700		pseudo_hash = GEN_create_pseudo_species_hash(GB_get_root(gb_species_data), marked_genes);
	695	pseudo_hash = GEN_create_pseudo_species_hash(GB_get_root(gb_species_data), marked_genes_);
701	696	}
702	697
…	…
803	798	if (create_new_gene_species) {
804	799	if (!short_name) { // create a new name
805		error = AWTC_generate_one_name(gb_main, full_name, acc, 0, short_name~~, false, false~~);
	800	error = AWTC_generate_one_name(gb_main, full_name, acc, 0, short_name);
806	801	if (!error) { // name has been created
807	802	if (eg2ps->existing.name_known(short_name)) { // nameserver-generated name is already in use
…	…
925	920	EG2PS_data eg2ps = (EG2PS_data)cl_user;
926	921	gen_extract_gene_2_pseudoSpecies(gb_species, gb_gene, eg2ps);
927		if ((++eg2ps->count)%10 == 0) {
928		aw_status(eg2ps->count/double(eg2ps->marked_genes));
929		}
	922	eg2ps->progress.inc();
930	923	}
931	924	break;
…	…
1122	1115	ask_to_overwrite_alignment = new AW_repeated_question();
1123	1116
1124		a~~w_openstatu~~s("Extracting pseudo-species");
	1117	arb_progress progress("Extracting pseudo-species");
1125	1118	{
1126	1119	EG2PS_data *eg2ps = 0;
…	…
1139	1132	delete eg2ps;
1140	1133	}
1141		~~aw_closestatus();~~
1142	1134
1143	1135	delete ask_to_overwrite_alignment;

branches/refactor/GENOM/Makefile

r7089	r7097
225	225	GEN_map.o: $(ARBHOME)/INCLUDE/arb_error.h
226	226	GEN_map.o: $(ARBHOME)/INCLUDE/arb_msg.h
	227	GEN_map.o: $(ARBHOME)/INCLUDE/arb_progress.h
227	228	GEN_map.o: $(ARBHOME)/INCLUDE/arb_string.h
228	229	GEN_map.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
243	244	GEN_map.o: $(ARBHOME)/INCLUDE/AW_rename.hxx
244	245	GEN_map.o: $(ARBHOME)/INCLUDE/aw_root.hxx
245		~~GEN_map.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
246	246	GEN_map.o: $(ARBHOME)/INCLUDE/aw_window.hxx
247	247	GEN_map.o: $(ARBHOME)/INCLUDE/awt.hxx

branches/refactor/MERGE/MG_alignment.cxx

r6861	r7097
15	15	#include <aw_awar.hxx>
16	16	#include <aw_msg.hxx>
17		~~#include <aw_status.hxx>~~
18	17	#include <arbdbt.h>
19	18
…	…
87	86	}
88	87
89		int MG_copy_and_check_alignments(AW_window /aww*/~~, int show_status~~) {
	88	int MG_copy_and_check_alignments(AW_window /aww*/) {
90	89	// returns 0 if alignments are ok for merging.
91	90	// checks types and names.
92	91
93	92	GB_ERROR error = NULL;
94
95		~~if (show_status) aw_openstatus("Checking alignments");~~
96	93
97	94	GB_begin_transaction(GLOBAL_gb_dest);
…	…
133	130
134	131	if (error) aw_message(error);
135		~~if (show_status) aw_closestatus();~~
136	132
137	133	return !!error;

branches/refactor/MERGE/MG_checkfield.cxx

r6858	r7097
18	18	#include <aw_root.hxx>
19	19	#include <aw_msg.hxx>
20		#include <a~~w_status.hxx~~>
	20	#include <arb_progress.h>
21	21
22	22	#include <arbdbt.h>
…	…
169	169	}
170	170
171		#undef IS_QUERIED
172		#define IS_QUERIED(gb_species) (1 & GB_read_usr_private(gb_species))
	171	int mg_count_queried(GBDATA *gb_main) {
	172	int queried = 0;
	173	for (GBDATA *gb_spec = GBT_first_species(gb_main);
	174	gb_spec;
	175	gb_spec = GBT_next_species(gb_spec))
	176	{
	177	if (IS_QUERIED_SPECIES(gb_spec)) queried++;
	178	}
	179	return queried;
	180	}
173	181
174	182	void mg_check_field_cb(AW_window *aww) {
…	…
189	197	}
190	198	else {
191		~~aw_openstatus("Checking fields");~~
192	199	error = GB_begin_transaction(GLOBAL_gb_merge);
193	200
…	…
201	208	GBDATA *gb_species2;
202	209
203		~~int sum_species = 0;~~
204		~~int species_count = 0;~~
205
206	210	// First step: count selected species
207		for (gb_species1 = GBT_first_species_rel_species_data(gb_species_data1);
208		gb_species1 && !error;
209		gb_species1 = GBT_next_species(gb_species1))
210		{
211		if (IS_QUERIED(gb_species1)) sum_species++;
212		}
	211	arb_progress progress("Checking fields", mg_count_queried(GLOBAL_gb_merge));
213	212
214	213	// Delete all 'dest' fields in gb_database 2
…	…
231	230
232	231	if (!error) {
233		if (IS_QUERIED(gb_species1)) {
234		species_count++;
235		if ((species_count & 0xf) == 0) aw_status(species_count / (double)sum_species);
236
	232	if (IS_QUERIED_SPECIES(gb_species1)) {
237	233	const char *name1 = GBT_read_name(gb_species1);
238	234	gb_species2 = GB_find_string(gb_species_data2, "name", name1, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
…	…
277	273	free(s1);
278	274	}
	275	progress.inc_and_check_user_abort(error);
279	276	}
280	277	}
281	278	}
282	279
283		~~aw_closestatus();~~
284	280	error = GB_end_transaction(GLOBAL_gb_merge, error);
285	281	error = GB_end_transaction(GLOBAL_gb_dest, error);

branches/refactor/MERGE/MG_main.cxx

r6858	r7097
19	19	#include <aw_file.hxx>
20	20	#include <aw_msg.hxx>
21		#include <a~~w_status.hxx~~>
	21	#include <arb_progress.h>
22	22	#include <aw_root.hxx>
23	23
…	…
81	81	char *name = aww->get_root()->awar(AWAR_MAIN_DB"/file_name")->read_string();
82	82	char *type = aww->get_root()->awar(AWAR_MAIN_DB"/type")->read_string();
83		aw_openstatus("Saving database");
	83
	84	arb_progress progress("Saving database");
84	85	GB_begin_transaction(GLOBAL_gb_dest);
85	86	GBT_check_data(GLOBAL_gb_dest, 0);
86	87	GB_commit_transaction(GLOBAL_gb_dest);
	88
87	89	GB_ERROR error = GB_save(GLOBAL_gb_dest, name, type);
88		~~aw_closestatus();~~
89	90	if (error) aw_message(error);
90	91	else AW_refresh_fileselection(aww->get_root(), AWAR_MAIN_DB);
91		delete name;
92		delete type;
	92
	93	free(type);
	94	free(name);
93	95	}
94	96
…	…
133	135	void MG_save_quick_result_cb(AW_window *aww) {
134	136	char *name = aww->get_root()->awar(AWAR_MAIN_DB"/file_name")->read_string();
135		aw_openstatus("Saving database");
	137
	138	arb_progress progress("Saving database");
136	139	GB_begin_transaction(GLOBAL_gb_dest);
137	140	GBT_check_data(GLOBAL_gb_dest, 0);
138	141	GB_commit_transaction(GLOBAL_gb_dest);
	142
139	143	GB_ERROR error = GB_save_quick_as(GLOBAL_gb_dest, name);
140		~~aw_closestatus();~~
141	144	if (error) aw_message(error);
142	145	else AW_refresh_fileselection(aww->get_root(), AWAR_MAIN_DB);
143		delete name;
144		~~return~~;
	146
	147	free(name);
145	148	}
146	149
…	…
308	311	}
309	312	else {
310		a~~w_openstatu~~s("Loading databases");
	313	arb_progress progress("Loading databases");
311	314
312	315	#if defined(DEVEL_RALF)
…	…
314	317	#warning when closing them, call AWT_browser_forget_db as well
315	318	#endif // DEVEL_RALF
316		~~aw_status~~("DATABASE I");
	319	progress.subtitle("DATABASE I");
317	320	GLOBAL_gb_merge = GBT_open(merge, "rw", "$(ARBHOME)/lib/pts/*");
318	321	if (!GLOBAL_gb_merge) error = GB_await_error();
…	…
322	325	#endif // DEBUG
323	326
324		~~aw_status~~("DATABASE II");
	327	progress.subtitle("DATABASE II");
325	328
326	329	char *main = awr->awar(AWAR_MAIN_DB"/file_name")->read_string();
…	…
347	350	free(main);
348	351	}
349		~~aw_closestatus();~~
350	352	}
351	353	free(merge);

branches/refactor/MERGE/MG_names.cxx

r6858	r7097
15	15	#include <aw_awar.hxx>
16	16	#include <aw_msg.hxx>
17		#include <a~~w_status.hxx~~>
	17	#include <arb_progress.h>
18	18
19	19	// --------------------------------------------------------------------------------
…	…
123	123
124	124	static GB_ERROR renameDB(const char which, GBDATA gb_db, bool allowDups) {
125		aw_openstatus(GBS_global_string("Generating new names in %s database", which));
126		aw_status("Contacting name server");
127
128		bool isDuplicatesWarning;
129		GB_ERROR error = AWTC_pars_names(gb_db, 1, &isDuplicatesWarning);
	125	arb_progress progress(GBS_global_string("Generating new names in %s database", which));
	126	bool isDuplicatesWarning;
	127	GB_ERROR error = AWTC_pars_names(gb_db, &isDuplicatesWarning);
130	128
131	129	if (error) {
…	…
138	136	}
139	137
140		~~aw_closestatus();~~
141	138	return error;
142	139	}

branches/refactor/MERGE/MG_preserves.cxx

r6858	r7097
20	20	#include <aw_root.hxx>
21	21	#include <aw_msg.hxx>
22		#include <a~~w_status.hxx~~>
	22	#include <arb_progress.h>
23	23	#include <arbdbt.h>
24	24
…	…
184	184	// add all candidate species to 'candidates'
185	185	static void find_species_candidates(Candidates& candidates, const char const ali_names) {
186		~~aw_status("Examining species (kill to stop)");~~
187		~~aw_status(0.0);~~
188
189	186	// collect names of all species in source database
190		GB_HASH *src_species = GBT_create_species_hash(GLOBAL_gb_merge);
191		long src_count = GBS_hash_count_elems(src_species);
192		~~long found = 0~~;
193		bool aborted = false;
	187	GB_HASH *src_species = GBT_create_species_hash(GLOBAL_gb_merge);
	188	long src_count = GBS_hash_count_elems(src_species);
	189	arb_progress progress("Examining species", src_count);
	190	bool aborted = false;
194	191
195	192	// find existing species in destination database
…	…
213	210	}
214	211
215		++found;
216		aw_status(double(found)/src_count);
217		aborted = aw_status() != 0; // test user abort
	212	progress.inc();
	213	aborted = progress.aborted();
218	214	}
219	215	}
…	…
222	218	}
223	219
224		~~// add all candidate SAIs to 'candidates'~~
225	220	static void find_SAI_candidates(Candidates& candidates, const char const ali_names) {
226		aw_status("Examining SAIs");
227		aw_status(0.0);
228
229		// collect names of all SAIs in source database
230		GB_HASH *src_SAIs = GBT_create_SAI_hash(GLOBAL_gb_merge);
231		long src_count = GBS_hash_count_elems(src_SAIs);
232		long found = 0;
	221	// add all candidate SAIs to 'candidates'
	222	GB_HASH *src_SAIs = GBT_create_SAI_hash(GLOBAL_gb_merge);
	223	long src_count = GBS_hash_count_elems(src_SAIs);
	224	arb_progress progress("Examining SAIs", src_count);
233	225
234	226	// find existing SAIs in destination database
…	…
252	244	}
253	245
254		++found;
255		aw_status(double(found)/src_count);
	246	progress.inc();
256	247	}
257	248	}
…	…
274	265	Candidates candidates;
275	266
276		a~~w_openstatu~~s("Searching candidates");
	267	arb_progress("Searching candidates");
277	268
278	269	// add candidates
…	…
305	296	}
306	297	free(ali);
307
308		~~aw_closestatus();~~
309	298
310	299	aww->update_selection_list(id);

branches/refactor/MERGE/MG_species.cxx

r6858	r7097
18	18	#include <aw_awars.hxx>
19	19	#include <aw_msg.hxx>
20		#include <a~~w_status.hxx~~>
	20	#include <arb_progress.h>
21	21	#include <aw_root.hxx>
22	22	#include <arb_str.h>
…	…
198	198
199	199	void MG_transfer_selected_species(AW_window *aww) {
200		if (MG_copy_and_check_alignments(aww~~, 0~~) != 0) return;
	200	if (MG_copy_and_check_alignments(aww) != 0) return;
201	201
202	202	AW_root *aw_root = aww->get_root();
…	…
208	208	}
209	209	else {
210		a~~w_openstatu~~s("Transferring selected species");
	210	arb_progress progress("Transferring selected species");
211	211
212	212	error = GB_begin_transaction(GLOBAL_gb_merge);
…	…
234	234	error = GB_end_transaction(GLOBAL_gb_merge, error);
235	235	error = GB_end_transaction(GLOBAL_gb_dest, error);
236
237		~~aw_closestatus();~~
238	236	}
239	237
…	…
241	239	}
242	240
243		~~#undef IS_QUERIED~~
244		~~#define IS_QUERIED(gb_species) (1 & GB_read_usr_private(gb_species))~~
245
246	241	void MG_transfer_species_list(AW_window *aww) {
247		if (MG_copy_and_check_alignments(aww~~, 0~~) != 0) return;
	242	if (MG_copy_and_check_alignments(aww) != 0) return;
248	243
249	244	GB_ERROR error = NULL;
250		~~aw_openstatus("Transferring species");~~
251	245	GB_begin_transaction(GLOBAL_gb_merge);
252	246	GB_begin_transaction(GLOBAL_gb_dest);
…	…
263	257
264	258	GBDATA *gb_species1;
265		int queried = 0;
266		int count = 0;
267
268		for (gb_species1 = GBT_first_species(GLOBAL_gb_merge); gb_species1; gb_species1 = GBT_next_species(gb_species1)) {
269		if (IS_QUERIED(gb_species1)) queried++;
270		}
271
272		for (gb_species1 = GBT_first_species(GLOBAL_gb_merge); gb_species1; gb_species1 = GBT_next_species(gb_species1)) {
273		if (IS_QUERIED(gb_species1)) {
	259	arb_progress progress("Transferring listed species", mg_count_queried(GLOBAL_gb_merge));
	260
	261	for (gb_species1 = GBT_first_species(GLOBAL_gb_merge);
	262	gb_species1;
	263	gb_species1 = GBT_next_species(gb_species1))
	264	{
	265	if (IS_QUERIED_SPECIES(gb_species1)) {
274	266	GBDATA *gb_species_data2 = GB_search(GLOBAL_gb_dest, "species_data", GB_CREATE_CONTAINER);
275	267
…	…
280	272	source_organism_hash, dest_species_hash,
281	273	error_suppressor);
282		aw_status(++count/double(queried));
	274
	275	progress.inc_and_check_user_abort(error);
283	276	}
284	277	}
…	…
292	285	error = GB_end_transaction(GLOBAL_gb_merge, error);
293	286	GB_end_transaction_show_error(GLOBAL_gb_dest, error, aw_message);
294
295		~~aw_closestatus();~~
296	287	}
297	288
298	289	void MG_transfer_fields_cb(AW_window *aww) {
299		if (MG_copy_and_check_alignments(aww~~, 0~~) != 0) return;
	290	if (MG_copy_and_check_alignments(aww) != 0) return;
300	291
301	292	char *field = aww->get_root()->awar(AWAR_FIELD1)->read_string();
…	…
310	301	}
311	302	else {
312		~~aw_openstatus("Transferring fields");~~
313	303	GB_begin_transaction(GLOBAL_gb_merge);
314	304	GB_begin_transaction(GLOBAL_gb_dest);
…	…
316	306	GBDATA *gb_dest_species_data = GB_search(GLOBAL_gb_dest, "species_data", GB_CREATE_CONTAINER);
317	307	bool transfer_of_alignment = GBS_string_matches(field, "ali_*/data", GB_MIND_CASE);
	308
	309	arb_progress progress("Transferring fields of listed", mg_count_queried(GLOBAL_gb_merge));
318	310
319	311	AW_root *aw_root = aww->get_root();
…	…
324	316	gb_species1 = GBT_next_species(gb_species1))
325	317	{
326		if (IS_QUERIED(gb_species1)) {
	318	if (IS_QUERIED_SPECIES(gb_species1)) {
327	319	const char *name1 = GBT_read_name(gb_species1);
328	320	GBDATA *gb_species2 = GB_find_string(gb_dest_species_data, "name", name1, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
…	…
386	378	}
387	379	}
	380	progress.inc_and_check_user_abort(error);
388	381	}
389	382	}
…	…
393	386	error = GB_end_transaction(GLOBAL_gb_merge, error);
394	387	error = GB_end_transaction(GLOBAL_gb_dest, error);
395		~~aw_closestatus();~~
396	388	}
397	389
…	…
433	425
434	426	void MG_move_field_cb(AW_window *aww) {
435		if (MG_copy_and_check_alignments(aww~~, 0~~) != 0) return;
	427	if (MG_copy_and_check_alignments(aww) != 0) return;
436	428
437	429	AW_root *aw_root = aww->get_root();
…	…
446	438	}
447	439	else {
448		a~~w_openstatu~~s("Cross Move field");
	440	arb_progress progress("Cross Move field");
449	441	error = GB_begin_transaction(GLOBAL_gb_merge);
450	442	if (!error) error = GB_begin_transaction(GLOBAL_gb_dest);
…	…
500	492	error = GB_end_transaction(GLOBAL_gb_merge, error);
501	493	error = GB_end_transaction(GLOBAL_gb_dest, error);
502
503		~~aw_closestatus();~~
504	494	}
505	495
…	…
551	541	char *tag_del1 = awr->awar(AWAR_TAG_DEL1)->read_string();
552	542
	543	arb_progress progress("Merging tagged fields", mg_count_queried(GLOBAL_gb_merge));
	544
553	545	GBDATA *gb_dest_species_data = GB_search(GLOBAL_gb_dest, "species_data", GB_CREATE_CONTAINER);
554	546	if (!gb_dest_species_data) error = GB_await_error();
…	…
558	550	gb_species1 = GBT_next_species(gb_species1))
559	551	{
560		if (IS_QUERIED(gb_species1)) {
	552	if (IS_QUERIED_SPECIES(gb_species1)) {
561	553	char *name = GBT_read_string(gb_species1, "name");
562	554	if (!name) error = GB_await_error();
…	…
579	571	}
580	572	free(name);
	573	progress.inc_and_check_user_abort(error);
581	574	}
582	575	}

branches/refactor/MERGE/Makefile

r7089	r7097
84	84	MG_alignment.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
85	85	MG_alignment.o: $(ARBHOME)/INCLUDE/aw_root.hxx
86		~~MG_alignment.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
87	86	MG_alignment.o: $(ARBHOME)/INCLUDE/aw_window.hxx
88	87	MG_alignment.o: $(ARBHOME)/INCLUDE/awt_sel_boxes.hxx
…	…
100	99	MG_checkfield.o: $(ARBHOME)/INCLUDE/arb_error.h
101	100	MG_checkfield.o: $(ARBHOME)/INCLUDE/arb_msg.h
	101	MG_checkfield.o: $(ARBHOME)/INCLUDE/arb_progress.h
102	102	MG_checkfield.o: $(ARBHOME)/INCLUDE/arb_string.h
103	103	MG_checkfield.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
113	113	MG_checkfield.o: $(ARBHOME)/INCLUDE/aw_root.hxx
114	114	MG_checkfield.o: $(ARBHOME)/INCLUDE/aw_select.hxx
115		~~MG_checkfield.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
116	115	MG_checkfield.o: $(ARBHOME)/INCLUDE/aw_window.hxx
117	116	MG_checkfield.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
216	215	MG_main.o: $(ARBHOME)/INCLUDE/arb_error.h
217	216	MG_main.o: $(ARBHOME)/INCLUDE/arb_msg.h
	217	MG_main.o: $(ARBHOME)/INCLUDE/arb_progress.h
218	218	MG_main.o: $(ARBHOME)/INCLUDE/arb_string.h
219	219	MG_main.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
231	231	MG_main.o: $(ARBHOME)/INCLUDE/AW_rename.hxx
232	232	MG_main.o: $(ARBHOME)/INCLUDE/aw_root.hxx
233		~~MG_main.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
234	233	MG_main.o: $(ARBHOME)/INCLUDE/aw_window.hxx
235	234	MG_main.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
247	246	MG_names.o: $(ARBHOME)/INCLUDE/arb_error.h
248	247	MG_names.o: $(ARBHOME)/INCLUDE/arb_msg.h
	248	MG_names.o: $(ARBHOME)/INCLUDE/arb_progress.h
249	249	MG_names.o: $(ARBHOME)/INCLUDE/arb_string.h
250	250	MG_names.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
259	259	MG_names.o: $(ARBHOME)/INCLUDE/AW_rename.hxx
260	260	MG_names.o: $(ARBHOME)/INCLUDE/aw_root.hxx
261		~~MG_names.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
262	261	MG_names.o: $(ARBHOME)/INCLUDE/aw_window.hxx
263	262	MG_names.o: $(ARBHOME)/INCLUDE/cb.h
…	…
275	274	MG_preserves.o: $(ARBHOME)/INCLUDE/arb_error.h
276	275	MG_preserves.o: $(ARBHOME)/INCLUDE/arb_msg.h
	276	MG_preserves.o: $(ARBHOME)/INCLUDE/arb_progress.h
277	277	MG_preserves.o: $(ARBHOME)/INCLUDE/arb_string.h
278	278	MG_preserves.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
287	287	MG_preserves.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
288	288	MG_preserves.o: $(ARBHOME)/INCLUDE/aw_root.hxx
289		~~MG_preserves.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
290	289	MG_preserves.o: $(ARBHOME)/INCLUDE/aw_window.hxx
291	290	MG_preserves.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
304	303	MG_species.o: $(ARBHOME)/INCLUDE/arb_error.h
305	304	MG_species.o: $(ARBHOME)/INCLUDE/arb_msg.h
	305	MG_species.o: $(ARBHOME)/INCLUDE/arb_progress.h
306	306	MG_species.o: $(ARBHOME)/INCLUDE/arb_str.h
307	307	MG_species.o: $(ARBHOME)/INCLUDE/arb_string.h
…	…
319	319	MG_species.o: $(ARBHOME)/INCLUDE/aw_root.hxx
320	320	MG_species.o: $(ARBHOME)/INCLUDE/aw_select.hxx
321		~~MG_species.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
322	321	MG_species.o: $(ARBHOME)/INCLUDE/aw_window.hxx
323	322	MG_species.o: $(ARBHOME)/INCLUDE/awt.hxx

branches/refactor/MERGE/merge.hxx

r6551	r7097
45	45	GB_ERROR MG_expect_renamed();
46	46
47		int MG_copy_and_check_alignments(AW_window *aww~~, int show_status~~);
	47	int MG_copy_and_check_alignments(AW_window *aww);
48	48
49	49	// export of gene-species:
…	…
58	58	#define AWAR_MERGE_GENE_SPECIES_BASE "merge/gene_species/"
59	59
	60	#define IS_QUERIED_SPECIES(gb_species) (1 & GB_read_usr_private(gb_species))
	61	int mg_count_queried(GBDATA *gb_main);
	62
60	63	const char *MG_left_AWAR_SPECIES_NAME();
61	64	const char *MG_right_AWAR_SPECIES_NAME();

branches/refactor/MULTI_PROBE/MP_Generation.cxx

r6595	r7097
12	12	#include "MP_externs.hxx"
13	13	#include "MultiProbe.hxx"
	14	#include <arb_progress.h>
14	15
15	16	bool Stop_evaluation = false;
…	…
50	51	double fitness = 0;
51	52	double dummy = 0;
52
53	53	int i;
	54
	55	arb_progress progress(probe_combi_array_length);
54	56
55	57	for (i=0; i<probe_combi_array_length; i++)
…	…
67	69	max_fit = dummy;
68	70
69		if (~~!MP_check_status(generation_counter, old_avg_fit, min_fit, max_fit~~)) // Berechnungen abbrechen
	71	if (MP_aborted(generation_counter, old_avg_fit, min_fit, max_fit, progress)) // Berechnungen abbrechen
70	72	{
71	73	Stop_evaluation = true;
…	…
73	75	return;
74	76	}
	77	progress.inc();
75	78	}
76	79

branches/refactor/MULTI_PROBE/MP_externs.hxx

r6583	r7097
12	12	#define MP_EXTERNS_HXX
13	13
14		class AW_window;
15		class AW_root;
	14	class AW_window;
	15	class AW_root;
	16	class arb_progress;
	17
16	18	typedef long AW_CL; // generic client data type (void *)
17	19
…	…
37	39	void MP_selected_chosen(AW_window *aww);
38	40
39		bool MP_~~check_status(int gen_cnt, double avg_fit, double min_fit, double max_fit~~);
	41	bool MP_aborted(int gen_cnt, double avg_fit, double min_fit, double max_fit, arb_progress& progress);
40	42
41	43	char MP_get_comment(int which, const char str);

branches/refactor/MULTI_PROBE/MP_mo_liste.cxx

r6858	r7097
38	38	}
39	39	delete [] mo_liste;
40		GBS_free_hash(hashptr);
	40	if (hashptr) GBS_free_hash(hashptr);
41	41	}
42	42

branches/refactor/MULTI_PROBE/MP_noclass.cxx

r6861	r7097
17	17	#include <aw_select.hxx>
18	18	#include <aw_msg.hxx>
19		#include <a~~w_status.hxx~~>
	19	#include <arb_progress.h>
20	20	#include <aw_root.hxx>
21	21	#include <TreeCallbacks.hxx>
…	…
200	200	}
201	201
202		bool MP_~~check_status(int gen_cnt, double avg_fit, double min_fit, double max_fit~~) {
	202	bool MP_aborted(int gen_cnt, double avg_fit, double min_fit, double max_fit, arb_progress& progress) {
203	203	char view_text[150];
204	204
…	…
208	208	sprintf(view_text, "Gen:%d Avg:%5i Min:%5i Max:%5i", gen_cnt, int(avg_fit), int(min_fit), int(max_fit));
209	209
210		if (aw_status(view_text) == 1)
211		{
212		aw_closestatus();
213		return false; // Berechnungen abbrechen !!!!!!
214		}
215
216		return true;
	210	progress.subtitle(view_text);
	211	return progress.aborted();
217	212	}
218	213
…	…
347	342	single_mismatch = new int[selected_probes_count];
348	343
349		a~~w_openstatu~~s("Computing multiprobes");
	344	arb_progress progress("Computing multiprobes");
350	345
351	346	while ((ptr2 = (char *)aww->get_list_entry_char_value()))
…	…
377	372	mp_main->destroy_probe_eval();
378	373
379		~~aw_closestatus();~~
380	374	aww2->activate();
381
382	375	}
383	376

branches/refactor/MULTI_PROBE/MP_probe.cxx

r6858	r7097
15	15	#include <aw_window.hxx>
16	16	#include <aw_msg.hxx>
17		#include <a~~w_status.hxx~~>
	17	#include <arb_progress.h>
18	18
19	19	#include <ctime>
…	…
37	37	}
38	38
39		MP_check_status(0, 0.0, 0.0, 0.0);
40
	39
	40	long max_generation = moeglichkeiten/(3*MAXPOPULATION)-1;
	41
	42	mp_assert(max_generation>1);
	43	arb_progress progress(max_generation);
	44	MP_aborted(0, 0.0, 0.0, 0.0, progress);
	45
41	46	// hier beginnt der genetische Algorithmus
42		do
43		{
	47	do {
44	48	act_generation->calc_fitness(0, avg_fit); // hier wird auch init_roulette_wheel gemacht
45	49	avg_fit = act_generation->get_avg_fit();
46	50
47		if (avg_fit == 0 && !Stop_evaluation)
48		{
49		aw_message("Please choose better Probes!");
50		return;
51		}
52
53		if (Stop_evaluation) // Abgebrochen durch Benutzer
54		{
55		Stop_evaluation = false;
56		act_generation->check_for_results();
57		return;
58		}
59
60		child_generation = act_generation->create_next_generation();
61		delete act_generation;
62		act_generation = NULL;
63
64
65		child_generation->check_for_results();
66
67		act_generation = child_generation; // zum testen hier nur generierung einer Generation
68		}
69		while (moeglichkeiten/3 > act_generation->get_generation() * MAXPOPULATION) ; // hier abbruchbedingung
	51	if (!Stop_evaluation) {
	52	if (avg_fit == 0) {
	53	aw_message("Please choose better Probes!");
	54	return;
	55	}
	56	child_generation = act_generation->create_next_generation();
	57	delete act_generation; act_generation = NULL;
	58
	59	child_generation->check_for_results();
	60
	61	act_generation = child_generation; // zum testen hier nur generierung einer Generation
	62	progress.inc();
	63	}
	64	}
	65	while (act_generation->get_generation() <= max_generation && !Stop_evaluation) ; // hier abbruchbedingung
	66
	67	Stop_evaluation = false;
70	68
71	69	// Abbruchbedingung deshalb, weil der genetische Alg. keinesfalls mehr Versuche
…	…
194	192	delete mp_main->get_stc();
195	193
196		~~aw_status("Starting computation");~~
197	194	mp_main->set_stc(new ST_Container(MAXSONDENHASHSIZE));
198	195	}

branches/refactor/MULTI_PROBE/MP_probe.hxx

r6595	r7097
176	176	max_init_pop_combis;
177	177	Generation *act_generation,
178		*child_generation;
	178	*child_generation; // @@@ can be removed
179	179	List<result_struct> *computation_result_list;
180	180

branches/refactor/MULTI_PROBE/Makefile

r7089	r7097
55	55	MP_Generation.o: $(ARBHOME)/INCLUDE/arb_assert.h
56	56	MP_Generation.o: $(ARBHOME)/INCLUDE/arb_core.h
	57	MP_Generation.o: $(ARBHOME)/INCLUDE/arb_error.h
	58	MP_Generation.o: $(ARBHOME)/INCLUDE/arb_progress.h
57	59	MP_Generation.o: $(ARBHOME)/INCLUDE/arbdb_base.h
	60	MP_Generation.o: $(ARBHOME)/INCLUDE/arbtools.h
58	61	MP_Generation.o: $(ARBHOME)/INCLUDE/attributes.h
59	62	MP_Generation.o: $(ARBHOME)/INCLUDE/aw_awar.hxx
…	…
63	66	MP_Generation.o: $(ARBHOME)/INCLUDE/dupstr.h
64	67	MP_Generation.o: $(ARBHOME)/INCLUDE/PT_com.h
	68	MP_Generation.o: $(ARBHOME)/INCLUDE/smartptr.h
65	69	MP_Generation.o: $(ARBHOME)/INCLUDE/test_global.h
66	70
…	…
154	158	MP_noclass.o: $(ARBHOME)/INCLUDE/arb_error.h
155	159	MP_noclass.o: $(ARBHOME)/INCLUDE/arb_msg.h
	160	MP_noclass.o: $(ARBHOME)/INCLUDE/arb_progress.h
156	161	MP_noclass.o: $(ARBHOME)/INCLUDE/arb_string.h
157	162	MP_noclass.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
171	176	MP_noclass.o: $(ARBHOME)/INCLUDE/aw_root.hxx
172	177	MP_noclass.o: $(ARBHOME)/INCLUDE/aw_select.hxx
173		~~MP_noclass.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
174	178	MP_noclass.o: $(ARBHOME)/INCLUDE/aw_window.hxx
175	179	MP_noclass.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
212	216	MP_probe.o: $(ARBHOME)/INCLUDE/arb_core.h
213	217	MP_probe.o: $(ARBHOME)/INCLUDE/arb_error.h
	218	MP_probe.o: $(ARBHOME)/INCLUDE/arb_progress.h
214	219	MP_probe.o: $(ARBHOME)/INCLUDE/arbdb_base.h
215	220	MP_probe.o: $(ARBHOME)/INCLUDE/arbtools.h
…	…
220	225	MP_probe.o: $(ARBHOME)/INCLUDE/aw_keysym.hxx
221	226	MP_probe.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
222		~~MP_probe.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
223	227	MP_probe.o: $(ARBHOME)/INCLUDE/aw_window.hxx
224	228	MP_probe.o: $(ARBHOME)/INCLUDE/cb.h

branches/refactor/NTREE/AP_consensus.cxx

r6858	r7097
49	49	#include <awt_sel_boxes.hxx>
50	50	#include <aw_window.hxx>
51		#include <a~~w_status.hxx~~>
	51	#include <arb_progress.h>
52	52	#include <aw_root.hxx>
53	53	#include <aw_msg.hxx>
…	…
107	107	long numentries;
108	108
109		a~~w_status("calculating result"~~);
	109	arb_progress progress("calculating result", alignlength);
110	110
111	111	result=(char *)GB_calloc(alignlength+1, 1);
…	…
116	116	if (numentries==0) {
117	117	result[column]='.';
118		continue;
119		}
120
121		if (numentries-statistic[0][column]==0) {
122		result[column]='=';
123		continue; /* 100 per cent `-` -> `=` */
124		}
125
126		if (!countgap) {
127		numentries -= statistic[0][column];
128		statistic[0][column]=0;
129		}
130
131		if ((statistic[0][column]*100/numentries)>gapbound) {
132		result[column]='-';
133		continue;
134		}
135
136		for (j=0; j<numgroups; j++) {
137		groupfr[j]=0;
138		}
139
140		row=0;
141		while (statistic[row]) {
142		if ((statistic[row][column]100.0)>=fconsidboundnumentries) {
143		for (j=numgroups-1; j>=0; j--) {
144		if (groupflags[j][row]) {
145		groupfr[j] += statistic[row][column];
	118	}
	119	else {
	120	if (numentries-statistic[0][column]==0) {
	121	result[column]='='; // 100 per cent `-` -> `=`
	122	}
	123	else {
	124	if (!countgap) {
	125	numentries -= statistic[0][column];
	126	statistic[0][column]=0;
	127	}
	128
	129	if ((statistic[0][column]*100/numentries)>gapbound) {
	130	result[column]='-';
	131	}
	132	else {
	133	for (j=0; j<numgroups; j++) {
	134	groupfr[j]=0;
	135	}
	136
	137	row=0;
	138	while (statistic[row]) {
	139	if ((statistic[row][column]100.0)>=fconsidboundnumentries) {
	140	for (j=numgroups-1; j>=0; j--) {
	141	if (groupflags[j][row]) {
	142	groupfr[j] += statistic[row][column];
	143	}
	144	}
	145	}
	146	row++;
	147	}
	148
	149	highestfr=0;
	150	highestgr=0;
	151	for (j=0; j<numgroups; j++) {
	152	if (groupfr[j] > highestfr) {
	153	highestfr=groupfr[j];
	154	highestgr=j;
	155	}
	156	}
	157
	158	if ((highestfr*100.0/numentries)>=fupper) {
	159	result[column]=groupnames[highestgr];
	160	}
	161	else if ((highestfr*100/numentries)>=lower) {
	162	char c=groupnames[highestgr];
	163	if (c>='A' && c<='Z') {
	164	c=c-'A'+'a';
	165	}
	166	result[column]=c;
	167	}
	168	else {
	169	result[column]='.';
146	170	}
147	171	}
148	172	}
149		row++;
150		}
151
152		highestfr=0; highestgr=0;
153		for (j=0; j<numgroups; j++) {
154		if (groupfr[j] > highestfr) {
155		highestfr=groupfr[j];
156		highestgr=j;
157		}
158		}
159
160		if ((highestfr*100.0/numentries)>=fupper) {
161		result[column]=groupnames[highestgr];
162		}
163		else if ((highestfr*100/numentries)>=lower) {
164		char c=groupnames[highestgr];
165		if (c>='A' && c<='Z') {
166		c=c-'A'+'a';
167		}
168		result[column]=c;
169		}
170		else {
171		result[column]='.';
172		}
	173	}
	174	++progress;
173	175	}
174	176	}
…	…
293	295	int i, nrofspecies=0;
294	296
295		~~aw_status("reading database");~~
296
297	297	if (onlymarked) {
298	298	nrofspecies = GBT_count_marked_species(GLOBAL_gb_main);
…	…
302	302	}
303	303
	304	arb_progress progress(nrofspecies);
	305	progress.auto_subtitles("Examining sequence");
	306
304	307	if (onlymarked) {
305	308	gb_species = GBT_first_marked_species(GLOBAL_gb_main);
…	…
309	312	}
310	313
311		long count = 0;
312		while (gb_species)
313		{
314		if ((alidata=GBT_read_sequence(gb_species, align)))
315		{
	314	while (gb_species) {
	315	if ((alidata=GBT_read_sequence(gb_species, align))) {
316	316	unsigned char c;
317	317	const unsigned char data = (const unsigned char )GB_read_char_pntr(alidata);
318	318
319		~~aw_status((double)count++/(double)nrofspecies);~~
320	319	i = 0;
321	320	while ((c=data[i])) {
…	…
334	333	gb_species = GBT_next_species(gb_species);
335	334	}
	335	++progress;
336	336	}
337	337	return (nrofspecies);
…	…
639	639
640	640	/* filling the statistic table */
641		aw_openstatus("Consensus");
	641	arb_progress progress("Calculating consensus");
	642
642	643	long nrofspecies = CON_makestatistic(statistic, convtable, align, onlymarked);
643	644	double fupper = awr->awar("con/fupper")->read_float();
…	…
694	695	}
695	696
696		~~aw_closestatus();~~
697	697	CON_cleartables(statistic, isamino);
698	698	}
…	…
929	929	isamino = GBT_is_alignment_protein(GLOBAL_gb_main, align);
930	930
931		a~~w_openstatus("Max. F~~requency");
	931	arb_progress progress("Calculating max. frequency");
932	932	long nrofspecies;
933	933
…	…
982	982
983	983	CON_cleartables(statistic, isamino);
984		~~aw_closestatus();~~
985	984	free(align);
986	985	if (error) aw_message(error);

branches/refactor/NTREE/AP_cprofile.cxx

r6858	r7097
46	46	#include <aw_window.hxx>
47	47	#include <aw_msg.hxx>
48		#include <a~~w_status.hxx~~>
	48	#include <arb_progress.h>
49	49	#include <aw_root.hxx>
50	50	#include <aw_device.hxx>
…	…
145	145	GBDATA *gb_species;
146	146
147		~~aw_status("reading database");~~
148
149		~~long nrofspecies=0~~;
150		~~gb_species = GBT_first_species_rel_species_data(gb_species_data);~~
151		~~while (gb_species)~~
152		{
153		~~if (GBT_read_sequence(gb_species, align)) {~~
154		~~nrofspecies++; }~~
155		~~gb_species = GBT_next_species(gb_species);~~
156		}
157		~~CPRO.numspecies=nrofspecies;~~
	147	{
	148	long nrofspecies=0;
	149	gb_species = GBT_first_species_rel_species_data(gb_species_data);
	150	while (gb_species)
	151	{
	152	if (GBT_read_sequence(gb_species, align)) {
	153	nrofspecies++; }
	154	gb_species = GBT_next_species(gb_species);
	155	}
	156	CPRO.numspecies=nrofspecies;
	157	}
158	158
159	159	speciesdata=(char *)calloc((size_t)CPRO.numspecies, sizeof(char ));
…	…
165	165	long countspecies=0;
166	166	gb_species = GBT_first_species_rel_species_data(gb_species_data);
167		while (gb_species)
168		{
169		if ((alidata=GBT_read_sequence(gb_species, align)))
170		{
171		speciesdatabase[countspecies++]=alidata;
	167	while (gb_species) {
	168	if ((alidata=GBT_read_sequence(gb_species, align))) {
	169	speciesdatabase[countspecies++] = alidata;
172	170	}
173	171	gb_species = GBT_next_species(gb_species);
…	…
483	481	long n = CPRO.numspecies;
484	482	long comparesneeded = n*n;
485		~~long compares = 0;~~
486	483	long numofsegments = CPRO.numspecies/widthmatrix + 1;
487		long segmentx = 0, segmenty=0, elemx=0, elemy=0;
488		long elemx1 = 0, elemx2=0, elemy1=0, elemy2=0;
489
490		if (CPRO.result[which_statistic].statisticexists)
491		{
	484
	485	if (CPRO.result[which_statistic].statisticexists) {
492	486	CPRO_freestatistic(which_statistic);
493	487	}
…	…
496	490	CPRO_allocstatistic(which_statistic);
497	491
498		aw_status("calculating");
499
500		for (segmentx=0; segmentx<numofsegments; segmentx++)
501		{
502		elemx1=widthmatrix*segmentx;
503		elemx2=widthmatrix*(segmentx+1)-1;
504		for (segmenty=0; segmenty<numofsegments; segmenty++)
505		{
506		elemy1=widthmatrix*segmenty;
507		elemy2=widthmatrix*(segmenty+1)-1;
	492	arb_progress progress("calculating matrix", comparesneeded);
	493	bool aborted = false;
	494
	495	for (long segmentx=0; segmentx<numofsegments && !aborted; segmentx++) {
	496	long elemx1 = widthmatrix*segmentx;
	497	long elemx2 = widthmatrix*(segmentx+1)-1;
	498
	499	for (long segmenty=0; segmenty<numofsegments && !aborted; segmenty++) {
	500	long elemy1 = widthmatrix*segmenty;
	501	long elemy2 = widthmatrix*(segmenty+1)-1;
	502
508	503	CPRO_readneededdata(speciesdata, speciesdatabase, elemx1, elemx2, elemy1, elemy2, which_statistic);
509		for (elemx=elemx1; elemx<=elemx2; elemx++)
510		{
511		for (elemy=elemy1; elemy<=elemy2; elemy++)
512		{
513		if ((elemy<CPRO.numspecies)&&(elemx<CPRO.numspecies))
514		{
515		CPRO_entryinstatistic(speciesdata,
516		elemx, elemy, which_statistic);
517		compares++;
518		if (((compares/30)*30)==compares)
519		{
520		if (aw_status((double)compares
521		/(double)comparesneeded)) return (0);
522		}
	504	for (long elemx=elemx1; elemx<=elemx2 && !aborted; elemx++) {
	505	for (long elemy=elemy1; elemy<=elemy2 && !aborted; elemy++) {
	506	if ((elemy<CPRO.numspecies)&&(elemx<CPRO.numspecies)) {
	507	CPRO_entryinstatistic(speciesdata, elemx, elemy, which_statistic);
	508	++progress;
	509	aborted = progress.aborted();
523	510	}
524	511	}
…	…
600	587	CPRO.result[which_statistic].maxalignlen = GBT_get_alignment_len(GLOBAL_gb_main, align);
601	588	if (CPRO.result[which_statistic].maxalignlen<=0) {
	589	GB_clear_error();
602	590	GB_pop_transaction(GLOBAL_gb_main);
603	591	aw_message("Error: Select an alignment !");
…	…
607	595
608	596	char isamino = GBT_is_alignment_protein(GLOBAL_gb_main, align);
609		a~~w_openstatus("calculating"); aw_status((double)0~~);
	597	arb_progress progress("Calculating conservation profile");
610	598
611	599	GBDATA **speciesdatabase; // array of GBDATA-pointers to the species
…	…
629	617
630	618	/* fill the CPRO.statistic table */
631		~~char success=~~CPRO_makestatistic(speciesdata, speciesdatabase, (char)which_statistic);
	619	CPRO_makestatistic(speciesdata, speciesdatabase, (char)which_statistic);
632	620	// GBUSE(success);
633	621	CPRO_workupstatistic((char)which_statistic);
634
635		~~aw_closestatus();~~
636	622
637	623	CPRO_deallocate(speciesdata, speciesdatabase);
…	…
649	635	static void CPRO_memrequirement_cb(AW_root *aw_root)
650	636	{
651		char *align=aw_root->awar("cpro/alignment")->read_string();
652		char *marked=aw_root->awar("cpro/which_species")->read_string();
653		char versus=0; /* all vs all */
654		if (!(strcmp("marked", marked))) versus=1;
655		if (!(strcmp("markedall", marked))) versus=2;
656		free(marked);
657		CPRO.partition=aw_root->awar("cpro/partition")->read_int();
658		if (CPRO.partition<=0) CPRO.partition=1;
659		long resolution=aw_root->awar("cpro/resolution")->read_int();
660		if (resolution<=0) resolution=1;
	637	char versus = 0; /* all vs all */
	638	{
	639	char *marked = aw_root->awar("cpro/which_species")->read_string();
	640
	641	if (!(strcmp("marked", marked))) versus = 1;
	642	if (!(strcmp("markedall", marked))) versus = 2;
	643	free(marked);
	644	}
	645
	646	CPRO.partition = aw_root->awar("cpro/partition")->read_int();
	647	long resolution = aw_root->awar("cpro/resolution")->read_int();
	648
	649	if (CPRO.partition<=0) CPRO.partition = 1;
	650	if (resolution<=0) resolution = 1;
	651
661	652	char buf[80];
662		~~GB_ERROR faultmessage;~~
663	653
664	654	aw_root->awar("tmp/cpro/which1")->write_string(CPRO.result[0].which_species);
…	…
686	676	}
687	677
688		if ((faultmessage=GB_push_transaction(GLOBAL_gb_main))) {
689		aw_question(faultmessage, "OK,EXIT");
	678	long len;
	679	{
	680	GB_transaction ta(GLOBAL_gb_main);
	681	char *align = aw_root->awar("cpro/alignment")->read_string();
	682
	683	len = GBT_get_alignment_len(GLOBAL_gb_main, align);
690	684	free(align);
691		return;
692		}
693
694		long len=GBT_get_alignment_len(GLOBAL_gb_main, align);
	685	}
695	686
696	687	if (len<=0) {
697		GB_~~pop_transaction(GLOBAL_gb_main~~);
	688	GB_clear_error();
698	689	aw_root->awar("tmp/cpro/mempartition")->write_string("???");
699	690	aw_root->awar("tmp/cpro/memstatistic")->write_string("???");
700		free(align);
701		return;
702		}
703
704		long mem;
705
706		mem=CPRO.partitionlen2; // *2, because of row and column in matrix
707		sprintf(buf, "%li KB", long(mem/1024));
708		aw_root->awar("tmp/cpro/mempartition")->write_string(buf);
709
710		mem+=resolution3sizeof(STATTYPE)*len;
711		sprintf(buf, "%li KB", long(mem/1024));
712		aw_root->awar("tmp/cpro/memstatistic")->write_string(buf);
713
714		free(align);
715		if ((faultmessage=GB_pop_transaction(GLOBAL_gb_main)))
716		{
717		aw_question(faultmessage, "OK,EXIT");
718		return;
	691	}
	692	else {
	693	long mem;
	694
	695	mem=CPRO.partitionlen2; // *2, because of row and column in matrix
	696	sprintf(buf, "%li KB", long(mem/1024));
	697	aw_root->awar("tmp/cpro/mempartition")->write_string(buf);
	698
	699	mem+=resolution3sizeof(STATTYPE)*len;
	700	sprintf(buf, "%li KB", long(mem/1024));
	701	aw_root->awar("tmp/cpro/memstatistic")->write_string(buf);
719	702	}
720	703	}
…	…
1342	1325	}
1343	1326
1344		a~~w_openstatus("condense statistic"); aw_status((double)0~~);
	1327	arb_progress progress("condense statistic", maxcol);
1345	1328
1346	1329	char result=(char )calloc((unsigned int)maxcol+1, 1);
…	…
1351	1334	for (long column=0; column<maxcol; column++)
1352	1335	{
1353		~~if (((column/100)*100)==column) aw_status((double)column/(double)maxcol);~~
1354	1336	maximum=CPRO_getmaximum(column, transversion, (char)which_statistic, mode);
1355	1337	if (maximum<-100.0) result[column]='.';
…	…
1365	1347	result[column]+=steps;
1366	1348	}
	1349	++progress;
1367	1350	}
1368	1351
1369	1352	GB_ERROR error = 0;
1370	1353	char *align=CPRO.result[which_statistic].alignname;
1371
1372		~~aw_status("exporting result");~~
1373	1354
1374	1355	GB_begin_transaction(GLOBAL_gb_main);
…	…
1390	1371
1391	1372	error = GB_write_string(gb_data, result);
1392		~~aw_closestatus();~~
1393	1373	GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message);
1394	1374

branches/refactor/NTREE/AP_pos_var_pars.cxx

r6858	r7097
14	14	#include <awt_sel_boxes.hxx>
15	15	#include <aw_window.hxx>
16		#include <a~~w_status.hxx~~>
	16	#include <arb_progress.h>
17	17	#include <aw_root.hxx>
18	18	#include <aw_awar.hxx>
…	…
30	30	AP_pos_var::AP_pos_var(GBDATA gb_maini, char ali_namei, long ali_leni, int isdna, char *tree_namei) {
31	31	memset((char *)this, 0, sizeof(AP_pos_var));
32		this->gb_main = gb_maini;
33		this->ali_name = strdup(ali_namei);
34		this->is_dna = isdna;
35		this->ali_len = ali_leni;
36		this->tree_name = strdup(tree_namei);
	32	gb_main = gb_maini;
	33	ali_name = strdup(ali_namei);
	34	is_dna = isdna;
	35	ali_len = ali_leni;
	36	tree_name = strdup(tree_namei);
	37	progress = NULL;
37	38	}
38	39
39	40	AP_pos_var::~AP_pos_var() {
	41	delete progress;
40	42	free(ali_name);
41	43	free(tree_name);
42	44	free(transitions);
43	45	free(transversions);
44		int i;
45		for (i=0; i<256; i++) free(frequencies[i]);
46		}
47
48		long AP_pos_var::getsize(GBT_TREE *tree) {
	46	for (int i=0; i<256; i++) free(frequencies[i]);
	47	}
	48
	49	long AP_pos_var::getsize(GBT_TREE *tree) {
49	50	if (!tree) return 0;
50	51	if (tree->is_leaf) return 1;
…	…
54	55	const char AP_pos_var::parsimony(GBT_TREE tree, GB_UINT4 bases, GB_UINT4 tbases) {
55	56	GB_ERROR error = 0;
56		~~timer ++;~~
57		~~long i;~~
58		~~long l, r;~~
59	57
60	58	if (tree->is_leaf) {
61		unsigned char *sequence;
62		long seq_len = ali_len;
63		if (!tree->gb_node) return 0; // zombie
64
65		GBDATA *gb_data = GBT_read_sequence(tree->gb_node, ali_name);
66		if (!gb_data) return 0; // no sequence
67		if (GB_read_string_count(gb_data) < seq_len)
68		seq_len = GB_read_string_count(gb_data);
69		sequence = (unsigned char*)GB_read_char_pntr(gb_data);
70
71		for (i = 0; i< seq_len; i++) {
72		l = char_2_freq[sequence[i]];
73		if (l) {
74		ap_assert(frequencies[l]);
75		frequencies[l][i]++;
76		}
77		}
78
79		if (bases) {
80		for (i = 0; i< seq_len; i++) bases[i] = char_2_transition[sequence[i]];
81		}
82		if (tbases) {
83		for (i = 0; i< seq_len; i++) tbases[i] = char_2_transversion[sequence[i]];
84		}
85		return 0;
86		}
87		if (aw_status(timer/(double)treesize)) return "Operation aborted";
88
89		GB_UINT4 ls = (GB_UINT4 )calloc(sizeof(GB_UINT4), (int)ali_len);
90		GB_UINT4 rs = (GB_UINT4 )calloc(sizeof(GB_UINT4), (int)ali_len);
91		GB_UINT4 lts = (GB_UINT4 )calloc(sizeof(GB_UINT4), (int)ali_len);
92		GB_UINT4 rts = (GB_UINT4 )calloc(sizeof(GB_UINT4), (int)ali_len);
93
94		if (!error) error = this->parsimony(tree->leftson, ls, lts);
95		if (!error) error = this->parsimony(tree->rightson, rs, rts);
96		if (!error) {
97		for (i=0; i< ali_len; i++) {
98		l = ls[i];
99		r = rs[i];
100		if (l & r) {
101		if (bases) bases[i] = l&r;
102		}
103		else {
104		transitions[i] ++;
105		if (bases) bases[i] = l\|r;
106		}
107		l = lts[i];
108		r = rts[i];
109		if (l & r) {
110		if (tbases) tbases[i] = l&r;
111		}
112		else {
113		transversions[i] ++;
114		if (tbases) tbases[i] = l\|r;
115		}
116		}
117		}
118
119		free(lts);
120		free(rts);
121
122		free(ls);
123		free(rs);
	59	if (tree->gb_node) {
	60	GBDATA *gb_data = GBT_read_sequence(tree->gb_node, ali_name);
	61	if (gb_data) {
	62	long seq_len = ali_len;
	63	if (GB_read_string_count(gb_data) < seq_len) {
	64	seq_len = GB_read_string_count(gb_data);
	65	}
	66
	67	unsigned char sequence = (unsigned char)GB_read_char_pntr(gb_data);
	68	for (long i = 0; i< seq_len; i++) {
	69	long L = char_2_freq[sequence[i]];
	70	if (L) {
	71	ap_assert(frequencies[L]);
	72	frequencies[L][i]++;
	73	}
	74	}
	75
	76	if (bases) {
	77	for (long i = 0; i< seq_len; i++) bases[i] = char_2_transition[sequence[i]];
	78	}
	79	if (tbases) {
	80	for (long i = 0; i< seq_len; i++) tbases[i] = char_2_transversion[sequence[i]];
	81	}
	82	}
	83	}
	84	}
	85	else {
	86	GB_UINT4 ls = (GB_UINT4 )calloc(sizeof(GB_UINT4), (int)ali_len);
	87	GB_UINT4 rs = (GB_UINT4 )calloc(sizeof(GB_UINT4), (int)ali_len);
	88	GB_UINT4 lts = (GB_UINT4 )calloc(sizeof(GB_UINT4), (int)ali_len);
	89	GB_UINT4 rts = (GB_UINT4 )calloc(sizeof(GB_UINT4), (int)ali_len);
	90
	91	if (!error) error = this->parsimony(tree->leftson, ls, lts);
	92	if (!error) error = this->parsimony(tree->rightson, rs, rts);
	93	if (!error) {
	94	for (long i=0; i< ali_len; i++) {
	95	long l = ls[i];
	96	long r = rs[i];
	97	if (l & r) {
	98	if (bases) bases[i] = l&r;
	99	}
	100	else {
	101	transitions[i] ++;
	102	if (bases) bases[i] = l\|r;
	103	}
	104	l = lts[i];
	105	r = rts[i];
	106	if (l & r) {
	107	if (tbases) tbases[i] = l&r;
	108	}
	109	else {
	110	transversions[i] ++;
	111	if (tbases) tbases[i] = l\|r;
	112	}
	113	}
	114	}
	115
	116	free(lts);
	117	free(rts);
	118
	119	free(ls);
	120	free(rs);
	121	}
	122	progress->inc_and_check_user_abort(error);
124	123	return error;
125	124	}
…	…
166	165	}
167	166	}
168		t~~his->treesize = this->~~getsize(tree);
169		~~this->timer = 0~~;
	167	treesize = getsize(tree);
	168	progress = new arb_progress(treesize);
170	169
171	170	for (i=0; i<256; i++) {
…	…
305	304	GB_ERROR error = 0;
306	305
307		a~~w_openstatu~~s("Calculating positional variability");
308		~~aw_status~~("Loading Tree");
	306	arb_progress progress("Calculating positional variability");
	307	progress.subtitle("Loading Tree");
309	308	GBT_TREE *tree;
310	309	{ // get tree
…	…
320	319
321	320	if (!error) {
322		~~aw_status("Counting M~~utations");
	321	progress.subtitle("Counting mutations");
323	322
324	323	char *ali_name = GBT_get_default_alignment(GLOBAL_gb_main);
…	…
346	345	free(tree_name);
347	346
348		~~aw_closestatus();~~
349
350	347	if (error) aw_message(error);
351	348	return;

branches/refactor/NTREE/Makefile

r7093	r7097
132	132	ad_spec.o: $(ARBHOME)/INCLUDE/arb_error.h
133	133	ad_spec.o: $(ARBHOME)/INCLUDE/arb_msg.h
	134	ad_spec.o: $(ARBHOME)/INCLUDE/arb_progress.h
134	135	ad_spec.o: $(ARBHOME)/INCLUDE/arb_str.h
135	136	ad_spec.o: $(ARBHOME)/INCLUDE/arb_string.h
…	…
153	154	ad_spec.o: $(ARBHOME)/INCLUDE/aw_root.hxx
154	155	ad_spec.o: $(ARBHOME)/INCLUDE/aw_select.hxx
155		~~ad_spec.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
156	156	ad_spec.o: $(ARBHOME)/INCLUDE/aw_window.hxx
157	157	ad_spec.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
181	181	ad_transpro.o: $(ARBHOME)/INCLUDE/arb_error.h
182	182	ad_transpro.o: $(ARBHOME)/INCLUDE/arb_msg.h
	183	ad_transpro.o: $(ARBHOME)/INCLUDE/arb_progress.h
183	184	ad_transpro.o: $(ARBHOME)/INCLUDE/arb_string.h
184	185	ad_transpro.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
193	194	ad_transpro.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
194	195	ad_transpro.o: $(ARBHOME)/INCLUDE/aw_root.hxx
195		~~ad_transpro.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
196	196	ad_transpro.o: $(ARBHOME)/INCLUDE/aw_window.hxx
197	197	ad_transpro.o: $(ARBHOME)/INCLUDE/awt_sel_boxes.hxx
…	…
240	240	AP_consensus.o: $(ARBHOME)/INCLUDE/arb_error.h
241	241	AP_consensus.o: $(ARBHOME)/INCLUDE/arb_msg.h
	242	AP_consensus.o: $(ARBHOME)/INCLUDE/arb_progress.h
242	243	AP_consensus.o: $(ARBHOME)/INCLUDE/arb_string.h
243	244	AP_consensus.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
251	252	AP_consensus.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
252	253	AP_consensus.o: $(ARBHOME)/INCLUDE/aw_root.hxx
253		~~AP_consensus.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
254	254	AP_consensus.o: $(ARBHOME)/INCLUDE/aw_window.hxx
255	255	AP_consensus.o: $(ARBHOME)/INCLUDE/awt_sel_boxes.hxx
…	…
291	291	AP_cprofile.o: $(ARBHOME)/INCLUDE/arb_error.h
292	292	AP_cprofile.o: $(ARBHOME)/INCLUDE/arb_msg.h
	293	AP_cprofile.o: $(ARBHOME)/INCLUDE/arb_progress.h
293	294	AP_cprofile.o: $(ARBHOME)/INCLUDE/arb_string.h
294	295	AP_cprofile.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
306	307	AP_cprofile.o: $(ARBHOME)/INCLUDE/aw_position.hxx
307	308	AP_cprofile.o: $(ARBHOME)/INCLUDE/aw_root.hxx
308		~~AP_cprofile.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
309	309	AP_cprofile.o: $(ARBHOME)/INCLUDE/aw_window.hxx
310	310	AP_cprofile.o: $(ARBHOME)/INCLUDE/awt_sel_boxes.hxx
…	…
322	322	AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/arb_error.h
323	323	AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/arb_msg.h
	324	AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/arb_progress.h
324	325	AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/arb_string.h
325	326	AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
333	334	AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
334	335	AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/aw_root.hxx
335		~~AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
336	336	AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/aw_window.hxx
337	337	AP_pos_var_pars.o: $(ARBHOME)/INCLUDE/awt_sel_boxes.hxx
…	…
409	409	NT_concatenate.o: $(ARBHOME)/INCLUDE/arb_error.h
410	410	NT_concatenate.o: $(ARBHOME)/INCLUDE/arb_msg.h
	411	NT_concatenate.o: $(ARBHOME)/INCLUDE/arb_progress.h
411	412	NT_concatenate.o: $(ARBHOME)/INCLUDE/arb_string.h
412	413	NT_concatenate.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
440	441	NT_dbrepair.o: $(ARBHOME)/INCLUDE/arb_error.h
441	442	NT_dbrepair.o: $(ARBHOME)/INCLUDE/arb_msg.h
	443	NT_dbrepair.o: $(ARBHOME)/INCLUDE/arb_progress.h
442	444	NT_dbrepair.o: $(ARBHOME)/INCLUDE/arb_str.h
443	445	NT_dbrepair.o: $(ARBHOME)/INCLUDE/arb_string.h
…	…
452	454	NT_dbrepair.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
453	455	NT_dbrepair.o: $(ARBHOME)/INCLUDE/aw_root.hxx
454		~~NT_dbrepair.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
455	456	NT_dbrepair.o: $(ARBHOME)/INCLUDE/aw_window.hxx
456	457	NT_dbrepair.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
507	508	NT_extern.o: $(ARBHOME)/INCLUDE/arb_error.h
508	509	NT_extern.o: $(ARBHOME)/INCLUDE/arb_msg.h
	510	NT_extern.o: $(ARBHOME)/INCLUDE/arb_progress.h
509	511	NT_extern.o: $(ARBHOME)/INCLUDE/arb_string.h
510	512	NT_extern.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
528	530	NT_extern.o: $(ARBHOME)/INCLUDE/AW_rename.hxx
529	531	NT_extern.o: $(ARBHOME)/INCLUDE/aw_root.hxx
530		~~NT_extern.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
531	532	NT_extern.o: $(ARBHOME)/INCLUDE/aw_window.hxx
532	533	NT_extern.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
618	619	NT_join.o: $(ARBHOME)/INCLUDE/arb_error.h
619	620	NT_join.o: $(ARBHOME)/INCLUDE/arb_msg.h
	621	NT_join.o: $(ARBHOME)/INCLUDE/arb_progress.h
620	622	NT_join.o: $(ARBHOME)/INCLUDE/arb_string.h
621	623	NT_join.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
631	633	NT_join.o: $(ARBHOME)/INCLUDE/aw_root.hxx
632	634	NT_join.o: $(ARBHOME)/INCLUDE/aw_select.hxx
633		~~NT_join.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
634	635	NT_join.o: $(ARBHOME)/INCLUDE/aw_window.hxx
635	636	NT_join.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
656	657	NT_main.o: $(ARBHOME)/INCLUDE/arb_error.h
657	658	NT_main.o: $(ARBHOME)/INCLUDE/arb_msg.h
	659	NT_main.o: $(ARBHOME)/INCLUDE/arb_progress.h
658	660	NT_main.o: $(ARBHOME)/INCLUDE/arb_string.h
659	661	NT_main.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
677	679	NT_main.o: $(ARBHOME)/INCLUDE/aw_question.hxx
678	680	NT_main.o: $(ARBHOME)/INCLUDE/aw_root.hxx
679		~~NT_main.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
680	681	NT_main.o: $(ARBHOME)/INCLUDE/aw_window.hxx
681	682	NT_main.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
699	700	NT_sort.o: $(ARBHOME)/INCLUDE/arb_error.h
700	701	NT_sort.o: $(ARBHOME)/INCLUDE/arb_msg.h
	702	NT_sort.o: $(ARBHOME)/INCLUDE/arb_progress.h
701	703	NT_sort.o: $(ARBHOME)/INCLUDE/arb_string.h
702	704	NT_sort.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
711	713	NT_sort.o: $(ARBHOME)/INCLUDE/aw_root.hxx
712	714	NT_sort.o: $(ARBHOME)/INCLUDE/aw_select.hxx
713		~~NT_sort.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
714	715	NT_sort.o: $(ARBHOME)/INCLUDE/aw_window.hxx
715	716	NT_sort.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
727	728	NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/arb_error.h
728	729	NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/arb_msg.h
	730	NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/arb_progress.h
729	731	NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/arb_string.h
730	732	NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
738	740	NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
739	741	NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/aw_root.hxx
740		~~NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
741	742	NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/aw_window.hxx
742	743	NT_trackAliChanges.o: $(ARBHOME)/INCLUDE/awt_sel_boxes.hxx
…	…
756	757	NT_tree_cmp.o: $(ARBHOME)/INCLUDE/arb_error.h
757	758	NT_tree_cmp.o: $(ARBHOME)/INCLUDE/arb_msg.h
	759	NT_tree_cmp.o: $(ARBHOME)/INCLUDE/arb_progress.h
758	760	NT_tree_cmp.o: $(ARBHOME)/INCLUDE/arb_string.h
759	761	NT_tree_cmp.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
766	768	NT_tree_cmp.o: $(ARBHOME)/INCLUDE/aw_color_groups.hxx
767	769	NT_tree_cmp.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
768		~~NT_tree_cmp.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
769	770	NT_tree_cmp.o: $(ARBHOME)/INCLUDE/downcast.h
770	771	NT_tree_cmp.o: $(ARBHOME)/INCLUDE/dupstr.h

branches/refactor/NTREE/NT_concatenate.cxx

r6858	r7097
21	21	#include <aw_msg.hxx>
22	22	#include <aw_root.hxx>
	23	#include <arb_progress.h>
23	24
24	25	#define nt_assert(bed) arb_assert(bed)
…	…
271	272	/* ---------------------------------------- Concatenation function ---------------------------------- */
272	273	void concatenateAlignments(AW_window *aws) {
273
274	274	GB_push_transaction(GLOBAL_gb_main);
	275	arb_progress progress("Concatenating alignments", GBT_count_marked_species(GLOBAL_gb_main));
275	276	AW_root *aw_root = aws->get_root();
276	277
…	…
318	319	AW_repeated_question ask_about_missing_alignment;
319	320
320		for (GBDATA *gb_species = GBT_first_marked_species(GLOBAL_gb_main); gb_species; gb_species = GBT_next_marked_species(gb_species)) {
	321	for (GBDATA *gb_species = GBT_first_marked_species(GLOBAL_gb_main);
	322	gb_species && !error;
	323	gb_species = GBT_next_marked_species(gb_species))
	324	{
321	325	GBS_strstruct str_seq = GBS_stropen(new_alignment_len+1000); / create output stream */
322	326	int ali_len = 0;
…	…
355	359	free(concatenated_ali_seq_data);
356	360	}
357		}
358
359		{ /* ............. print missing alignments........... */
	361	progress.inc_and_check_user_abort(error);
	362	}
	363
	364	if (!error) {
	365	/* ............. print missing alignments........... */
360	366	aw_message(GBS_global_string("Concatenation of Alignments was performed for %ld species.", GBT_count_marked_species(GLOBAL_gb_main)));
361	367	const_ali_name = con_alignment_list->first_element(); int i = 0;
…	…
570	576	char *full_name = 0;
571	577	char *acc = 0;
572		~~char *addid = 0;~~
573	578
574	579	/* --------------------getting the species related data -------------------- */
…	…
625	630	const char *add_field = AW_get_nameserver_addid(GLOBAL_gb_main);
626	631	GBDATA *gb_addid = add_field[0] ? GB_entry(gb_new_species, add_field) : 0;
627		if (gb_addid) addid = GB_read_string(gb_addid);
628
629		error = AWTC_generate_one_name(GLOBAL_gb_main, full_name, acc, addid, new_species_name, false, true);
	632	char *addid = 0;
	633	if (gb_addid) addid = GB_read_as_string(gb_addid);
	634
	635	error = AWTC_generate_one_name(GLOBAL_gb_main, full_name, acc, addid, new_species_name);
630	636	if (!error) { // name was created
631	637	if (GBT_find_species_rel_species_data(gb_species_data, new_species_name) != 0) {
…	…
640	646
641	647	free(new_species_name);
	648	free(addid);
642	649	}
643	650
…	…
648	655	}
649	656
650		~~free(addid);~~
651	657	free(acc);
652	658	free(full_name);
…	…
670	676
671	677	static void mergeSimilarSpecies(AW_window *aws, AW_CL cl_mergeSimilarConcatenateAlignments) {
672		AW_root *aw_root = aws->get_root();
673		char *merge_field_name = aw_root->awar(AWAR_CON_MERGE_FIELD)->read_string();
674		char *new_field_name = aw_root->awar(AWAR_CON_STORE_SIM_SP_NO)->read_string();
675
676		speciesConcatenateList scl = 0; // to build list of similar species
677		speciesConcatenateList newSpeciesList = 0; // new SPECIES_ConcatenateList
678
679		GB_begin_transaction(GLOBAL_gb_main); // open database for transaction
680
681		GB_ERROR error = checkAndCreateNewField(GLOBAL_gb_main, new_field_name);
682
683		for (GBDATA * gb_species = GBT_first_marked_species(GLOBAL_gb_main);
684		gb_species && !error;
685		gb_species = GBT_next_marked_species(gb_species))
	678	GB_ERROR error = NULL;
	679	arb_progress wrapper;
686	680	{
687		GBDATA *gb_species_field = GB_entry(gb_species, merge_field_name);
688		const char *name = GBT_read_name(gb_species);
689
690		if (!gb_species_field) {
691		// exit if species doesn't have any data in the selected field
692		error = GBS_global_string("Species '%s' does not contain data in selected field '%s'", name, merge_field_name);
693		}
694		else {
695		char *gb_species_field_content = GB_read_string(gb_species_field);
696		int similar_species = 0;
697
698		for (GBDATA * gb_species_next = GBT_next_marked_species(gb_species);
699		gb_species_next && !error;
700		gb_species_next = GBT_next_marked_species(gb_species_next))
701		{
702		GBDATA *gb_next_species_field = GB_entry(gb_species_next, merge_field_name);
703		const char *next_name = GBT_read_name(gb_species_next);
704
705		if (!gb_next_species_field) {
706		// exit if species doesn't have any data in the selected field
707		error = GBS_global_string("Species '%s' does not contain data in selected field '%s'", next_name, merge_field_name);
	681	AW_root *aw_root = aws->get_root();
	682	char *merge_field_name = aw_root->awar(AWAR_CON_MERGE_FIELD)->read_string();
	683	char *new_field_name = aw_root->awar(AWAR_CON_STORE_SIM_SP_NO)->read_string();
	684
	685	speciesConcatenateList scl = 0; // to build list of similar species
	686	speciesConcatenateList newSpeciesList = 0; // new SPECIES_ConcatenateList
	687
	688	GB_begin_transaction(GLOBAL_gb_main); // open database for transaction
	689
	690	error = checkAndCreateNewField(GLOBAL_gb_main, new_field_name);
	691
	692	PersistentNameServerConnection stayAlive;
	693	arb_progress progress("Merging similar species", GBT_count_marked_species(GLOBAL_gb_main));
	694	progress.auto_subtitles("Species");
	695
	696	for (GBDATA * gb_species = GBT_first_marked_species(GLOBAL_gb_main);
	697	gb_species && !error;
	698	gb_species = GBT_next_marked_species(gb_species))
	699	{
	700	GBDATA *gb_species_field = GB_entry(gb_species, merge_field_name);
	701	const char *name = GBT_read_name(gb_species);
	702
	703	if (!gb_species_field) {
	704	// exit if species doesn't have any data in the selected field
	705	error = GBS_global_string("Species '%s' does not contain data in selected field '%s'", name, merge_field_name);
	706	}
	707	else {
	708	char *gb_species_field_content = GB_read_string(gb_species_field);
	709	int similar_species = 0;
	710
	711	for (GBDATA * gb_species_next = GBT_next_marked_species(gb_species);
	712	gb_species_next && !error;
	713	gb_species_next = GBT_next_marked_species(gb_species_next))
	714	{
	715	GBDATA *gb_next_species_field = GB_entry(gb_species_next, merge_field_name);
	716	const char *next_name = GBT_read_name(gb_species_next);
	717
	718	if (!gb_next_species_field) {
	719	// exit if species doesn't have any data in the selected field
	720	error = GBS_global_string("Species '%s' does not contain data in selected field '%s'", next_name, merge_field_name);
	721	}
	722	else {
	723	char *gb_next_species_field_content = GB_read_string(gb_next_species_field);
	724
	725	if (strcmp(gb_species_field_content, gb_next_species_field_content) == 0) {
	726	addSpeciesToConcatenateList(&scl, next_name);
	727	GB_write_flag(gb_species_next, 0);
	728	++similar_species;
	729	++progress;
	730	}
	731	free(gb_next_species_field_content);
	732	}
708	733	}
709		else {
710		char *gb_next_species_field_content = GB_read_string(gb_next_species_field);
711
712		if (strcmp(gb_species_field_content, gb_next_species_field_content) == 0) {
713		addSpeciesToConcatenateList(&scl, next_name);
714		GB_write_flag(gb_species_next, 0);
715		++similar_species;
	734
	735	if (similar_species > 0 && !error) {
	736	addSpeciesToConcatenateList(&scl, name);
	737	GB_write_flag(gb_species, 0);
	738
	739	GBDATA *new_species_created = concatenateFieldsCreateNewSpecies(aws, gb_species, scl);
	740
	741	nt_assert(new_species_created);
	742	if (new_species_created) { // create a list of newly created species
	743	addSpeciesToConcatenateList(&newSpeciesList, GBT_read_name(new_species_created));
716	744	}
717		free(gb_next_species_field_content);
	745
	746	error = GBT_write_int(new_species_created, new_field_name, ++similar_species);
718	747	}
719		}
720
721		if (similar_species > 0 && !error) {
722		addSpeciesToConcatenateList(&scl, name);
723		GB_write_flag(gb_species, 0);
724
725		GBDATA *new_species_created = concatenateFieldsCreateNewSpecies(aws, gb_species, scl);
726
727		nt_assert(new_species_created);
728		if (new_species_created) { // create a list of newly created species
729		addSpeciesToConcatenateList(&newSpeciesList, GBT_read_name(new_species_created));
730		}
731
732		error = GBT_write_int(new_species_created, new_field_name, ++similar_species);
733		}
734
735		freeSpeciesConcatenateList(scl); scl = 0;
736		free(gb_species_field_content);
737		}
738		}
739
740		if (!error) {
741		GBT_mark_all(GLOBAL_gb_main, 0); // unmark all species in the database
742		int newSpeciesCount = 0;
743
744		for (; newSpeciesList; newSpeciesList = newSpeciesList->next) { // mark only newly created species
745		GB_write_flag(newSpeciesList->species, 1);
746		newSpeciesCount++;
747		}
748		aw_message(GBS_global_string("%i new species were created by taking \"%s\" as a criterion!", newSpeciesCount, merge_field_name));
749		freeSpeciesConcatenateList(newSpeciesList);
750		}
751
752		free(merge_field_name);
753		free(new_field_name);
754
755		GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message);
756
	748
	749	freeSpeciesConcatenateList(scl); scl = 0;
	750	free(gb_species_field_content);
	751	}
	752
	753	progress.inc_and_check_user_abort(error);
	754	}
	755
	756	if (!error) {
	757	GBT_mark_all(GLOBAL_gb_main, 0); // unmark all species in the database
	758	int newSpeciesCount = 0;
	759
	760	for (; newSpeciesList; newSpeciesList = newSpeciesList->next) { // mark only newly created species
	761	GB_write_flag(newSpeciesList->species, 1);
	762	newSpeciesCount++;
	763	}
	764	aw_message(GBS_global_string("%i new species were created by taking \"%s\" as a criterion!", newSpeciesCount, merge_field_name));
	765	freeSpeciesConcatenateList(newSpeciesList);
	766	}
	767
	768	free(merge_field_name);
	769	free(new_field_name);
	770
	771	GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message);
	772	}
757	773	// Concatenate alignments of the merged species if cl_mergeSimilarConcatenateAlignments = MERGE_SIMILAR_CONCATENATE_ALIGNMENTS
758	774	if (int (cl_mergeSimilarConcatenateAlignments) && !error) concatenateAlignments(aws);

branches/refactor/NTREE/NT_dbrepair.cxx

r6858	r7097
20	20	#include <aw_color_groups.hxx>
21	21	#include <aw_msg.hxx>
22		#include <a~~w_status.hxx~~>
	22	#include <arb_progress.h>
23	23	#include <aw_root.hxx>
24	24
…	…
107	107	{
108	108	if (!error && !was_performed(check_name)) {
109		aw_status(check_name.c_str());
110		aw_status(0.0);
	109	arb_progress progress(check_name.c_str());
111	110	error = do_check(gb_main, species_count, sai_count);
112		~~aw_status(1.0);~~
113	111	if (!error) register_as_performed(check_name);
114	112	}
…	…
193	191	static GB_ERROR NT_fix_gene_data(GBDATA gb_main, size_t species_count, size_t / sai_count */) {
194	192	GB_transaction ta(gb_main);
195		size_t deleted_gene_datas = 0;
196		size_t generated_gene_datas = 0;
197		GB_ERROR error = 0;
198		size_t count = 0;
	193	arb_progress progress(species_count);
	194
	195	size_t deleted_gene_datas = 0;
	196	size_t generated_gene_datas = 0;
	197	GB_ERROR error = 0;
199	198
200	199	for (GBDATA *gb_species = GBT_first_species(gb_main);
…	…
224	223	}
225	224
226		~~aw_status(double(++count)/species_count~~);
	225	progress.inc_and_check_user_abort(error);
227	226	}
228	227
…	…
268	267	typedef vector<GBDATA*> GBvec;
269	268	GBvec toDelete;
270		size_t count = 0;
271
	269
	270	arb_progress progress(species_count);
	271
272	272	for (GBDATA *gb_organism = GEN_first_organism(gb_main);
273	273	gb_organism && !error;
274	274	gb_organism = GEN_next_organism(gb_organism))
275	275	{
276
277
278	276	GBDATA *gb_gene_data = GEN_find_gene_data(gb_organism);
279	277	nt_assert(gb_gene_data);
…	…
449	447	}
450	448
451		~~aw_status(double(++count)/species_count~~);
	449	progress.inc_and_check_user_abort(error);
452	450	}
453	451
…	…
474	472	GB_transaction ta(gb_main);
475	473	GB_ERROR error = 0;
476		~~size_t count = 0;~~
477	474	size_t all = species_count+sai_count;
478	475	size_t removed = 0;
…	…
480	477	// delete 'mark' entries from all alignments of species/SAIs
481	478
	479	arb_progress progress(all);
482	480	char **ali_names = GBT_get_alignment_names(gb_main);
483	481
…	…
498	496	}
499	497
500		~~aw_status(double(++count)/all~~);
	498	progress.inc_and_check_user_abort(error);
501	499	}
502	500	}
…	…
773	771	Dict::gb_main = gb_main;
774	772
775		~~aw_status(STATUS_PREFIX "init");~~
776		~~aw_status(0.0);~~
777
778	773	if (!gb_key_data) {
779	774	error = "No @key_data found.. DB corrupted?";
…	…
794	789	if (!error) {
795	790	// check which keys are compressed
796		int cnt = 0;
797		aw_status(STATUS_PREFIX "search compression");
798		aw_status(0.0);
799		for (Keys::iterator ki = keys.begin(); ki != keys.end(); ++ki) {
800		KeyInfoPtr k = ki->second;
801		k->testCompressed(gb_main);
802		aw_status(++cnt/double(affectedKeys));
	791
	792	{
	793	arb_progress progress(STATUS_PREFIX "search compressed data", affectedKeys);
	794
	795	for (Keys::iterator ki = keys.begin(); ki != keys.end(); ++ki) {
	796	KeyInfoPtr k = ki->second;
	797	k->testCompressed(gb_main);
	798	++progress;
	799	}
803	800	}
804	801
805	802	// test which key/dict combinations work
806		aw_status(STATUS_PREFIX "test compression");
807		aw_status(0.0);
808		cnt = 0;
809		int combinations = 0; // possible key/dict combinations
	803	int combinations = 0; // possible key/dict combinations
810	804
811	805	DictMap use; // keyname -> dictionary (which dictionary to use)
…	…
813	807
814	808	for (int pass = 1; pass <= 2; ++pass) {
	809	arb_progress *progress = NULL;
	810	if (pass == 2 && combinations) progress = new arb_progress(STATUS_PREFIX "test compression", combinations);
	811
815	812	for (Dicts::iterator di = dicts.begin(); di != dicts.end(); ++di) {
816	813	DictPtr d = *di;
…	…
834	831	}
835	832	}
836		~~aw_status(++cnt/double(combinations)~~);
	833	++(*progress);
837	834	break;
838	835	}
…	…
840	837	}
841	838	}
	839	delete progress;
842	840	}
843	841
…	…
862	860	"Data of %i DB-keys is lost and will be deleted", nd_count));
863	861
864		aw_status(STATUS_PREFIX "deleting corrupt data");
865		aw_status(0.0);
866		cnt = 0;
	862	arb_progress progress(STATUS_PREFIX "deleting corrupt data", nd_count);
867	863
868	864	StringSet deletedData;
…	…
874	870
875	871	error = deleteDataOfKey(gb_main, GB_key_2_quark(gb_main, keyname.c_str()), deletedData, deleted, notDeleted);
876		~~aw_status(++cnt/double(nd_count))~~;
	872	++progress;
877	873	}
878	874
…	…
1060	1056	}
1061	1057	if (!err) {
1062		a~~w_openstatu~~s("DB-Repair");
	1058	arb_progress progress("DB-Repair");
1063	1059	err = NT_repair_DB(gb_main);
1064		~~aw_closestatus();~~
1065	1060	}
1066	1061

branches/refactor/NTREE/NT_extern.cxx

r7078	r7097
44	44	#include <aw_file.hxx>
45	45	#include <aw_msg.hxx>
46		#include <a~~w_status.hxx~~>
	46	#include <arb_progress.h>
47	47	#include <aw_root.hxx>
48	48
…	…
334	334
335	335	void NT_database_optimization(AW_window *aww) {
336		GB_ERROR error = 0;
	336	arb_progress progress("Optimizing database", 2);
	337
337	338	GB_push_my_security(GLOBAL_gb_main);
338
339		{
340		aw_openstatus("Optimizing sequence data");
341
342		error = GB_begin_transaction(GLOBAL_gb_main);
	339	GB_ERROR error = GB_begin_transaction(GLOBAL_gb_main);
	340	if (!error) {
	341	char **ali_names = GBT_get_alignment_names(GLOBAL_gb_main);
	342	arb_progress ali_progress("Optimizing sequence data", GBT_count_names(ali_names));
	343
	344	ali_progress.allow_title_reuse();
	345
	346	error = GBT_check_data(GLOBAL_gb_main, 0);
	347	error = GB_end_transaction(GLOBAL_gb_main, error);
	348
343	349	if (!error) {
344		char **ali_names = GBT_get_alignment_names(GLOBAL_gb_main);
345
346		aw_status("Checking Sequence Lengths");
347		error = GBT_check_data(GLOBAL_gb_main, 0);
348		error = GB_end_transaction(GLOBAL_gb_main, error);
349
350		if (!error) {
351		char *tree_name = aww->get_root()->awar("tmp/nt/arbdb/optimize_tree_name")->read_string();
352		for (char *ali_name = ali_names; !error && ali_name; ali_name++) {
353		aw_status(*ali_name);
354		error = GBT_compress_sequence_tree2(GLOBAL_gb_main, tree_name, *ali_name);
355		}
356		free(tree_name);
357		}
358		GBT_free_names(ali_names);
359		}
360		aw_closestatus();
361		}
	350	char *tree_name = aww->get_root()->awar("tmp/nt/arbdb/optimize_tree_name")->read_string();
	351	for (char *ali_name = ali_names; !error && ali_name; ali_name++) {
	352	error = GBT_compress_sequence_tree2(GLOBAL_gb_main, tree_name, *ali_name);
	353	ali_progress.inc_and_check_user_abort(error);
	354	}
	355	free(tree_name);
	356	}
	357	GBT_free_names(ali_names);
	358	}
	359	progress.inc_and_check_user_abort(error);
362	360
363	361	if (!error) {
364		~~aw_openstatus("Optimizing non-sequence data");~~
365	362	error = GB_optimize(GLOBAL_gb_main);
366		~~aw_closestatus(~~);
	363	progress.inc_and_check_user_abort(error);
367	364	}
368	365
…	…
998	995	GBT_TREE_REMOVE_TYPE mode = (GBT_TREE_REMOVE_TYPE)cl_mode;
999	996
	997	GB_ERROR error = 0;
1000	998	GB_transaction ta(gb_main);
1001	999
…	…
1004	1002
1005	1003	if (tree_names) {
1006		aw_openstatus("Deleting from trees");
1007		GB_HASH *species_hash = GBT_create_species_hash(gb_main);
1008
1009		for (int t = 0; t<treeCount; t++) {
1010		GB_ERROR error = 0;
1011		aw_status(t/double(treeCount));
1012		aw_status(tree_names[t]);
	1004	arb_progress progress("Deleting from trees", treeCount);
	1005	GB_HASH *species_hash = GBT_create_species_hash(gb_main);
	1006
	1007	for (int t = 0; t<treeCount && !error; t++) {
	1008	progress.subtitle(tree_names[t]);
1013	1009	GBT_TREE *tree = GBT_read_tree(gb_main, tree_names[t], -sizeof(GBT_TREE));
1014	1010	if (!tree) {
…	…
1039	1035	}
1040	1036	}
1041		if (error) aw_message(error);
1042		}
1043		aw_status(1.0);
	1037	progress.inc_and_check_user_abort(error);
	1038	}
1044	1039
1045	1040	GBT_free_names(tree_names);
1046	1041	GBS_free_hash(species_hash);
1047		aw_closestatus();
1048		}
	1042	}
	1043
	1044	aw_message_if(ta.close(error));
1049	1045	}
1050	1046
…	…
1338	1334	{
1339	1335	AWMIMT("pos_var_dist", "Positional variability (distance method)", "P", "pos_variability.ps", AWM_EXP, AW_POPUP, (AW_CL)AP_open_cprofile_window, 0);
1340		AWMIMT("count_different_chars", "Count different chars/column", "C", "count_chars.hlp", AWM_EXP, NT_count_different_chars, (AW_CL)GLOBAL_gb_main, 1);
	1336	AWMIMT("count_different_chars", "Count different chars/column", "C", "count_chars.hlp", AWM_EXP, NT_count_different_chars, (AW_CL)GLOBAL_gb_main, 0);
1341	1337	AWMIMT("export_pos_var", "Export Column Statistic (GNUPLOT format)", "E", "csp_2_gnuplot.hlp", AWM_ALL, AW_POPUP, (AW_CL)NT_create_colstat_2_gnuplot_window, 0);
1342	1338	}

branches/refactor/NTREE/NT_join.cxx

r6858	r7097
15	15	#include <aw_root.hxx>
16	16	#include <aw_msg.hxx>
17		#include <a~~w_status.hxx~~>
	17	#include <arb_progress.h>
18	18	#include <arbdbt.h>
19	19
…	…
114	114	if (!error) {
115	115	GB_HASH *hash = GBS_create_hash(1000, GB_MIND_CASE);
116		aw_openstatus("Joining species");
117
118		long maxs = GBT_count_marked_species(GLOBAL_gb_main);
119		long cnt = 0;
	116	long maxs = GBT_count_marked_species(GLOBAL_gb_main);
	117
	118	arb_progress progress("Joining species", maxs);
120	119
121	120	GBDATA *gb_next = 0;
…	…
125	124	{
126	125	gb_next = GBT_next_marked_species(gb_species);
127
128		~~aw_status(++cnt/(double)maxs);~~
129	126
130	127	GBDATA *gb_field = GB_entry(gb_species, field);
…	…
141	138	}
142	139	}
	140	progress.inc_and_check_user_abort(error);
143	141	}
144	142
145		~~aw_closestatus();~~
146	143	GBS_free_hash(hash);
147	144	}

branches/refactor/NTREE/NT_main.cxx

r7055	r7097
25	25	#include <aw_file.hxx>
26	26	#include <aw_msg.hxx>
27		#include <a~~w_status.hxx~~>
	27	#include <arb_progress.h>
28	28	#include <aw_root.hxx>
29	29
…	…
54	54	GB_push_my_security(gb_main);
55	55
56		a~~w_status("Checking alignments"~~);
	56	arb_progress progress("Formatting alignments", GBT_count_alignments(gb_main));
57	57	err = GBT_check_data(gb_main, 0);
58	58
…	…
62	62	question.add_help("prompt/format_alignments.hlp");
63	63
64		for (GBDATA *gb_ali = GB_entry(gb_presets, "alignment"); gb_ali && !err; gb_ali = GB_nextEntry(gb_ali)) {
	64	for (GBDATA *gb_ali = GB_entry(gb_presets, "alignment");
	65	gb_ali && !err;
	66	gb_ali = GB_nextEntry(gb_ali))
	67	{
65	68	GBDATA *gb_aligned = GB_search(gb_ali, "aligned", GB_INT);
66	69
…	…
122	125	}
123	126	if (!err && perform_format) {
124		~~aw_status(GBS_global_string("Formatting '%s'", ali_name));~~
125	127	GB_push_my_security(gb_main);
126	128	err = GBT_format_alignment(gb_main, ali_name);
…	…
128	130	}
129	131	}
	132	progress.inc_and_check_user_abort(err);
130	133	}
131	134
…	…
138	141	// --------------------------------------------------------------------------------
139	142
140
141
142		~~// called once on ARB_NTREE startup~~
143		//
144	143	static GB_ERROR nt_check_database_consistency() {
145		aw_openstatus("Checking database...");
146
147		GB_ERROR err = NT_format_all_alignments(GLOBAL_gb_main);
	144	// called once on ARB_NTREE startup
	145	arb_progress("Checking consistency");
	146
	147	GB_ERROR err = NT_format_all_alignments(GLOBAL_gb_main);
148	148	if (!err) err = NT_repair_DB(GLOBAL_gb_main);
149	149
150		~~aw_closestatus();~~
151	150	return err;
152	151	}

branches/refactor/NTREE/NT_sort.cxx

r6858	r7097
15	15	#include <awt.hxx>
16	16	#include <aw_awar.hxx>
17		#include <a~~w_status.hxx~~>
	17	#include <arb_progress.h>
18	18	#include <aw_msg.hxx>
19	19	#include <aw_root.hxx>
…	…
135	135
136	136	void NT_resort_data_by_phylogeny(AW_window *, AW_CL, AW_CL) {
137		aw_openstatus("resorting data");
138		GB_ERROR error = 0;
139		GBT_TREE *tree = nt_get_current_tree_root();
140		if (!tree) error = "Please select/build a tree first";
	137	arb_progress progress("Sorting data");
	138	GB_ERROR error = 0;
	139	GBT_TREE *tree = nt_get_current_tree_root();
	140
	141	if (!tree) error = "Please select/build a tree first";
141	142	if (!error) error = NT_resort_data_base(tree, 0, 0, 0);
142		~~aw_closestatus();~~
143	143	if (error) aw_message(error);
144
145	144	}
146	145
147	146	void NT_resort_data_by_user_criteria(AW_window *aw) {
148		a~~w_openstatus("res~~orting data");
149		~~GB_ERROR error = 0;~~
	147	arb_progress progress("Sorting data");
	148
150	149	char *s1 = aw->get_root()->awar("ad_tree/sort_1")->read_string();
151	150	char *s2 = aw->get_root()->awar("ad_tree/sort_2")->read_string();
152	151	char *s3 = aw->get_root()->awar("ad_tree/sort_3")->read_string();
153		if (!error) error = NT_resort_data_base(0, s1, s2, s3);
154		~~aw_closestatus(~~);
	152
	153	GB_ERROR error = NT_resort_data_base(0, s1, s2, s3);
155	154	if (error) aw_message(error);
	155
	156	free(s3);
	157	free(s2);
	158	free(s1);
156	159	}
157	160

branches/refactor/NTREE/NT_trackAliChanges.cxx

r6858	r7097
17	17	#include <aw_root.hxx>
18	18	#include <aw_msg.hxx>
19		#include <a~~w_status.hxx~~>
	19	#include <arb_progress.h>
20	20	#include <arbdbt.h>
21	21	#include <ctime>
…	…
56	56
57	57	static void trackAlignmentChanges(AW_window *aww) {
58		GB_transaction ta(GLOBAL_gb_main);
59		AW_root *root = aww->get_root();
60		char *ali = root->awar(AWAR_TRACK_ALI)->read_string();
61		char *checksum_field = GBS_string_2_key(GBS_global_string("checksum_%s", ali));
62		long newSpecies = 0;
63		long ali_changed = 0;
64		long seq_changed = 0;
65		long unchanged = 0;
66		long species = GBT_get_species_count(GLOBAL_gb_main);
67		long count = 0;
68		GB_ERROR error = 0;
69		char *stamp;
	58	GB_transaction ta(GLOBAL_gb_main);
	59
	60	AW_root *root = aww->get_root();
	61	char *ali = root->awar(AWAR_TRACK_ALI)->read_string();
	62	char *checksum_field = GBS_string_2_key(GBS_global_string("checksum_%s", ali));
	63	long newSpecies = 0;
	64	long ali_changed = 0;
	65	long seq_changed = 0;
	66	long unchanged = 0;
	67	GB_ERROR error = 0;
	68	char *stamp;
70	69
71	70	{
…	…
80	79	}
81	80
82		a~~w_openstatus(GBS_global_string("Tracking changes in '%s'", ali~~));
	81	arb_progress progress(GBS_global_string("Tracking changes in '%s'", ali), GBT_get_species_count(GLOBAL_gb_main));
83	82
84	83	for (GBDATA *gb_species = GBT_first_species(GLOBAL_gb_main);
…	…
139	138	free(char_entry);
140	139	}
141		count++;
142		aw_status(count/(double)species);
	140	progress.inc_and_check_user_abort(error);
143	141	}
144	142
145		aw_closestatus();
146
147		if (seq_changed) aw_message(GBS_global_string("%li species with changed sequence", seq_changed));
148		if (ali_changed) aw_message(GBS_global_string("%li species with changed alignment", ali_changed));
149		if (newSpecies) aw_message(GBS_global_string("%li new species", newSpecies));
	143	if (error) aw_message(error);
	144	else {
	145	if (seq_changed) aw_message(GBS_global_string("%li species with changed sequence", seq_changed));
	146	if (ali_changed) aw_message(GBS_global_string("%li species with changed alignment", ali_changed));
	147	if (newSpecies) aw_message(GBS_global_string("%li new species", newSpecies));
	148	}
150	149
151	150	free(stamp);

branches/refactor/NTREE/NT_tree_cmp.cxx

r6858	r7097
12	12	#include <AP_Tree.hxx>
13	13	#include <aw_msg.hxx>
14		#include <a~~w_status.hxx~~>
	14	#include <arb_progress.h>
15	15	#include <string>
16	16
…	…
19	19	using namespace std;
20	20
21		AWT_species_set_root::AWT_species_set_root(GBDATA *gb_maini, long nspeciesi) {
	21	AWT_species_set_root::AWT_species_set_root(GBDATA gb_maini, long nspeciesi, arb_progress progress_) {
22	22	memset((char )this, 0, sizeof(this));
23		gb_main = gb_maini;
	23	gb_main = gb_maini;
24	24	nspecies = nspeciesi;
25		sets = (AWT_species_set *)GB_calloc(sizeof(AWT_species_set ), (size_t)(nspecies*2+1));
	25	progress = progress_;
	26	sets = (AWT_species_set *)GB_calloc(sizeof(AWT_species_set ), (size_t)(nspecies*2+1));
26	27
27	28	int i;
…	…
162	163	* If a match is found, set ssr->sets to this match)
163	164	*/
164		AWT_species_set *ss;
	165	AWT_species_set *ss = NULL;
165	166	if (tree_source->is_leaf) {
166		~~aw_status(this->status++/(double)this->mstatus);~~
167	167	ss = new AWT_species_set(tree_source, this, tree_source->name);
168		~~return ss;~~
169		}
170		~~aw_status(this->status++/(double)this->mstatus);~~
171		~~AWT_species_set *ls = find_best_matches_info(tree_source->get_leftson(), log, compare_node_info);~~
172		~~AWT_species_set *rs = find_best_matches_info(tree_source->get_rightson(), log, compare_node_info);~~
173
174		~~ss = new AWT_species_set(tree_source, this, ls, rs); // Generate new bitstring~~
175		~~if (compare_node_info) {~~
176		~~int mismatches = this->search(ss, log); // Search optimal position~~
177		~~delete ss->node->remark_branch;~~
178		~~ss->node->remark_branch = 0;~~
179		~~if (mismatches) {~~
180		~~char remark[20];~~
181		~~sprintf(remark, "# %i", mismatches); // the #-sign is important (otherwise TREE_write_Newick will not work correctly)~~
182		~~ss->node->remark_branch = strdup(remark);~~
183		}
184	168	}
185	169	else {
186		if (tree_source->name) {
187		this->search(ss, log); // Search optimal position
188		}
189		}
190		delete rs;
191		delete ls;
	170	AWT_species_set *ls = NULL;
	171	AWT_species_set *rs = NULL;
	172
	173	ls = find_best_matches_info(tree_source->get_leftson(), log, compare_node_info);
	174	if (ls) rs = find_best_matches_info(tree_source->get_rightson(), log, compare_node_info);
	175
	176	if (rs) {
	177	ss = new AWT_species_set(tree_source, this, ls, rs); // Generate new bitstring
	178	if (compare_node_info) {
	179	int mismatches = this->search(ss, log); // Search optimal position
	180	delete ss->node->remark_branch;
	181	ss->node->remark_branch = 0;
	182	if (mismatches) {
	183	char remark[20];
	184	sprintf(remark, "# %i", mismatches); // the #-sign is important (otherwise TREE_write_Newick will not work correctly)
	185	ss->node->remark_branch = strdup(remark);
	186	}
	187	}
	188	else {
	189	if (tree_source->name) {
	190	this->search(ss, log); // Search optimal position
	191	}
	192	}
	193	}
	194	delete rs;
	195	delete ls;
	196	}
	197	if (ss) {
	198	progress->inc();
	199	if (progress->aborted()) {
	200	delete ss;
	201	ss = NULL;
	202	}
	203	}
192	204	return ss; // return bitstring for this node
193	205	}
…	…
257	269
258	270	return error;
	271	}
	272
	273	void AWT_species_set_root::finish(GB_ERROR& error) {
	274	if (!error) error = progress->error_if_aborted();
	275	progress->done();
259	276	}
260	277
…	…
280	297	AP_tree_root rdest (new AliView(gb_main), AP_tree(0), NULL, false);
281	298
282		aw_openstatus("Comparing Topologies");
283
284		aw_status("Load Tree 1");
	299	arb_progress progress("Comparing Topologies");
	300
285	301	error = rsource.loadFromDB(tree_source);
286	302	if (!error) error = rsource.linkToDB(0, 0);
287	303	if (!error) {
288		~~aw_status("Load Tree 2");~~
289	304	error = rdest.loadFromDB(tree_dest);
290	305	if (!error) error = rdest.linkToDB(0, 0);
…	…
293	308	AP_tree *dest = rdest.get_root_node();
294	309
295		long nspecies = dest->arb_tree_leafsum2();
296		AWT_species_set_root *ssr = new AWT_species_set_root(gb_main, nspecies);
297
298		aw_status("Building Search Table for Tree 2");
	310	long nspecies = dest->arb_tree_leafsum2();
	311	long source_leafs = source->arb_tree_leafsum2();
	312	long source_nodes = source_leafs*2-1;
	313
	314	arb_progress compare_progress(source_nodes);
	315	compare_progress.subtitle("Comparing both trees");
	316
	317	AWT_species_set_root *ssr = new AWT_species_set_root(gb_main, nspecies, &compare_progress);
	318
299	319	ssr->move_tree_2_ssr(dest);
300	320
301		aw_status("Compare Both Trees");
302		ssr->mstatus = source->arb_tree_leafsum2() * 2;
303		ssr->status = 0;
304
305		if (ssr->mstatus < 2) error = GB_export_error("Destination tree has less than 3 species");
	321	if (source_leafs < 3) error = GB_export_error("Destination tree has less than 3 species");
306	322	else {
307		AWT_species_set *root_setl = ssr->find_best_matches_info(source->get_leftson(), log, compare_node_info);
308		AWT_species_set *root_setr = ssr->find_best_matches_info(source->get_rightson(), log, compare_node_info);
309
310		if (!compare_node_info) {
311		aw_status("Copy Node Information");
312		ssr->copy_node_information(log, delete_old_nodes, nodes_with_marked_only);
313		}
314
315		long dummy = 0;
316		AWT_species_set *new_root_setl = ssr->search(root_setl, &dummy);
317		AWT_species_set *new_root_setr = ssr->search(root_setr, &dummy);
318		AP_tree new_rootl = (AP_tree ) new_root_setl->node;
319		AP_tree new_rootr = (AP_tree ) new_root_setr->node;
320
321		new_rootl->set_root(); // set root correctly
322		new_rootr->set_root(); // set root correctly
323
324		aw_status("Save Tree");
325
326		AP_tree *root = new_rootr->get_root_node();
327
328		error = GBT_write_tree(gb_main, rdest.get_gb_tree(), 0, root->get_gbt_tree());
329		if (!error) error = GBT_write_tree(gb_main, rsource.get_gb_tree(), 0, source->get_gbt_tree());
330		}
	323	AWT_species_set *root_setl = NULL;
	324	AWT_species_set *root_setr = NULL;
	325
	326	root_setl = ssr->find_best_matches_info(source->get_leftson(), log, compare_node_info);
	327	if (root_setl) root_setr = ssr->find_best_matches_info(source->get_rightson(), log, compare_node_info);
	328
	329	if (root_setr) {
	330	if (!compare_node_info) {
	331	compare_progress.subtitle("Copying node information");
	332	ssr->copy_node_information(log, delete_old_nodes, nodes_with_marked_only);
	333	}
	334
	335	long dummy = 0;
	336	AWT_species_set *new_root_setl = ssr->search(root_setl, &dummy);
	337	AWT_species_set *new_root_setr = ssr->search(root_setr, &dummy);
	338	AP_tree new_rootl = (AP_tree ) new_root_setl->node;
	339	AP_tree new_rootr = (AP_tree ) new_root_setr->node;
	340
	341	new_rootl->set_root(); // set root correctly
	342	new_rootr->set_root(); // set root correctly
	343
	344	compare_progress.subtitle("Saving trees");
	345
	346	AP_tree *root = new_rootr->get_root_node();
	347
	348	error = GBT_write_tree(gb_main, rdest.get_gb_tree(), 0, root->get_gbt_tree());
	349	if (!error) error = GBT_write_tree(gb_main, rsource.get_gb_tree(), 0, source->get_gbt_tree());
	350	}
	351
	352	delete root_setl;
	353	delete root_setr;
	354	}
	355
	356	ssr->finish(error);
	357	delete ssr;
331	358	}
332	359	}
…	…
337	364	}
338	365
339		~~aw_closestatus();~~
340
341	366	GB_end_transaction_show_error(gb_main, error, aw_message);
342	367	}

branches/refactor/NTREE/ad_spec.cxx

r7095	r7097
24	24	#include <aw_detach.hxx>
25	25	#include <aw_msg.hxx>
26		#include <a~~w_status.hxx~~>
	26	#include <arb_progress.h>
27	27	#include <arb_str.h>
28	28	#include <arb_defs.h>
…	…
94	94	static const char * const SAI_COUNTED_CHARS = "COUNTED_CHARS";
95	95
96		void NT_count_different_chars(AW_window *, AW_CL cl_gb_main, AW_CL ~~use_status~~) {
97		// @@@ extract algorithm
	96	void NT_count_different_chars(AW_window *, AW_CL cl_gb_main, AW_CL) {
	97	// @@@ extract algorithm and call extracted from testcode
98	98	ARB_ERROR error;
99	99	GBDATA gb_main = (GBDATA)cl_gb_main;
…	…
120	120	// loop over all marked species
121	121	{
122		if (use_status) {
123		aw_openstatus("Counting characters");
124		aw_status(0.0);
125		}
126
127		int all_marked = GBT_count_marked_species(gb_main);
128		aw_status_counter *progress = use_status ? new aw_status_counter(all_marked) : NULL;
	122	int all_marked = GBT_count_marked_species(gb_main);
	123	arb_progress progress("Counting different characters", all_marked);
129	124
130	125	for (GBDATA *gb_species = GBT_first_marked_species(gb_main);
…	…
147	142	}
148	143	}
149		if (progress) progress->inc();
150		}
151
152		if (use_status) {
153		delete progress;
154		aw_closestatus();
	144	progress.inc_and_check_user_abort(error);
155	145	}
156	146	}
…	…
427	417	if (!error) {
428	418	if (aw_ask_sure("Do you want to re-create the 'name' field?")) {
429		aw_openstatus("Recreating species name");
430		aw_status("");
431		aw_status(0.0);
432		error = AWTC_recreate_name(gb_species, true);
	419	arb_progress progress("Recreating species name", 1);
	420	error = AWTC_recreate_name(gb_species);
433	421	if (!error) aw_root->awar(AWAR_SPECIES_NAME)->write_string(GBT_read_name(gb_species)); // set focus
434		~~aw_closestatus();~~
435	422	}
436	423	}
…	…
945	932	error = GB_export_error("Please select a valid field");
946	933	}
947		~~long max = awt_count_queried_items(cbs, AWT_QUERY_ALL_SPECIES);~~
948	934
949	935	if (strcmp(dest_field, "name")==0) {
…	…
956	942	}
957	943
958		aw_openstatus("Searching next neighbours");
959
960		long count = 0;
	944	long max = awt_count_queried_items(cbs, AWT_QUERY_ALL_SPECIES);
	945	arb_progress progress("Searching next neighbours", max);
	946	progress.auto_subtitles("Species");
	947
961	948	int pts = aw_root->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int();
962	949	char *ali_name = aw_root->awar(AWAR_DEFAULT_ALIGNMENT)->read_string();
…	…
976	963	if (!IS_QUERIED(gb_species, cbs)) continue;
977	964
978		~~count++;~~
979		~~if ((count%10) == 0) {~~
980		~~GBDATA *gb_name = GB_search(gb_species, "name", GB_STRING);~~
981		~~aw_status(GBS_global_string("Species '%s' (%li:%li)", GB_read_char_pntr(gb_name), count, max));~~
982		}
983
984	965	GBDATA *gb_data = GBT_read_sequence(gb_species, ali_name);
985		if (!gb_data) continue;
986
987		if (aw_status(count/(double)max)) {
988		error = "operation aborted";
989		}
990		else {
	966	if (gb_data) {
991	967	char *sequence = GB_read_string(gb_data);
992	968	PT_FamilyFinder ff(GLOBAL_gb_main, pts, oligo_len, mismatches, fast_mode, rel_matches);
…	…
1040	1016	free(sequence);
1041	1017	}
1042		}
1043		~~aw_closestatus();~~
	1018	progress.inc_and_check_user_abort(error);
	1019	}
1044	1020	GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message);
1045	1021	free(dest_field);
…	…
1465	1441	void TEST_count_chars() {
1466	1442	// calculate SAI for test DBs
1467
	1443
	1444	arb_suppress_progress silence;
1468	1445	for (int prot = 0; prot<2; ++prot) {
1469	1446	GBDATA *gb_main;
…	…
1484	1461	// the difference to TEST_count_chars() is just in size of alignment.
1485	1462	// NT_count_different_chars() crashes for big alignments when running in gdb
	1463	arb_suppress_progress silence;
1486	1464	{
1487	1465	arb_unit_test::test_alignment_data data_source[] = {

branches/refactor/NTREE/ad_transpro.cxx

r6861	r7097
19	19	#include <aw_root.hxx>
20	20	#include <aw_msg.hxx>
21		#include <a~~w_status.hxx~~>
	21	#include <arb_progress.h>
22	22	#include <arbdbt.h>
23	23	#include <cctype>
…	…
80	80
81	81	if (!error) {
82		aw_openstatus("Translating");
83
84		int spec_count = GBT_get_species_count(gb_main);
85		int spec_i = 0;
	82	arb_progress progress("Translating", GBT_count_marked_species(gb_main));
86	83
87	84	bool table_used[AWT_CODON_TABLES];
…	…
139	136	}
140	137
141		if (aw_status(double(spec_i++)/double(spec_count))) {
142		error = "Aborted by user";
143		}
	138	GBDATA *gb_source = GB_entry(gb_species, ali_source);
	139	if (!gb_source) { ++no_data; }
144	140	else {
145		~~GBDATA *gb_source = GB_entry(gb_species, ali_source);~~
146		~~if (!gb_source) { ++no_data; continue; }~~
147
148	141	GBDATA *gb_source_data = GB_entry(gb_source, "data");
149		if (!gb_source_data) { ++no_data; continue; }
150
151		char *data = GB_read_string(gb_source_data);
152		if (!data) {
153		GB_print_error(); // cannot read data (ignore species)
154		++no_data;
155		continue;
156		}
157
158		if (!found_transl_info) ++spec_no_transl_info; // count species with missing info
159
160		stops += AWT_pro_a_nucs_convert(table, data, GB_read_string_count(gb_source_data), startpos, translate_all, false, false, 0); // do the translation
161		++count;
162
163		GBDATA *gb_dest_data = GBT_add_data(gb_species, ali_dest, "data", GB_STRING);
164		if (!gb_dest_data) error = GB_await_error();
165		else error = GB_write_string(gb_dest_data, data);
166
167		free(data);
168		}
169
170		if (!error && save_entries && !found_transl_info) {
171		error = AWT_saveTranslationInfo(gb_species, selected_ttable, startpos);
172		}
173		}
174		}
175
176		aw_closestatus();
	142	if (!gb_source_data) { ++no_data; }
	143	else {
	144	char *data = GB_read_string(gb_source_data);
	145	if (!data) {
	146	GB_print_error(); // cannot read data (ignore species)
	147	++no_data;
	148	}
	149	else {
	150	if (!found_transl_info) ++spec_no_transl_info; // count species with missing info
	151
	152	stops += AWT_pro_a_nucs_convert(table, data, GB_read_string_count(gb_source_data), startpos, translate_all, false, false, 0); // do the translation
	153	++count;
	154
	155	GBDATA *gb_dest_data = GBT_add_data(gb_species, ali_dest, "data", GB_STRING);
	156	if (!gb_dest_data) error = GB_await_error();
	157	else error = GB_write_string(gb_dest_data, data);
	158
	159
	160	if (!error && save_entries && !found_transl_info) {
	161	error = AWT_saveTranslationInfo(gb_species, selected_ttable, startpos);
	162	}
	163
	164	free(data);
	165	}
	166	}
	167	}
	168	progress.inc_and_check_user_abort(error);
	169	}
	170	}
177	171	}
178	172
…	…
353	347	GB_ERROR error = 0;
354	348
355		aw_openstatus("Re-aligner");
356
357		int no_of_marked_species = GBT_count_marked_species(gb_main);
358		int no_of_realigned_species = 0;
359		int ignore_fail_pos = 0;
	349	arb_progress progress("Re-aligner", GBT_count_marked_species(gb_main));
	350	progress.auto_subtitles("Re-aligning species");
	351
	352	int ignore_fail_pos = 0;
360	353
361	354	for (GBDATA *gb_species = GBT_first_marked_species(gb_main);
…	…
363	356	gb_species = GBT_next_marked_species(gb_species))
364	357	{
365		~~aw_status(GBS_global_string("Re-aligning #%i of %i ...", no_of_realigned_species+1, no_of_marked_species));~~
366
367	358	gb_source = GB_entry(gb_species, ali_source); if (!gb_source) continue;
368	359	GBDATA *gb_source_data = GB_entry(gb_source, "data"); if (!gb_source_data) continue;
…	…
657	648	free(source);
658	649
659		no_of_realigned_species++;
660		GB_status(double(no_of_realigned_species)/double(no_of_marked_species));
661		}
662		aw_closestatus();
	650	progress.inc_and_check_user_abort(error);
	651	}
663	652
664	653	if (max_wanted_ali_len>0) {

branches/refactor/NTREE/ap_pos_var_pars.hxx

r6490	r7097
24	24	AW_window AP_open_pos_var_pars_window(AW_root root);
25	25
	26	class arb_progress;
	27
26	28	class AP_pos_var {
27	29	GBDATA *gb_main;
28		long t~~imer; // for the status box~~
29		~~long treesize; // max value for slider~~
	30	long treesize; // max value for slider
	31	arb_progress *progress;
30	32	GB_UINT4 *frequencies[256]; // count every occurrence
31		GB_UINT4 *transitions; // minimum transitions
32		GB_UINT4 *transversions; // minimum transversions (dna only)
	33	GB_UINT4 *transitions; // minimum transitions
	34	GB_UINT4 *transversions; // minimum transversions (dna only)
33	35	unsigned char char_2_freq[256]; // mapper (~ toupper)
34	36	long char_2_transition[256]; // a->1 c->2 g->4 ...

branches/refactor/NTREE/nt_internal.h

r7084	r7097
129	129	/* ad_spec.cxx */
130	130	void NT_create_species_var(AW_root *aw_root, AW_default aw_def);
131		void NT_count_different_chars(AW_window *, AW_CL cl_gb_main, AW_CL ~~use_status~~);
	131	void NT_count_different_chars(AW_window *, AW_CL cl_gb_main, AW_CL dummy_1x);
132	132	void NT_create_sai_from_pfold(AW_window *aww, AW_CL ntw, AW_CL dummy_1x);
133	133	AW_window NT_create_ad_list_reorder(AW_root root, AW_CL cl_item_selector);

branches/refactor/NTREE/nt_tree_cmp.hxx

r6490	r7097
18	18	class AP_tree;
19	19	class AWT_species_set;
	20	class arb_progress;
20	21
21	22	class AWT_species_set_root {
…	…
25	26	int diff_bits[256];
26	27
	28	arb_progress *progress;
	29
27	30	public:
28		~~long mstatus;~~
29		~~long status; // temporary variables for status~~
30	31	long nspecies;
31	32	GBDATA *gb_main;
…	…
33	34
34	35	// REAL PUBLIC
35		AWT_species_set_root(GBDATA *gb_main, long nspecies);
	36	AWT_species_set_root(GBDATA gb_main, long nspecies, arb_progress progress_);
36	37	~AWT_species_set_root();
37	38
…	…
43	44	AWT_species_set find_best_matches_info(AP_tree tree_source, FILE *log, bool setinner_node);
44	45	AWT_species_set move_tree_2_ssr(AP_tree node);
	46
	47	void finish(GB_ERROR& error);
45	48	};
46	49

branches/refactor/PARSIMONY/AP_tree_edge.cxx

r6858	r7097
13	13
14	14	#include <AP_filter.hxx>
15		#include <a~~w_status.hxx~~>
	15	#include <arb_progress.h>
16	16
17	17	#include <cmath>
…	…
680	680	}
681	681
682		#if defined(DEVEL_RALF)
683		#warning fix interfaces of AP_tree_nlen::nn_interchange_rek and AP_tree_edge::nni_rek (use a struct as param)
684		#endif // DEVEL_RALF
685		AP_FLOAT AP_tree_edge::nni_rek(bool useStatus, int &Abort, int deep, bool skip_hidden,
686		AP_BL_MODE mode, AP_tree_nlen *skipNode)
687		{
	682	AP_FLOAT AP_tree_edge::nni_rek(int deep, bool skip_hidden, AP_BL_MODE mode, AP_tree_nlen *skipNode) {
688	683	if (!rootNode()) return 0.0;
689	684	if (rootNode()->is_leaf) return rootNode()->costs();
…	…
691	686	AP_tree_edge *oldRootEdge = rootEdge();
692	687
693		~~if (useStatus) aw_openstatus("Recursive NNI");~~
694	688	if (deep>=0) set_root();
695	689
…	…
699	693	buildChain(deep, skip_hidden, 0, skipNode);
700	694	long cs = sizeofChain();
	695	arb_progress progress(cs*2);
701	696	AP_tree_edge *follow;
702		~~long count = 0;~~
703		{ // set all branch lengths to undef
	697	{
	698	// set all branch lengths to undef
704	699	for (follow = this; follow; follow = follow->next) {
705	700	follow->node[0]->leftlen = ap_undef_bl;
…	…
714	709	}
715	710
716		if (useStatus) aw_status(0.0);
717
718		for (follow = this; follow && Abort == 0; follow = follow->next) {
	711	for (follow = this; follow && !progress.aborted(); follow = follow->next) {
719	712	AP_tree_nlen *son = follow->sonNode();
720	713	AP_tree_nlen *fath = son;
…	…
741	734	}
742	735
743		if (useStatus ? aw_status(++count/(double)cs) : aw_status()) { Abort = 1; break; }
744		}
745
746		if (useStatus) {
747		aw_status("Recalc modified branches");
748		aw_status(0.0);
749		count = 0;
750		}
751
752		for (follow = this; follow && Abort == 0; follow = follow->next) {
	736	progress.inc();
	737	}
	738
	739	for (follow = this; follow && !progress.aborted(); follow = follow->next) {
753	740	ap_check_leaf_bl(follow->node[0]);
754	741	ap_check_leaf_bl(follow->node[1]);
755		~~if (useStatus ? aw_status(++count/(double)cs) : aw_status()) { Abort = 1; break; }~~
	742	progress.inc();
756	743	}
757	744	oldRootEdge->set_root();
758	745	new_parsimony = rootNode()->costs();
759		~~if (useStatus) aw_closestatus();~~
760	746
761	747	return new_parsimony;

branches/refactor/PARSIMONY/AP_tree_nlen.cxx

r7096	r7097
859	859	}
860	860
861		#if defined(DEVEL_RALF)
862		#warning fix interfaces of AP_tree_nlen::nn_interchange_rek and AP_tree_edge::nni_rek (use a struct as param)
863		#endif // DEVEL_RALF
864		AP_FLOAT AP_tree_nlen::nn_interchange_rek(bool openclosestatus, int &Abort, int deep, AP_BL_MODE mode, bool skip_hidden)
	861	AP_FLOAT AP_tree_nlen::nn_interchange_rek(int deep, AP_BL_MODE mode, bool skip_hidden)
865	862	{
866	863	if (!father)
867	864	{
868		return rootEdge()->nni_rek(~~openclosestatus, Abort,~~ deep, skip_hidden, mode, NULL);
	865	return rootEdge()->nni_rek(deep, skip_hidden, mode, NULL);
869	866	}
870	867
…	…
873	870	AP_tree_edge *e = rootEdge();
874	871
875		return e->nni_rek(~~openclosestatus, Abort,~~ deep, skip_hidden, mode, e->otherNode(this));
876		}
877
878		return edgeTo(get_father())->nni_rek(~~openclosestatus, Abort,~~ deep, skip_hidden, mode, get_father());
	872	return e->nni_rek(deep, skip_hidden, mode, e->otherNode(this));
	873	}
	874
	875	return edgeTo(get_father())->nni_rek(deep, skip_hidden, mode, get_father());
879	876	}
880	877

branches/refactor/PARSIMONY/Makefile

r7089	r7097
100	100	AP_tree_edge.o: $(ARBHOME)/INCLUDE/arb_error.h
101	101	AP_tree_edge.o: $(ARBHOME)/INCLUDE/arb_msg.h
	102	AP_tree_edge.o: $(ARBHOME)/INCLUDE/arb_progress.h
102	103	AP_tree_edge.o: $(ARBHOME)/INCLUDE/arb_string.h
103	104	AP_tree_edge.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
109	110	AP_tree_edge.o: $(ARBHOME)/INCLUDE/aw_base.hxx
110	111	AP_tree_edge.o: $(ARBHOME)/INCLUDE/aw_color_groups.hxx
111		~~AP_tree_edge.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
112	112	AP_tree_edge.o: $(ARBHOME)/INCLUDE/downcast.h
113	113	AP_tree_edge.o: $(ARBHOME)/INCLUDE/dupstr.h
…	…
181	181	PARS_dtree.o: $(ARBHOME)/INCLUDE/arb_error.h
182	182	PARS_dtree.o: $(ARBHOME)/INCLUDE/arb_msg.h
	183	PARS_dtree.o: $(ARBHOME)/INCLUDE/arb_progress.h
183	184	PARS_dtree.o: $(ARBHOME)/INCLUDE/arb_string.h
184	185	PARS_dtree.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
197	198	PARS_dtree.o: $(ARBHOME)/INCLUDE/aw_preset.hxx
198	199	PARS_dtree.o: $(ARBHOME)/INCLUDE/aw_root.hxx
199		~~PARS_dtree.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
200	200	PARS_dtree.o: $(ARBHOME)/INCLUDE/aw_window.hxx
201	201	PARS_dtree.o: $(ARBHOME)/INCLUDE/awt_canvas.hxx
…	…
236	236	PARS_main.o: $(ARBHOME)/INCLUDE/arb_error.h
237	237	PARS_main.o: $(ARBHOME)/INCLUDE/arb_msg.h
	238	PARS_main.o: $(ARBHOME)/INCLUDE/arb_progress.h
238	239	PARS_main.o: $(ARBHOME)/INCLUDE/arb_string.h
239	240	PARS_main.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
253	254	PARS_main.o: $(ARBHOME)/INCLUDE/aw_preset.hxx
254	255	PARS_main.o: $(ARBHOME)/INCLUDE/aw_root.hxx
255		~~PARS_main.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
256	256	PARS_main.o: $(ARBHOME)/INCLUDE/aw_window.hxx
257	257	PARS_main.o: $(ARBHOME)/INCLUDE/awt.hxx

branches/refactor/PARSIMONY/PARS_dtree.cxx

r7096	r7097
27	27	#include <aw_awar.hxx>
28	28	#include <aw_msg.hxx>
29		#include <a~~w_status.hxx~~>
	29	#include <arb_progress.h>
30	30	#include <aw_root.hxx>
31	31
…	…
67	67	agt->tree_static->set_root_changed_callback(AWT_graphic_parsimony_root_changed, agt);
68	68	}
69
70		~~static int ap_global_abort_flag;~~
71	69
72	70	double funktion_quadratisch(double x, double *param_list, int param_anz) {
…	…
145	143
146	144	i = 0;
147		aw_openstatus("KL Optimizer");
148		{
149		char buffer[100];
150		sprintf(buffer, "Old Parsimony: %f", pars_start);
151		aw_status(buffer);
152		}
153		int abort_flag = false;
	145	arb_progress progress(anzahl);
	146
	147	progress.subtitle(GBS_global_string("Old Parsimony: %.1f", pars_start));
154	148
155	149	GB_pop_transaction(GLOBAL_gb_main);
156	150
157		for (i=0; i<anzahl && ! abort_flag; i++) {
158		abort_flag \|= aw_status(i/(double)anzahl);
159		if (abort_flag) break;
160
	151	for (i=0; i<anzahl && !progress.aborted(); i++) {
161	152	AP_tree_nlen tree_elem = (AP_tree_nlen )list[i];
162	153
163		if (tree_elem->gr.hidden \|\|
164		(tree_elem->father && tree_elem->get_father()->gr.hidden)) {
165		continue; // within a folded group
166		}
167		{
	154	bool in_folded_group = tree_elem->gr.hidden \|\|
	155	(tree_elem->father && tree_elem->get_father()->gr.hidden);
	156
	157	if (!in_folded_group) {
168	158	bool better_tree_found = false;
169	159	ap_main->push();
…	…
179	169	ap_main->clear();
180	170	pars_start = GLOBAL_PARS->get_root_node()->costs();
181		char buffer[100];
182		sprintf(buffer, "New Parsimony: %f", pars_start);
183		abort_flag \|= aw_status(buffer);
	171	progress.subtitle(GBS_global_string("New parsimony: %.1f (gain: %.1f)", pars_start, pars_prev-pars_start));
184	172	}
185	173	else {
…	…
187	175	}
188	176	}
189		}
190		~~aw_closestatus();~~
	177	progress.inc();
	178	}
191	179	delete list;
192		~~ap_global_abort_flag \|= abort_flag;~~
193	180	printf("Combines: %li\n", AP_sequence::combine_count()-prevCombineCount);
194	181	}
195	182
196		void PARS_optimizer_cb(AP_tree *tree) {
	183	void PARS_optimizer_cb(AP_tree *tree, arb_progress& progress) {
197	184	AWT_graphic_tree *agt = GLOBAL_PARS->tree;
198	185	AP_tree *oldrootleft = agt->get_root_node()->get_leftson();
199	186	AP_tree *oldrootright = agt->get_root_node()->get_rightson();
200	187
201		for (ap_global_abort_flag = 0; !ap_global_abort_flag;) {
202		AP_FLOAT old_pars = DOWNCAST(AP_tree_nlen*, agt->get_root_node())->costs();
203
204		AP_FLOAT this_pars = ((AP_tree_nlen *)tree)->nn_interchange_rek(true, ap_global_abort_flag, -1, AP_BL_NNI_ONLY, false);
205		if (ap_global_abort_flag) break;
206
207		if (old_pars != this_pars) { // NNI found better tree
208		continue;
	188	AP_FLOAT org_pars = DOWNCAST(AP_tree_nlen*, agt->get_root_node())->costs();
	189	AP_FLOAT prev_pars = org_pars;
	190
	191	progress.subtitle(GBS_global_string("Old parsimony: %.1f", org_pars));
	192
	193	while (!progress.aborted()) {
	194	AP_FLOAT nni_pars = ((AP_tree_nlen *)tree)->nn_interchange_rek(-1, AP_BL_NNI_ONLY, false);
	195
	196	if (nni_pars == prev_pars) { // NNI did not reduce costs -> kern-lin
	197	PARS_kernighan_cb(tree);
	198	AP_FLOAT ker_pars = DOWNCAST(AP_tree_nlen*, agt->get_root_node())->costs();
	199
	200	if (ker_pars == prev_pars) break; // kern-lin did not improve tree -> done
	201	prev_pars = ker_pars;
209	202	}
210
211		PARS_kernighan_cb(tree);
212		if (old_pars == DOWNCAST(AP_tree_nlen*, agt->get_root_node())->costs()) {
213		ap_global_abort_flag = 1;
	203	else {
	204	prev_pars = nni_pars;
214	205	}
215		}
	206	progress.subtitle(GBS_global_string("New parsimony: %.1f (gain: %.1f)", prev_pars, org_pars-prev_pars));
	207	}
	208
216	209	if (oldrootleft->father == oldrootright) oldrootleft->set_root();
217	210	else oldrootright->set_root();
	211
218	212	DOWNCAST(AP_tree_nlen*, agt->get_root_node())->costs();
219		~~aw_closestatus();~~
220	213	}
221	214
…	…
386	379	case AWT_M_LEFT: {
387	380	if (cl->exists) {
388		at = (AP_tree *)cl->client_data1;
389		ap_global_abort_flag = false;
	381	arb_progress progress("NNI optimize subtree");
	382
	383	at = (AP_tree *)cl->client_data1;
390	384	AP_tree_nlen atn = DOWNCAST(AP_tree_nlen, at);
391		atn->nn_interchange_rek(true, ap_global_abort_flag, -1, AP_BL_NNI_ONLY, false);
	385	atn->nn_interchange_rek(-1, AP_BL_NNI_ONLY, false);
	386
392	387	exports.refresh = 1;
393	388	exports.save = 1;
	389
394	390	ASSERT_VALID_TREE(get_root_node());
395	391	recalc_branch_lengths = true;
…	…
398	394	}
399	395	case AWT_M_RIGHT: {
400		~~long prevCombineCount = AP_sequence::combine_count(~~);
401		~~ap_global_abort_flag = false~~;
402		~~AP_tree_nlen atn = DOWNCAST(AP_tree_nlen, get_root_node());~~
403
404		atn->nn_interchange_rek(~~true, ap_global_abort_flag,~~ -1, AP_BL_NNI_ONLY, false);
	396	arb_progress progress("NNI optimize tree");
	397	long prevCombineCount = AP_sequence::combine_count();
	398
	399	AP_tree_nlen atn = DOWNCAST(AP_tree_nlen, get_root_node());
	400	atn->nn_interchange_rek(-1, AP_BL_NNI_ONLY, false);
405	401	printf("Combines: %li\n", AP_sequence::combine_count()-prevCombineCount);
406	402
407		exports.refresh = 1;
408		exports.save = 1;
	403	exports.refresh = 1;
	404	exports.save = 1;
	405
409	406	ASSERT_VALID_TREE(get_root_node());
410	407	recalc_branch_lengths = true;
…	…
420	417	switch (button) {
421	418	case AWT_M_LEFT:
422		if (!cl->exists) break;
423		at = (AP_tree *)cl->client_data1;
424		PARS_kernighan_cb(at);
425		this->exports.refresh = 1;
426		this->exports.save = 1;
427		ASSERT_VALID_TREE(get_root_node());
428		recalc_branch_lengths = true;
429		break;
430		case AWT_M_RIGHT:
	419	if (cl->exists) {
	420	arb_progress progress("Kernighan-Lin optimize subtree");
	421	at = (AP_tree *)cl->client_data1;
	422	PARS_kernighan_cb(at);
	423	this->exports.refresh = 1;
	424	this->exports.save = 1;
	425	ASSERT_VALID_TREE(get_root_node());
	426	recalc_branch_lengths = true;
	427	}
	428	break;
	429	case AWT_M_RIGHT: {
	430	arb_progress progress("Kernighan-Lin optimize tree");
431	431	PARS_kernighan_cb(get_root_node());
432	432	this->exports.refresh = 1;
…	…
435	435	recalc_branch_lengths = true;
436	436	break;
	437	}
437	438	}
438	439	GB_begin_transaction(gb_main);
…	…
444	445	switch (button) {
445	446	case AWT_M_LEFT:
446		if (!cl->exists) break;
447		at = (AP_tree *)cl->client_data1;
448		if (at) PARS_optimizer_cb(at);
	447	if (cl->exists) {
	448	arb_progress progress("Optimizing subtree");
	449
	450	at = (AP_tree *)cl->client_data1;
	451
	452	if (at) PARS_optimizer_cb(at, progress);
	453	this->exports.refresh = 1;
	454	this->exports.save = 1;
	455	ASSERT_VALID_TREE(get_root_node());
	456	recalc_branch_lengths = true;
	457	}
	458	break;
	459	case AWT_M_RIGHT: {
	460	arb_progress progress("Optimizing tree");
	461
	462	PARS_optimizer_cb(get_root_node(), progress);
449	463	this->exports.refresh = 1;
450		this->exports.save = 1;
	464	this->exports.save = 1;
451	465	ASSERT_VALID_TREE(get_root_node());
452	466	recalc_branch_lengths = true;
453	467	break;
454		case AWT_M_RIGHT:
455		PARS_optimizer_cb(get_root_node());
456		this->exports.refresh = 1;
457		this->exports.save = 1;
458		ASSERT_VALID_TREE(get_root_node());
459		recalc_branch_lengths = true;
460		break;
	468	}
461	469	}
462	470	GB_begin_transaction(gb_main);
…	…
471	479
472	480	if (recalc_branch_lengths) {
473		~~int abort_flag = false~~;
474		rootEdge()->~~nni_rek(false, abort_flag, -1, false, AP_BL_BL_ONLY, NULL~~);
	481	arb_progress progress("Recalculating branch lengths");
	482	rootEdge()->calc_branchlengths();
475	483
476	484	beautify_tree = true; // beautify after recalc_branch_lengths

branches/refactor/PARSIMONY/PARS_main.cxx

r7096	r7097
23	23	#include <awt_sel_boxes.hxx>
24	24	#include <awt_filter.hxx>
25		#include <a~~w_status.hxx~~>
	25	#include <arb_progress.h>
26	26	#include <aw_root.hxx>
27	27	#include <gui_aliview.hxx>
…	…
110	110	}
111	111
112		struct InsertData {
	112	class InsertData {
	113	int abort_flag;
	114	long currentspecies;
	115
	116	arb_progress progress;
	117
	118	public:
	119
113	120	bool quick_add_flag;
114		bool singlestatus; // update status for single species addition
115		int abort_flag;
116		long maxspecies;
117		long currentspecies;
118
119		InsertData(bool quick)
120		: quick_add_flag(quick)
121		, singlestatus(false)
122		, abort_flag(false)
123		, maxspecies(0)
124		, currentspecies(0)
	121	InsertData(bool quick, long spec_count)
	122	: abort_flag(false),
	123	currentspecies(0),
	124	progress(GBS_global_string("Inserting %li species", spec_count), spec_count),
	125	quick_add_flag(quick)
125	126	{
126	127	}
127	128
128	129	bool every_sixteenth() { return (currentspecies & 0xf) == 0; }
	130
	131	bool aborted() const { return abort_flag; }
	132	void set_aborted(bool aborted_) { abort_flag = aborted_; }
	133
	134	void inc() {
	135	++currentspecies;
	136	progress.inc();
	137	abort_flag = progress.aborted();
	138	}
129	139	};
130	140
…	…
133	143
134	144	InsertData isits = (InsertData)cd_isits;
135		if (isits->abort~~_flag~~) return val;
	145	if (isits->aborted()) return val;
136	146
137	147	GBDATA gb_node = (GBDATA )val;
…	…
167	177	}
168	178
169		if (isits->singlestatus) {
170		sprintf(AW_ERROR_BUFFER,
171		"Inserting Species %s (%li:%li)",
172		key,
173		++isits->currentspecies,
174		isits->maxspecies);
175		aw_openstatus(AW_ERROR_BUFFER);
176		}
177		else {
178		isits->abort_flag = aw_status(++isits->currentspecies/(double)isits->maxspecies);
179		}
	179	isits->inc();
180	180
181	181	{
…	…
185	185
186	186	while (cnt<2) {
187		char buf[200];
188
189		sprintf(buf, "Pre-optimize (pars=%f)", best_val);
190
191		aw_status(buf);
192		this_val = rootEdge()->nni_rek(false, isits->abort_flag, -1, false, AP_BL_NNI_ONLY, NULL);
	187	this_val = rootEdge()->nni_rek(-1, false, AP_BL_NNI_ONLY, NULL);
193	188	if (this_val<best_val) {
194	189	best_val = this_val;
…	…
206	201	rootEdge()->dumpNNI=2;
207	202
208		~~aw_status("Searching best position");~~
209
210	203	AP_tree **blist;
211	204	AP_tree_nlen bl, blf;
…	…
225	218	best_parsimony = akt_parsimony = rootNode()->costs();
226	219
227		for (counter = 0; !isits->abort_flag && blist[counter]; counter += 2)
228		{
229		if (isits->singlestatus && isits->every_sixteenth()) {
230		isits->abort_flag = aw_status(counter/(bsum*2.0));
231		}
232
	220	for (counter = 0; !isits->aborted() && blist[counter]; counter += 2)
	221	{
233	222	bl = (AP_tree_nlen *)blist[counter];
234	223	blf = (AP_tree_nlen *)blist[counter+1];
…	…
304	293	if (isits->every_sixteenth()) deep = -1;
305	294
306		a~~w_statu~~s("optimization");
307		e->dumpNNI = 1;
	295	arb_progress progress("optimization");
	296	e->dumpNNI = 1;
308	297	e->distInsertBorder = e->distanceToBorder(INT_MAX, (AP_tree_nlen*)leaf);
309		e->basesChanged = baseDiff;
310		e->nni_rek(~~false, isits->abort_flag,~~ deep, false, AP_BL_NNI_ONLY, NULL);
311		e->dumpNNI = 0;
	298	e->basesChanged = baseDiff;
	299	e->nni_rek(deep, false, AP_BL_NNI_ONLY, NULL);
	300	e->dumpNNI = 0;
312	301	}
313	302
…	…
351	340	static AP_tree_nlen insert_species_in_tree(const char key, AP_tree_nlen leaf, InsertData isits) {
352	341	if (!leaf) return leaf;
353		if (isits->abort~~_flag~~) return leaf;
	342	if (isits->aborted()) return leaf;
354	343
355	344	AP_tree_nlen *tree = rootNode();
…	…
367	356	}
368	357
369		~~++isits->currentspecies;~~
370		~~if (isits->singlestatus) {~~
371		~~sprintf(AW_ERROR_BUFFER, "Inserting Species %s (%li:%li)",~~
372		~~key, isits->currentspecies, isits->maxspecies);~~
373		~~aw_openstatus(AW_ERROR_BUFFER);~~
374		}
375
376	358	if (!tree) { // no tree yet
377	359	static AP_tree_nlen *last_inserted = NULL; // @@@ move 'last_inserted' into 'InsertData'
…	…
392	374	}
393	375	else {
394		~~aw_status("Searching best position");~~
395
396	376	ASSERT_VALID_TREE(tree);
397	377
…	…
418	398	ASSERT_VALID_TREE(rootNode());
419	399
420		for (long counter = 0; !isits->abort_flag && branchlist[counter]; counter += 2) {
421		if (isits->singlestatus && isits->every_sixteenth()) {
422		isits->abort_flag = aw_status(counter/(bsum*2.0));
423		}
	400	for (long counter = 0; !isits->aborted() && branchlist[counter]; counter += 2) {
424	401	AP_tree_nlen *bl = branchlist[counter];
425	402	AP_tree_nlen *blf = branchlist[counter+1];
…	…
462	439
463	440	if (!isits->quick_add_flag) {
464		int deep = 5;
	441	int deep = 5;
465	442	if (isits->every_sixteenth()) deep = -1;
466		aw_status("optimization");
467		bestposl->get_father()->nn_interchange_rek(false, isits->abort_flag, deep, AP_BL_NNI_ONLY, true);
	443
	444	arb_progress progress("optimization");
	445	bestposl->get_father()->nn_interchange_rek(deep, AP_BL_NNI_ONLY, true);
468	446	ASSERT_VALID_TREE(rootNode());
469	447	}
…	…
481	459
482	460	char *label = GBS_global_string_copy(format, to_insert->name);
483		~~isits->currentspecies--; // undo counter increment done by insert_species_in_tree~~
484	461	insert_species_in_tree(label, to_insert, isits);
485	462	free(label);
…	…
488	465	}
489	466
490		~~if (!isits->singlestatus) {~~
491		~~isits->abort_flag \|= aw_status(isits->currentspecies/(double)isits->maxspecies);~~
492		}
493
494	467	ASSERT_VALID_TREE(rootNode());
495	468	}
…	…
499	472
500	473	static long hash_insert_species_in_tree(const char key, long leaf, void cd_isits) {
501		InsertData isits = (InsertData)cd_isits;
502		return (long)insert_species_in_tree(key, (AP_tree_nlen*)leaf, isits);
503		}
504
505		static long count_hash_elements(const char , long val, void cd_isits) {
	474	InsertData isits = (InsertData)cd_isits;
	475	long result = (long)insert_species_in_tree(key, (AP_tree_nlen*)leaf, isits);
	476	isits->inc();
	477	return result;
	478	}
	479
	480	static long count_hash_elements(const char , long val, void cd_count) {
506	481	if (val) {
507		~~InsertData isits = (InsertData)cd_isits~~;
508		~~isits->maxspecies~~++;
	482	long count = (long)cd_count;
	483	(*count)++;
509	484	}
510	485	return val;
…	…
529	504	}
530	505	}
531
532		~~aw_openstatus("Search selected species");~~
533	506
534	507	GB_HASH *hash = 0;
…	…
562	535	NT_remove_species_in_tree_from_hash(rootNode(), hash);
563	536
564		~~InsertData isits(quick)~~;
565		GBS_hash_do_loop(hash, count_hash_elements, &~~isit~~s);
566		~~aw_openstatus(GBS_global_string("Adding %li species", isits.maxspecies)~~);
	537	long max_species = 0;
	538	GBS_hash_do_loop(hash, count_hash_elements, &max_species);
	539	InsertData isits(quick, max_species);
567	540
568	541	if (test) {
…	…
570	543	}
571	544	else {
572		~~aw_status("reading database");~~
573	545	GB_begin_transaction(GLOBAL_gb_main);
574	546	GBS_hash_do_loop(hash, transform_gbd_to_leaf, NULL);
…	…
577	549	}
578	550	if (!quick) {
579		aw_status("final optimization");
580		rootEdge()->nni_rek(false, isits.abort_flag, -1, false, AP_BL_NNI_ONLY, NULL);
	551	rootEdge()->nni_rek(-1, false, AP_BL_NNI_ONLY, NULL);
581	552	}
582	553
583	554	if (rootNode()) {
584		aw_status("Calculating Branch lengths");
585		rootEdge()->nni_rek(false, isits.abort_flag, -1, false, AP_BL_BL_ONLY, NULL);
	555	rootEdge()->calc_branchlengths();
586	556
587	557	ASSERT_VALID_TREE(rootNode());
…	…
600	570	error = "Tree lost (no leafs left)";
601	571	}
602
603		~~aw_closestatus();~~
604	572	}
605	573
…	…
792	760	int no_data = 0; // no data in alignment
793	761
794		a~~w_openstatu~~s("Adding partial sequences");
	762	arb_progress("Adding partial sequences");
795	763
796	764	{
…	…
855	823	list<PartialSequence>::iterator e = partial.end();
856	824
	825	arb_progress part_insert_progress(partial.size());
	826
857	827	#if defined(DEBUG)
858	828	// show results :
…	…
950	920	delete part_leaf;
951	921	}
	922
	923	part_insert_progress.inc_and_check_user_abort(error);
952	924	}
953	925	}
954	926	}
955
956		~~aw_closestatus();~~
957	927
958	928	if (full_marked_sequences) {
…	…
1031	1001
1032	1002	static void NT_branch_lengths(AW_window , AWT_canvas ntw) {
1033		aw_openstatus("Calculating Branch Lengths");
1034		int abort_flag = false;
1035		rootEdge()->nni_rek(false, abort_flag, -1, false, AP_BL_BL_ONLY, NULL);
1036
1037		aw_closestatus();
	1003	arb_progress progress("Calculating Branch Lengths");
	1004	rootEdge()->calc_branchlengths();
1038	1005	AWT_TREE(ntw)->resort_tree(0);
1039
1040	1006	pars_saveNrefresh_changed_tree(ntw);
1041	1007	}
1042	1008
1043	1009	static void NT_bootstrap(AW_window , AWT_canvas ntw, AW_CL limit_only) {
1044		aw_openstatus("Calculating Bootstrap Limit");
1045		int abort_flag = false;
1046		rootEdge()->nni_rek(false, abort_flag, -1, false,
1047		AP_BL_MODE((limit_only ? AP_BL_BOOTSTRAP_LIMIT : AP_BL_BOOTSTRAP_ESTIMATE)\|AP_BL_BL_ONLY), NULL);
1048		aw_closestatus();
1049
	1010	arb_progress progress("Calculating Bootstrap Limit");
	1011	AP_BL_MODE mode = AP_BL_MODE((limit_only ? AP_BL_BOOTSTRAP_LIMIT : AP_BL_BOOTSTRAP_ESTIMATE)\|AP_BL_BL_ONLY);
	1012	rootEdge()->nni_rek(-1, false, mode, NULL);
1050	1013	AWT_TREE(ntw)->resort_tree(0);
1051
1052	1014	AWT_TREE(ntw)->tree_root_display = AWT_TREE(ntw)->get_root_node();
1053	1015	pars_saveNrefresh_changed_tree(ntw);
1054	1016	}
1055	1017
1056		static void NT_optimize(AW_window , AWT_canvas ntw)
1057		{
1058		aw_openstatus("Optimize Tree");
1059
1060		PARS_optimizer_cb(rootNode());
	1018	static void NT_optimize(AW_window , AWT_canvas ntw) {
	1019	arb_progress progress("Optimizing Tree");
	1020	PARS_optimizer_cb(rootNode(), progress);
1061	1021	ASSERT_VALID_TREE(rootNode());
1062
1063		aw_openstatus("Calculating Branch Lengths");
1064		int abort_flag = false;
1065		rootEdge()->nni_rek(false, abort_flag, -1, false, AP_BL_BL_ONLY, NULL);
	1022	rootEdge()->calc_branchlengths();
1066	1023	AWT_TREE(ntw)->resort_tree(0);
1067	1024	rootNode()->compute_tree(GLOBAL_gb_main);
1068		~~aw_closestatus();~~
1069	1025	pars_saveNrefresh_changed_tree(ntw);
1070	1026	}
1071	1027
1072		static void NT_recursiveNNI(AW_window , AWT_canvas ntw)
1073		{
1074		aw_openstatus("Recursive NNI");
1075		int abort_flag = false;
1076
1077		AP_FLOAT thisPars = rootNode()->costs();
1078		AP_FLOAT lastPars = -1.0;
1079
1080		aw_status(GBS_global_string("Old parsimony: %f", thisPars));
1081		while (thisPars!=lastPars && !abort_flag) {
1082		lastPars = thisPars;
1083		thisPars = rootEdge()->nni_rek(false, abort_flag, -1, true, AP_BL_NNI_ONLY, NULL);
1084		abort_flag \|= aw_status(GBS_global_string("New Parsimony: %f", thisPars));
1085		}
1086
1087		aw_status("Calculating Branch Lengths");
1088		abort_flag = false;
1089		rootEdge()->nni_rek(false, abort_flag, -1, false, AP_BL_BL_ONLY, NULL);
1090
	1028	static void NT_recursiveNNI(AW_window , AWT_canvas ntw) {
	1029	arb_progress progress("Recursive NNI");
	1030	AP_FLOAT orgPars = rootNode()->costs();
	1031	AP_FLOAT prevPars = orgPars;
	1032	progress.subtitle(GBS_global_string("Old parsimony: %.1f", orgPars));
	1033	while (!progress.aborted()) {
	1034	AP_FLOAT currPars = rootEdge()->nni_rek(-1, true, AP_BL_NNI_ONLY, NULL);
	1035	if (currPars == prevPars) break; // no improvement -> abort
	1036	progress.subtitle(GBS_global_string("New parsimony: %.1f (gain: %.1f)", currPars, orgPars-currPars));
	1037	prevPars = currPars;
	1038	}
	1039	rootEdge()->calc_branchlengths();
1091	1040	AWT_TREE(ntw)->resort_tree(0);
1092	1041	rootNode()->compute_tree(GLOBAL_gb_main);
1093		~~aw_closestatus();~~
1094	1042	pars_saveNrefresh_changed_tree(ntw);
1095	1043	}
…	…
1316	1264	{
1317	1265	GB_ERROR error = 0;
1318
1319		aw_openstatus("load tree");
	1266	arb_progress progress("loading tree");
1320	1267	NT_reload_tree_event(awr, ntw); // load first tree
1321	1268	if (!GLOBAL_PARS->tree->get_root_node()) {
…	…
1337	1284	error = GB_end_transaction(ntw->gb_main, error);
1338	1285	if (!error) {
1339		~~aw_status~~("Calculating inner nodes");
	1286	progress.subtitle("Calculating inner nodes");
1340	1287	GLOBAL_PARS->get_root_node()->costs();
1341	1288	}
1342	1289	}
1343		~~aw_closestatus();~~
1344	1290	if (error) aw_popup_exit(error);
1345	1291	}

branches/refactor/PARSIMONY/ap_tree_nlen.hxx

r7096	r7097
107	107	void parsimony_rek(char *mutPerSite = NULL);
108	108
109		AP_FLOAT nn_interchange_rek(bool openclosestatus,
110		int &abort,
111		int deep, // -1 means: do whole subtree
	109	AP_FLOAT nn_interchange_rek(int deep, // -1 means: do whole subtree
112	110	AP_BL_MODE mode,
113	111	bool skip_hidden);
…	…
240	238	// tree optimization:
241	239
242		AP_FLOAT nni_rek(bool openclosestatus,
243		int& Abort,
244		int deep,
245		bool skip_hidden,
246		AP_BL_MODE mode,
247		AP_tree_nlen *skipNode);
	240	AP_FLOAT nni_rek(int deep, bool skip_hidden, AP_BL_MODE mode, AP_tree_nlen *skipNode);
	241
	242	AP_FLOAT calc_branchlengths() { return nni_rek(-1, false, AP_BL_BL_ONLY, NULL); }
248	243
249	244	AP_FLOAT nni_mutPerSite(AP_FLOAT pars_one, AP_BL_MODE mode, MutationsPerSite *mps);

branches/refactor/PARSIMONY/pars_dtree.hxx

r6428	r7097
16	16	#endif
17	17
	18	class arb_progress;
18	19
19	20	class AWT_graphic_parsimony : public AWT_graphic_tree {
…	…
35	36
36	37	void PARS_tree_init(AWT_graphic_tree *agt);
37		void PARS_optimizer_cb(AP_tree *tree);
	38	void PARS_optimizer_cb(AP_tree *tree, arb_progress& progress);
38	39
39	40	#else

branches/refactor/PHYLO/Makefile

r7089	r7097
41	41	PH_data.o: $(ARBHOME)/INCLUDE/arb_error.h
42	42	PH_data.o: $(ARBHOME)/INCLUDE/arb_msg.h
	43	PH_data.o: $(ARBHOME)/INCLUDE/arb_progress.h
43	44	PH_data.o: $(ARBHOME)/INCLUDE/arb_string.h
44	45	PH_data.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
51	52	PH_data.o: $(ARBHOME)/INCLUDE/aw_keysym.hxx
52	53	PH_data.o: $(ARBHOME)/INCLUDE/aw_root.hxx
53		~~PH_data.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
54	54	PH_data.o: $(ARBHOME)/INCLUDE/aw_window.hxx
55	55	PH_data.o: $(ARBHOME)/INCLUDE/cb.h
…	…
96	96	PH_filt.o: $(ARBHOME)/INCLUDE/arb_error.h
97	97	PH_filt.o: $(ARBHOME)/INCLUDE/arb_msg.h
	98	PH_filt.o: $(ARBHOME)/INCLUDE/arb_progress.h
98	99	PH_filt.o: $(ARBHOME)/INCLUDE/arb_string.h
99	100	PH_filt.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
106	107	PH_filt.o: $(ARBHOME)/INCLUDE/aw_keysym.hxx
107	108	PH_filt.o: $(ARBHOME)/INCLUDE/aw_root.hxx
108		~~PH_filt.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
109	109	PH_filt.o: $(ARBHOME)/INCLUDE/aw_window.hxx
110	110	PH_filt.o: $(ARBHOME)/INCLUDE/cb.h
…	…
138	138	PH_main.o: $(ARBHOME)/INCLUDE/aw_preset.hxx
139	139	PH_main.o: $(ARBHOME)/INCLUDE/aw_root.hxx
140		~~PH_main.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
141	140	PH_main.o: $(ARBHOME)/INCLUDE/aw_window.hxx
142	141	PH_main.o: $(ARBHOME)/INCLUDE/awt.hxx

branches/refactor/PHYLO/PH_data.cxx

r6858	r7097
13	13	#include <arbdbt.h>
14	14	#include <aw_awar.hxx>
15		#include <a~~w_status.hxx~~>
	15	#include <arb_progress.h>
16	16	#include <aw_root.hxx>
17	17
…	…
147	147	bool compare[256];
148	148	AP_FLOAT number_of_comparisons;
149		~~double gauge;~~
150	149	bool bases_used = true; // rna oder dna sequence : nur zum testen und Entwicklung
151	150
152	151	if (!PHDATA::ROOT) return "nothing loaded yet";
	152
	153	arb_progress progress("Calculating matrix", (nentries*(nentries+1))/2);
153	154
154	155	aw_root = PH_used_windows::windowList->phylo_main_window->get_root();
…	…
251	252
252	253	// counting routine
253		~~aw_openstatus("Calculating Matrix");~~
254		~~aw_status("Calculate the matrix");~~
255	254	sequence_bufferi = 0;
256	255	sequence_bufferj = 0;
257	256	GB_transaction dummy(PHDATA::ROOT->gb_main);
258	257
	258	GB_ERROR error = 0;
259	259	for (i = 0; i < long(nentries); i++) {
260		~~gauge = (double) i / (double) nentries;~~
261		~~if (aw_status(gauge * gauge)) return 0;~~
262	260	delete sequence_bufferi;
263	261	sequence_bufferi = GB_read_string(hash_elements[i]->gb_species_data_ptr);
…	…
280	278	matrix->set(i, j, (matrix->get(i, j) / number_of_comparisons));
281	279	}
	280	progress.inc_and_check_user_abort(error);
282	281	}
283	282	}
284	283	delete sequence_bufferi;
285		delete sequence_bufferj;
286		aw_closestatus();
287
288		return 0;
289		}
	284	delete sequence_bufferj;
	285
	286	if (error) {
	287	delete matrix;
	288	matrix = NULL;
	289	}
	290
	291	return error;
	292	}

branches/refactor/PHYLO/PH_display.cxx

r6861	r7097
212	212
213	213	if (!device) return;
	214	if (!markerline) return;
	215
214	216	GB_transaction dummy(PHDATA::ROOT->gb_main);
215	217	switch (display_what) // be careful: text origin is lower left

branches/refactor/PHYLO/PH_filt.cxx

r6858	r7097
13	13	#include <arbdbt.h>
14	14	#include <aw_awar.hxx>
15		#include <a~~w_status.hxx~~>
	15	#include <arb_progress.h>
16	16	#include <aw_root.hxx>
17	17	#include <cctype>
…	…
95	95	AW_root *aw_root;
96	96	float *mline = 0;
97		~~double gauge;~~
98	97
99	98	if (!PHDATA::ROOT) return 0; // nothing loaded yet
100	99
	100	arb_progress filt_progress("Calculating filter");
	101
101	102	GB_transaction dummy(PHDATA::ROOT->gb_main);
102		bool ~~isNUC = true;~~ // rna oder dna sequence : nur zum testen und Entwicklung
	103	bool isNUC = true; // rna oder dna sequence : nur zum testen und Entwicklung
103	104	if (GBT_is_alignment_protein(PHDATA::ROOT->gb_main, PHDATA::ROOT->use)) {
104	105	isNUC = false;
…	…
299	300	}
300	301
301		aw_openstatus("Calculating Filter");
302		aw_status("Counting");
303		// counting routine
304		for (i=0; i<long(PHDATA::ROOT->nentries); i++) {
305		gauge = (double)i/(double)PHDATA::ROOT->nentries;
306		if (aw_status(gauge*gauge)) return 0;
307		sequence_buffer = (unsigned char*)GB_read_char_pntr(PHDATA::ROOT->hash_elements[i]->gb_species_data_ptr);
308		long send = stopcol;
309		long slen = GB_read_string_count(PHDATA::ROOT->hash_elements[i]->gb_species_data_ptr);
310		if (slen< send) send = slen;
311		for (j=startcol; j<send; j++) {
312		if (mask[sequence_buffer[j]]) {
313		chars_counted[j-startcol][reference_table[sequence_buffer[j]]]++;
314		}
315		else {
316		chars_counted[j-startcol][num_all_chars+1]++;
317		}
	302	GB_ERROR error = NULL;
	303	{
	304	arb_progress progress("Counting", PHDATA::ROOT->nentries);
	305	// counting routine
	306	for (i=0; i<long(PHDATA::ROOT->nentries) && !error; i++) {
	307	sequence_buffer = (unsigned char*)GB_read_char_pntr(PHDATA::ROOT->hash_elements[i]->gb_species_data_ptr);
	308	long send = stopcol;
	309	long slen = GB_read_string_count(PHDATA::ROOT->hash_elements[i]->gb_species_data_ptr);
	310	if (slen< send) send = slen;
	311	for (j=startcol; j<send; j++) {
	312	if (mask[sequence_buffer[j]]) {
	313	chars_counted[j-startcol][reference_table[sequence_buffer[j]]]++;
	314	}
	315	else {
	316	chars_counted[j-startcol][num_all_chars+1]++;
	317	}
	318	}
	319	progress.inc_and_check_user_abort(error);
318	320	}
319	321	}
320
321		// calculate similarity
322		~~aw_status("Calculate similarity"~~);
323		~~for (i=0; i<len~~; i++) {
324		~~if (aw_status(i/(double)len)) return 0;~~
325		~~if (chars_counted[i][num_all_chars]==0) // else: forget whole column~~
326		{
327		~~max=0; max_char=' ';~~
328		~~for (j=0; get_maximum_from[j]!='\0'; j++~~) {
329		~~if (max<chars_counted[i][reference_table[(unsigned char)get_maximum_from[j]]]) {~~
330		~~max_char = get_maximum_from[j~~];
331		~~max = chars_counted[i][reference_table[(unsigned char)max_char]];~~
	322	if (!error) {
	323	// calculate similarity
	324	arb_progress progress("Calculate similarity", len);
	325	for (i=0; i<len && !error; i++) {
	326	if (chars_counted[i][num_all_chars]==0) // else: forget whole column
	327	{
	328	max=0; max_char=' ';
	329	for (j=0; get_maximum_from[j]!='\0'; j++) {
	330	if (max<chars_counted[i][reference_table[(unsigned char)get_maximum_from[j]]]) {
	331	max_char = get_maximum_from[j];
	332	max = chars_counted[i][reference_table[(unsigned char)max_char]];
	333	}
332	334	}
333		}
334		if ((max!=0) && !strchr(delete_when_max, max_char)) {
335		// delete SKIP_COLUMN_IF_MAX classes for counting
336		for (j=0; delete_when_max[j]!='\0'; j++) {
337		chars_counted[i][num_all_chars+1] += chars_counted[i][reference_table[(unsigned char)delete_when_max[j]]];
338		chars_counted[i][reference_table[(unsigned char)delete_when_max[j]]]=0;
	335	if ((max!=0) && !strchr(delete_when_max, max_char)) {
	336	// delete SKIP_COLUMN_IF_MAX classes for counting
	337	for (j=0; delete_when_max[j]!='\0'; j++) {
	338	chars_counted[i][num_all_chars+1] += chars_counted[i][reference_table[(unsigned char)delete_when_max[j]]];
	339	chars_counted[i][reference_table[(unsigned char)delete_when_max[j]]]=0;
	340	}
	341	mline[i+startcol] = (max/
	342	((float) PHDATA::ROOT->nentries -
	343	(float) chars_counted[i][num_all_chars+1]))*100.0;
	344	// (maximum in column / number of counted positions) * 100
339	345	}
340		mline[i+startcol] = (max/
341		((float) PHDATA::ROOT->nentries -
342		(float) chars_counted[i][num_all_chars+1]))*100.0;
343		// (maximum in column / number of counted positions) * 100
344		}
	346	}
	347	progress.inc_and_check_user_abort(error);
345	348	}
346	349	}
…	…
350	353	}
351	354	free(chars_counted);
352		aw_closestatus();
353
354		char filt=(char )calloc((int) PHDATA::ROOT->get_seq_len()+1, sizeof(char));
355		for (i=0; i<PHDATA::ROOT->get_seq_len(); i++)
356		filt[i]=((options_vector[OPT_MIN_HOM]<=mline[i])&&(options_vector[OPT_MAX_HOM]>=mline[i])) ? '1' : '0';
357		filt[i]='\0';
358		aw_root->awar("phyl/filter/filter")->write_string(filt);
359		free(filt);
360
361		return mline;
	355
	356	if (!error) {
	357	char filt=(char )calloc((int) PHDATA::ROOT->get_seq_len()+1, sizeof(char));
	358	for (i=0; i<PHDATA::ROOT->get_seq_len(); i++)
	359	filt[i]=((options_vector[OPT_MIN_HOM]<=mline[i])&&(options_vector[OPT_MAX_HOM]>=mline[i])) ? '1' : '0';
	360	filt[i]='\0';
	361	aw_root->awar("phyl/filter/filter")->write_string(filt);
	362	free(filt);
	363
	364	return mline;
	365	}
	366	else {
	367	delete mline;
	368	return 0;
	369	}
362	370	}
363	371

branches/refactor/PHYLO/PH_main.cxx

r6861	r7097
18	18	#include <aw_msg.hxx>
19	19	#include <awt.hxx>
20		~~#include <aw_status.hxx>~~
21	20	#include <aw_root.hxx>
22	21	#include <arbdbt.h>

branches/refactor/PRIMER_DESIGN/Makefile

r7089	r7097
58	58	PRD_Design.o: $(ARBHOME)/INCLUDE/arb_error.h
59	59	PRD_Design.o: $(ARBHOME)/INCLUDE/arb_msg.h
	60	PRD_Design.o: $(ARBHOME)/INCLUDE/arb_progress.h
60	61	PRD_Design.o: $(ARBHOME)/INCLUDE/arb_string.h
61	62	PRD_Design.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
128	129	primer_design.o: $(ARBHOME)/INCLUDE/arb_error.h
129	130	primer_design.o: $(ARBHOME)/INCLUDE/arb_msg.h
	131	primer_design.o: $(ARBHOME)/INCLUDE/arb_progress.h
130	132	primer_design.o: $(ARBHOME)/INCLUDE/arb_string.h
131	133	primer_design.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
140	142	primer_design.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
141	143	primer_design.o: $(ARBHOME)/INCLUDE/aw_root.hxx
142		~~primer_design.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
143	144	primer_design.o: $(ARBHOME)/INCLUDE/aw_window.hxx
144	145	primer_design.o: $(ARBHOME)/INCLUDE/awt_config_manager.hxx

branches/refactor/PRIMER_DESIGN/PRD_Design.cxx

r6385	r7097
13	13	#include "PRD_SequenceIterator.hxx"
14	14	#include "PRD_SearchFIFO.hxx"
	15	#include <arb_progress.h>
15	16
16	17	#include <iostream>
…	…
40	41	list2 = 0;
41	42	pairs = 0;
42
43		~~show_status_txt = 0;~~
44		~~show_status_double = 0;~~
45	43
46	44	setPositionalParameters (pos1_, pos2_, length_, distance_);
…	…
179	177	#endif // DEBUG
180	178
181		~~show_status("searching possible primers");~~
182	179	buildPrimerTrees();
183	180	if (error) return;
184	181	if (print_stages_ & PRINT_RAW_TREES) printPrimerTrees();
185	182
186		~~show_status("match possible primers vs. sequence");~~
187	183	matchSequenceAgainstPrimerTrees();
188	184	if (error) return;
189	185	if (print_stages_ & PRINT_MATCHED_TREES) printPrimerTrees();
190	186
191		~~show_status("evaluating primer pairs"); show_status(0.0~~);
	187	arb_progress::show_comment("evaluating primer pairs");
192	188	convertTreesToLists();
193	189	if (error) return;
…	…
276	272	void PrimerDesign::buildPrimerTrees ()
277	273	{
	274	arb_progress progress("searching possible primers",
	275	primer1.max()+primer2.max()-2*primer_length.min());
	276
278	277	#if defined(DEBUG)
279	278	primer1.print("buildPrimerTrees : pos1\t\t", "\n");
…	…
314	313	// build first tree
315	314	//
316		~~long int primer1_length = primer1.max()-primer1.min()+1;~~
317		~~show_status("searching possible primers -- left");~~
318
319	315	for (PRD_Sequence_Pos start_pos = primer1.min();
320	316	(start_pos < primer1.max()-primer_length.min()) && (sequence[start_pos] != '\x00');
321		start_pos++) {
322
323		show_status((double)(start_pos-primer1.min())/primer1_length/2);
324
	317	start_pos++)
	318	{
325	319	// start iterator at new position
326	320	sequence_iterator->restart(start_pos, primer1.max(), primer_length.max(), SequenceIterator::FORWARD);
…	…
346	340
347	341	offset++;
	342	progress.inc();
348	343	}
349	344
…	…
355	350	printf (" clearing left tree\n");
356	351	#endif
357		~~show_status("clearing left primertree");~~
358	352	clearTree(root1, 1, 0);
359	353	#if defined(DEBUG)
…	…
377	371	// build second tree
378	372	//
379		~~long int primer2_length = primer2.max()-primer2.min()+1;~~
380		~~show_status("searching possible primers -- right");~~
381
382	373	for (PRD_Sequence_Pos start_pos = primer2.min();
383	374	(start_pos < primer2.max()-primer_length.min()) && (sequence[start_pos] != '\x00');
384		start_pos++) {
385
386		show_status((double)(start_pos-primer2.min())/primer2_length/2+0.5);
387
	375	start_pos++)
	376	{
388	377	// start iterator at new position
389	378	sequence_iterator->restart(start_pos, primer2.max(), primer_length.max(), SequenceIterator::FORWARD);
…	…
409	398
410	399	offset++;
411		}
	400	progress.inc();
	401	}
	402	progress.done();
412	403
413	404	if (!treeContainsPrimer(root2)) {
…	…
424	415	printf (" clearing right tree\n");
425	416	#endif
426		~~show_status("clearing right primertree");~~
427	417	clearTree(root2, 0, 1);
428	418	#if defined(DEBUG)
…	…
496	486	#endif
497	487
498		show_status("match possible primers vs. seq. (forward)");
499		base = sequence_iterator->nextBase();
	488	arb_progress progress(seqLength);
	489
	490	progress.subtitle("match possible primers vs. seq. (forward)");
	491
	492	base = sequence_iterator->nextBase();
500	493	while (base != SequenceIterator::EOS) {
501	494	pos = sequence_iterator->pos;
502
503		~~if ((pos&0x7f) == 0) {~~
504		~~show_status((double)pos/seqLength/2);~~
505		}
506	495
507	496	// tree/fifo 1
…	…
531	520	// get next base in sequence
532	521	base = sequence_iterator->nextBase();
	522	progress.inc();
533	523	}
534	524
…	…
537	527	fifo2->flush();
538	528
539		~~show_status~~("match possible primers vs. seq. (backward)");
	529	progress.subtitle("match possible primers vs. seq. (backward)");
540	530	base = INVERT.BASE[sequence_iterator->nextBase()];
541	531	while (base != SequenceIterator::EOS) {
542	532	pos = sequence_iterator->pos;
543	533
544		~~if ((pos&0x7f) == 0) {~~
545		~~show_status((double)(seqLength-pos)/seqLength/2+0.5);~~
546		}
547
548	534	// tree/fifo 1
549	535	if (primer1.includes(pos)) { // flush fifo1 if in range of Primer 1
…	…
572	558	// get next base in sequence
573	559	base = INVERT.BASE[sequence_iterator->nextBase()];
574		}
	560	progress.inc();
	561	}
	562	progress.done();
575	563
576	564	delete fifo1;
…	…
924	912	#endif
925	913
926		~~show_status("evaluating primer pairs");~~
927	914	int list1_elems = 0;
928		~~int elems = 0;~~
929	915	while (one) {
930	916	list1_elems++;
…	…
933	919	one = list1;
934	920
	921	arb_progress progress("evaluating primer pairs", list1_elems);
935	922	// outer loop <= > run through list1
936	923	while (one != NULL)
937	924	{
938		~~show_status(GBS_global_string("evaluating primer pairs (%6.3f)", pairs[0].rating));~~
939		~~show_status((double)elems/list1_elems);~~
940		~~elems++;~~
941
942	925	// inner loop <= > run through list2
943	926	two = list2;
…	…
961	944	// next in outer loop
962	945	one = one->next;
	946	progress.inc();
963	947	}
964	948

branches/refactor/PRIMER_DESIGN/PRD_Design.hxx

r6381	r7097
155	155	double evaluatePair (Item one_, Item two_);
156	156	void insertPair (double rating_, Item one_, Item two_);
157
158		~~int (show_status_txt)(const char msg);~~
159		~~int (*show_status_double)(double gauge);~~
160
161		~~inline int show_status(const char *msg) { return show_status_txt ? show_status_txt(msg) : 0; }~~
162		~~inline int show_status(double gauge) { return show_status_double ? show_status_double(gauge) : 0; }~~
163
164		~~public:~~
165		~~void set_status_callbacks(int (show_txt)(const char), int (*show_double)(double)) {~~
166		~~show_status_txt = show_txt;~~
167		~~show_status_double = show_double;~~
168		}
169	157	};
170	158

branches/refactor/PRIMER_DESIGN/primer_design.cxx

r6858	r7097
22	22	#include <aw_window.hxx>
23	23	#include <aw_msg.hxx>
24		#include <a~~w_status.hxx~~>
	24	#include <arb_progress.h>
25	25	#include <aw_root.hxx>
26	26
…	…
89	89	}
90	90
91
92		~~inline int prd_aw_status(const char *s) { return aw_status(s); }~~
93		~~inline int prd_aw_status(double d) { return aw_status(d); }~~
94
95
96	91	static void primer_design_event_go(AW_window *aww, AW_CL cl_gb_main) {
97	92	AW_root *root = aww->get_root();
…	…
130	125
131	126	if (!error) {
132		a~~w_openstatus("Search~~ PCR primer pairs");
	127	arb_progress progress("Searching PCR primer pairs");
133	128	PrimerDesign *PD =
134	129	new PrimerDesign(sequence, length,
…	…
146	141	);
147	142
148		~~PD->set_status_callbacks(prd_aw_status, prd_aw_status);~~
149
150	143	try {
151	144	#ifdef DEBUG
…	…
208	201	if (sequence) free(sequence);
209	202	if (error) aw_message(error);
210
211		~~aw_closestatus();~~
212	203	}
213	204

branches/refactor/PROBE_DESIGN/Makefile

r7089	r7097
41	41	probe_design.o: $(ARBHOME)/INCLUDE/arb_error.h
42	42	probe_design.o: $(ARBHOME)/INCLUDE/arb_msg.h
	43	probe_design.o: $(ARBHOME)/INCLUDE/arb_progress.h
43	44	probe_design.o: $(ARBHOME)/INCLUDE/arb_string.h
44	45	probe_design.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
60	61	probe_design.o: $(ARBHOME)/INCLUDE/aw_root.hxx
61	62	probe_design.o: $(ARBHOME)/INCLUDE/aw_select.hxx
62		~~probe_design.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
63	63	probe_design.o: $(ARBHOME)/INCLUDE/aw_window.hxx
64	64	probe_design.o: $(ARBHOME)/INCLUDE/awt_canvas.hxx

branches/refactor/PROBE_DESIGN/probe_design.cxx

r6920	r7097
29	29	#include <aw_select.hxx>
30	30	#include <aw_msg.hxx>
31		#include <a~~w_status.hxx~~>
	31	#include <arb_progress.h>
32	32	#include <aw_root.hxx>
33	33	#include <adGene.h>
…	…
391	391	GBDATA gb_main = (GBDATA)cl_gb_main;
392	392
393		a~~w_openstatus("Probe D~~esign");
394		~~aw_status("Search a free running~~ server");
	393	arb_progress progress("Probe design");
	394	progress.subtitle("Connecting PT-server");
395	395
396	396	{
…	…
423	423	if (error) {
424	424	aw_message(error);
425		~~aw_closestatus();~~
426	425	return;
427	426	}
428	427
429		~~aw_status("Start probe design (Cannot be stopped)~~");
	428	progress.subtitle("probe design running");
430	429
431	430	aisc_create(pd_gl.link, PT_LOCS, pd_gl.locs,
…	…
447	446	if (probe_design_send_data(root, pdc)) {
448	447	aw_message ("Connection to PT_SERVER lost (1)");
449		~~aw_closestatus();~~
450	448	return;
451	449	}
…	…
463	461	NULL)) {
464	462	aw_message ("Connection to PT_SERVER lost (1)");
465		~~aw_closestatus();~~
466	463	return;
467	464	}
…	…
528	525	NULL);
529	526
530		~~aw_status("Read the results from the~~ server");
	527	progress.subtitle("Reading results from server");
531	528	{
532	529	char *locs_error = 0;
…	…
638	635
639	636	aisc_close(pd_gl.link); pd_gl.link = 0;
640		~~aw_closestatus();~~
641	637	return;
642	638	}
…	…
658	654	if (!gb_main) { error = "Internal error (gb_main unknown)"; }
659	655
	656	SmartPtr<arb_progress> progress;
	657
660	658	if (!error) {
661	659	const char *servername = PD_probe_pt_look_for_server(root, gb_main, error);
…	…
672	670
673	671	if (show_status) {
674		~~aw_openstatus("Probe M~~atch");
675		~~aw_status("Open Connection~~");
	672	progress = new arb_progress("Probe match");
	673	progress->subtitle("Connecting PT-server");
676	674	}
677	675
…	…
682	680
683	681	if (!error) {
684		~~if (show_status) aw_status("Initialize Server");~~
685	682	if (init_local_com_struct()) error = "Cannot contact PT-server (2)";
686	683
…	…
694	691
695	692	if (!error) {
696		if (show_status) ~~aw_status("Start Probe Match~~");
	693	if (show_status) progress->subtitle("Probe match running");
697	694
698	695	if (aisc_nput(pd_gl.link, PT_LOCS, pd_gl.locs,
…	…
723	720	long matches_truncated = 0;
724	721	if (!error) {
725		if (show_status) ~~aw_status("Read the R~~esults");
	722	if (show_status) progress->subtitle("Reading results");
726	723
727	724	T_PT_MATCHLIST match_list;
…	…
760	757
761	758	if (!error) {
762		~~if (show_status) aw_status("Parse the Results");~~
763
764	759	char toksep[2] = { 1, 0 };
765	760	char *strtok_ptr = 0; // stores strtok position
…	…
797	792	GBDATA *gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);
798	793	if (mark && !error) {
799		if (show_status) ~~aw_status~~(gene_flag ? "Unmarking all species and genes" : "Unmarking all species");
	794	if (show_status) progress->subtitle(gene_flag ? "Unmarking all species and genes" : "Unmarking all species");
800	795	for (GBDATA *gb_species = GBT_first_marked_species_rel_species_data(gb_species_data);
801	796	gb_species;
…	…
824	819	}
825	820	if (write_2_tmp && !error) {
826		if (show_status) ~~aw_status~~("Deleting old 'tmp' fields");
	821	if (show_status) progress->subtitle("Deleting old 'tmp' fields");
827	822	for (GBDATA *gb_species = GBT_first_species_rel_species_data(gb_species_data);
828	823	gb_species;
…	…
846	841
847	842	if (!error) {
848		if (show_status) ~~aw_status("Parsing results..~~");
	843	if (show_status) progress->subtitle("Parsing results");
849	844
850	845	g_spd->probeSpecies.clear();
…	…
1003	998
1004	999	aww->insert_default_selection(selection_id, last_line, "");
1005
1006		~~if (show_status) aw_status("Formatting output");~~
1007	1000	aww->update_selection_list(selection_id);
1008	1001	}
1009
1010		~~if (show_status) aw_closestatus();~~
1011	1002
1012	1003	free(bs.data);
…	…
1029	1020
1030	1021	aww->init_list_entry_iterator(iselection_id); // init
1031		aw_openstatus("Matching all resolved strings");
1032
1033		size_t string_count = iselection_id->size();
1034		size_t local_count = 0;
1035
	1022
	1023	arb_progress progress("Matching all resolved strings", iselection_id->size());
	1024
	1025	bool got_result = false;
1036	1026	for (;;) {
1037	1027	const char *entry = aww->get_list_entry_char_value();
1038	1028	if (!entry) break;
1039
1040		~~double percent = local_count++/double(string_count);~~
1041		~~aw_status(GBS_global_string("Match string %zu of %zu", local_count, string_count));~~
1042		~~aw_status(percent);~~
1043	1029
1044	1030	root->awar(AWAR_TARGET_STRING)->write_string(entry); // probe match
…	…
1051	1037	sprintf(buffer, "%5i %s", counter, entry);
1052	1038	aww->set_list_entry_displayed(buffer);
	1039	got_result = true;
1053	1040	delete buffer;
1054	1041
1055	1042	aww->iterate_list_entry(1); // iterate
1056		}
1057
1058		~~aw_closestatus();~~
1059
1060		if (~~local_coun~~t) {
	1043	progress.inc();
	1044
	1045	}
	1046
	1047	if (got_result) {
1061	1048	aww->sort_selection_list(iselection_id, 1, 1);
1062	1049	aww->update_selection_list(iselection_id);
…	…
1627	1614	static void pd_start_pt_server(AW_window *aww, AW_CL cl_gb_main) {
1628	1615	const char *server_tag = GBS_ptserver_tag(aww->get_root()->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int());
1629
1630		aw_openstatus("Start a server");
1631		aw_status("Look for server or start one");
1632
	1616	arb_progress progress("Connecting PT-server");
1633	1617	GB_ERROR error = arb_look_and_start_server(AISC_MAGIC_NUMBER, server_tag, (GBDATA*)cl_gb_main);
1634	1618	if (error) aw_message(error);
1635		~~aw_closestatus();~~
1636	1619	}
1637	1620
…	…
1652	1635	}
1653	1636
1654		aw_openstatus("Stopping PT-servers..");
1655
1656		for (int i = min; i <= max; i++) {
	1637	arb_progress progress("Stopping PT-servers..", max-min+1);
	1638	GB_ERROR error = NULL;
	1639
	1640	for (int i = min; i <= max && !error; i++) {
1657	1641	char *choice = GBS_ptserver_id_to_choice(i, 0);
1658	1642	if (!choice) {
1659		aw_message(GB_await_error());
1660		break;
1661		}
1662
1663		aw_status(GBS_global_string("Trying to stop '%s'", choice));
1664
1665		const char *server_tag = GBS_ptserver_tag(i);
1666		GB_ERROR error = arb_look_and_kill_server(AISC_MAGIC_NUMBER, server_tag);
1667
1668		if (error) aw_message(GBS_global_string("Could not stop '%s' (Reason: %s)", choice, error));
1669		else aw_message(GBS_global_string("Stopped '%s'", choice));
1670
1671		free(choice);
1672		}
1673		aw_closestatus();
	1643	error = GB_await_error();
	1644	}
	1645	else {
	1646	progress.subtitle(GBS_global_string("Trying to stop '%s'", choice));
	1647
	1648	const char *server_tag = GBS_ptserver_tag(i);
	1649	GB_ERROR kill_error = arb_look_and_kill_server(AISC_MAGIC_NUMBER, server_tag);
	1650
	1651	if (kill_error) aw_message(GBS_global_string("Could not stop '%s' (Reason: %s)", choice, kill_error));
	1652	else aw_message(GBS_global_string("Stopped '%s'", choice));
	1653
	1654	free(choice);
	1655	}
	1656	progress.inc_and_check_user_abort(error);
	1657	}
	1658	progress.done();
	1659	if (error) aw_message(error);
1674	1660	}
1675	1661	}
…	…
1732	1718	"Cancel,Do it"))
1733	1719	{
1734		a~~w_openstatu~~s("Updating PT-server");
1735		~~aw_status~~("Stopping PT-server");
	1720	arb_progress progress("Updating PT-server");
	1721	progress.subtitle("Stopping PT-server");
1736	1722	arb_look_and_kill_server(AISC_MAGIC_NUMBER, server_tag);
1737	1723
…	…
1746	1732	}
1747	1733
1748		~~aw_status~~("Exporting the database");
	1734	progress.subtitle("Exporting the database");
1749	1735	{
1750	1736	const char *mode = "bfm"; // save PT-server database with Fastload file
…	…
1756	1742	if (!error) {
1757	1743	// convert database (genes -> species)
1758		~~aw_status~~("Preparing DB for gene PT server");
	1744	progress.subtitle("Preparing DB for gene PT server");
1759	1745	GBS_add_ptserver_logentry("Preparing DB for gene PT server");
1760	1746	char *command = GBS_global_string_copy("$ARBHOME/bin/arb_gene_probe %s %s", temp_server_name, file);
…	…
1785	1771
1786	1772	if (!error) {
1787		~~aw_status~~("Start PT-server (builds in background)");
	1773	progress.subtitle("Start PT-server (builds in background)");
1788	1774	error = arb_start_server(server_tag, gb_main, 1);
1789	1775	}
1790		~~aw_closestatus();~~
1791
1792	1776	}
1793	1777	if (error) aw_message(error);

branches/refactor/SEQ_QUALITY/Makefile

r7089	r7097
61	61	SQ_functions.o: $(ARBHOME)/INCLUDE/arb_error.h
62	62	SQ_functions.o: $(ARBHOME)/INCLUDE/arb_msg.h
	63	SQ_functions.o: $(ARBHOME)/INCLUDE/arb_progress.h
63	64	SQ_functions.o: $(ARBHOME)/INCLUDE/arb_string.h
64	65	SQ_functions.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
70	71	SQ_functions.o: $(ARBHOME)/INCLUDE/aw_keysym.hxx
71	72	SQ_functions.o: $(ARBHOME)/INCLUDE/aw_preset.hxx
72		~~SQ_functions.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
73	73	SQ_functions.o: $(ARBHOME)/INCLUDE/aw_window.hxx
74	74	SQ_functions.o: $(ARBHOME)/INCLUDE/awt.hxx
…	…
93	93	SQ_main.o: $(ARBHOME)/INCLUDE/arb_error.h
94	94	SQ_main.o: $(ARBHOME)/INCLUDE/arb_msg.h
	95	SQ_main.o: $(ARBHOME)/INCLUDE/arb_progress.h
95	96	SQ_main.o: $(ARBHOME)/INCLUDE/arb_string.h
96	97	SQ_main.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
105	106	SQ_main.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
106	107	SQ_main.o: $(ARBHOME)/INCLUDE/aw_root.hxx
107		~~SQ_main.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
108	108	SQ_main.o: $(ARBHOME)/INCLUDE/aw_window.hxx
109	109	SQ_main.o: $(ARBHOME)/INCLUDE/awt.hxx

branches/refactor/SEQ_QUALITY/SQ_functions.cxx

r6858	r7097
19	19
20	20	#include <aw_preset.hxx>
21		#include <a~~w_status.hxx~~>
	21	#include <arb_progress.h>
22	22	#include <awt.hxx>
23	23	#include <arbdbt.h>
…	…
26	26
27	27	static SQ_GroupDataDictionary group_dict;
28		~~static int globalcounter = -1;~~
29		~~static int groupcounter = -1;~~
30		~~static int globalcounter_notree = 0;~~
31		~~static int pass1_counter_notree = 0;~~
32		~~static int pass2_counter_notree = 0;~~
33	28
34	29	enum {
…	…
418	413	}
419	414
420		GB_ERROR SQ_pass1(SQ_GroupData * globalData, GBDATA * gb_main, GBT_TREE * node,
421		AP_filter * filter) {
	415	GB_ERROR SQ_pass1(SQ_GroupData * globalData, GBDATA * gb_main, GBT_TREE * node, AP_filter * filter) {
422	416	char *alignment_name;
423
424	417	GBDATA *read_sequence = 0;
425	418	GBDATA *gb_species;
…	…
443	436	}
444	437	else {
445		GBDATA *gb_quality = GB_search(gb_species, "quality",
446		GB_CREATE_CONTAINER);
	438	GBDATA *gb_quality = GB_search(gb_species, "quality", GB_CREATE_CONTAINER);
447	439
448	440	if (!gb_quality) {
…	…
452	444	read_sequence = GB_entry(gb_ali, "data");
453	445
454		GBDATA *gb_quality_ali = GB_search(gb_quality, alignment_name,
455		GB_CREATE_CONTAINER);
	446	GBDATA *gb_quality_ali = GB_search(gb_quality, alignment_name, GB_CREATE_CONTAINER);
456	447	if (!gb_quality_ali)
457	448	error = GB_get_error();
…	…
459	450	/* real calculations start here */
460	451	if (read_sequence) {
461		char *rawSequence = SQ_fetch_filtered_sequence(read_sequence,
462		filter);
	452	char *rawSequence = SQ_fetch_filtered_sequence(read_sequence, filter);
463	453	int sequenceLength = filter->get_filtered_length();
464	454
…	…
466	456	{
467	457	SQ_physical_layout ps_chan;
468		ps_chan.SQ_calc_physical_layout(rawSequence,
469		sequenceLength, gb_quality_ali);
	458	ps_chan.SQ_calc_physical_layout(rawSequence, sequenceLength, gb_quality_ali);
470	459
471	460	/* calculate the average number of bases in group */
…	…
480	469	{
481	470	SQ_ambiguities ambi_chan;
482		ambi_chan.SQ_count_ambiguities(rawSequence, sequenceLength,
483		gb_quality_ali);
	471	ambi_chan.SQ_count_ambiguities(rawSequence, sequenceLength, gb_quality_ali);
484	472	}
485	473
…	…
487	475	{
488	476	SQ_helix heli_chan(sequenceLength);
489		heli_chan.SQ_calc_helix_layout(rawSequence, gb_main,
490		alignment_name, gb_quality_ali, filter);
	477	heli_chan.SQ_calc_helix_layout(rawSequence, gb_main, alignment_name, gb_quality_ali, filter);
491	478	}
492	479
…	…
514	501	}
515	502
516		GB_ERROR SQ_pass1_no_tree(SQ_GroupData * globalData, GBDATA * gb_main,
517		AP_filter * filter) {
	503	GB_ERROR SQ_pass1_no_tree(SQ_GroupData * globalData, GBDATA * gb_main, AP_filter * filter, arb_progress& progress) {
518	504	char *alignment_name;
519	505
…	…
531	517
532	518	getFirst = GBT_first_species;
533		getNext = GBT_next_species;
	519	getNext = GBT_next_species;
534	520
535	521	/* first pass operations */
536		for (gb_species = getFirst(gb_main); gb_species && !error; gb_species
537		= getNext(gb_species)) {
538
	522	for (gb_species = getFirst(gb_main); gb_species && !error; gb_species = getNext(gb_species)) {
539	523	gb_name = GB_entry(gb_species, "name");
540	524
…	…
548	532	}
549	533	else {
550		GBDATA *gb_quality = GB_search(gb_species, "quality",
551		GB_CREATE_CONTAINER);
	534	GBDATA *gb_quality = GB_search(gb_species, "quality", GB_CREATE_CONTAINER);
552	535	if (!gb_quality) {
553	536	error = GB_get_error();
…	…
556	539	read_sequence = GB_entry(gb_ali, "data");
557	540
558		GBDATA *gb_quality_ali = GB_search(gb_quality, alignment_name,
559		GB_CREATE_CONTAINER);
	541	GBDATA *gb_quality_ali = GB_search(gb_quality, alignment_name, GB_CREATE_CONTAINER);
560	542	if (!gb_quality_ali)
561	543	error = GB_get_error();
…	…
563	545	/* real calculations start here */
564	546	if (read_sequence) {
565		char *rawSequence = SQ_fetch_filtered_sequence(
566		read_sequence, filter);
	547	char *rawSequence = SQ_fetch_filtered_sequence(read_sequence, filter);
567	548	int sequenceLength = filter->get_filtered_length();
568	549
569	550	/* calculate physical layout of sequence */
570	551	SQ_physical_layout *ps_chan = new SQ_physical_layout();
571		ps_chan->SQ_calc_physical_layout(rawSequence,
572		sequenceLength, gb_quality_ali);
	552	ps_chan->SQ_calc_physical_layout(rawSequence, sequenceLength, gb_quality_ali);
573	553
574	554	/* calculate the average number of bases in group */
575	555	globalData->SQ_count_sequences();
576		globalData->SQ_set_avg_bases(ps_chan->
577		SQ_get_number_of_bases());
578		globalData->SQ_set_avg_gc(ps_chan->
579		SQ_get_gc_proportion());
	556	globalData->SQ_set_avg_bases(ps_chan->SQ_get_number_of_bases());
	557	globalData->SQ_set_avg_gc(ps_chan->SQ_get_gc_proportion());
580	558	delete ps_chan;
581	559
582	560	/* get values for ambiguities */
583	561	SQ_ambiguities *ambi_chan = new SQ_ambiguities();
584		ambi_chan->SQ_count_ambiguities(rawSequence,
585		sequenceLength, gb_quality_ali);
	562	ambi_chan->SQ_count_ambiguities(rawSequence, sequenceLength, gb_quality_ali);
586	563	delete ambi_chan;
587	564
588	565	/* calculate the number of strong, weak and no helixes */
589	566	SQ_helix *heli_chan = new SQ_helix(sequenceLength);
590		heli_chan->SQ_calc_helix_layout(rawSequence, gb_main,
591		alignment_name, gb_quality_ali, filter);
	567	heli_chan->SQ_calc_helix_layout(rawSequence, gb_main, alignment_name, gb_quality_ali, filter);
592	568	delete heli_chan;
593	569
…	…
599	575	globalData->SQ_add_sequence(rawSequence);
600	576	}
601		~~pass1_counter_notree++;~~
602		~~aw_status((double) pass1_counter_notree~~
603		~~/ (double) globalcounter_notree);~~
604
605	577	delete(rawSequence);
606	578	}
607	579	}
608	580	}
	581	progress.inc_and_check_user_abort(error);
609	582	}
610	583
…	…
670	643	double gcp = 0;
671	644
672		const char *rawSequence = SQ_fetch_filtered_sequence(
673		read_sequence, filter);
	645	const char *rawSequence = SQ_fetch_filtered_sequence(read_sequence, filter);
674	646
675	647	/*
…	…
677	649	a single sequence in group from it
678	650	*/
679		GBDATA *gb_result1 = GB_search(gb_quality_ali,
680		"number_of_bases", GB_INT);
	651	GBDATA *gb_result1 = GB_search(gb_quality_ali, "number_of_bases", GB_INT);
681	652	bases = GB_read_int(gb_result1);
682	653	avg_bases = globalData->SQ_get_avg_bases();
…	…
688	659	}
689	660
690		GBDATA *gb_result2 = GB_search(gb_quality_ali,
691		"percent_base_deviation", GB_INT);
	661	GBDATA *gb_result2 = GB_search(gb_quality_ali, "percent_base_deviation", GB_INT);
692	662	seq_assert(gb_result2);
693	663	GB_write_int(gb_result2, diff_percent);
…	…
697	667	a single sequence in group from it
698	668	*/
699		GBDATA *gb_result6 = GB_search(gb_quality_ali, "GC_proportion",
700		GB_FLOAT);
	669	GBDATA *gb_result6 = GB_search(gb_quality_ali, "GC_proportion", GB_FLOAT);
701	670	gcp = GB_read_float(gb_result6);
702	671	avg_gc = globalData->SQ_get_avg_gc();
…	…
708	677	}
709	678
710		GBDATA *gb_result7 = GB_search(gb_quality_ali,
711		"percent_GC_difference", GB_INT);
	679	GBDATA *gb_result7 = GB_search(gb_quality_ali, "percent_GC_difference", GB_INT);
712	680	seq_assert(gb_result7);
713	681	GB_write_int(gb_result7, diff_percent);
…	…
718	686	evaluate sequence with group consensus
719	687	*/
720		GBDATA *gb_con = GB_search(gb_quality_ali,
721		"consensus_conformity", GB_CREATE_CONTAINER);
	688	GBDATA *gb_con = GB_search(gb_quality_ali, "consensus_conformity", GB_CREATE_CONTAINER);
722	689	if (!gb_con)
723	690	error = GB_get_error();
724		GBDATA *gb_dev = GB_search(gb_quality_ali,
725		"consensus_deviation", GB_CREATE_CONTAINER);
	691	GBDATA *gb_dev = GB_search(gb_quality_ali, "consensus_deviation", GB_CREATE_CONTAINER);
726	692	if (!gb_dev)
727	693	error = GB_get_error();
…	…
731	697	while (backup->father) {
732	698	if (backup->name) {
733		SQ_GroupDataDictionary::iterator GDI =
734		group_dict.find(backup->name);
	699	SQ_GroupDataDictionary::iterator GDI = group_dict.find(backup->name);
735	700	if (GDI != group_dict.end()) {
736	701	SQ_GroupDataPtr GD_ptr = GDI->second;
737	702
738		consensus_result cr =
739		GD_ptr->SQ_calc_consensus(rawSequence);
	703	consensus_result cr = GD_ptr->SQ_calc_consensus(rawSequence);
740	704	value1 = cr.conformity;
741	705	value2 = cr.deviation;
742	706	value3 = GD_ptr->SQ_get_nr_sequences();
743	707
744		GBDATA *gb_node_entry = GB_search(gb_con,
745		"name", GB_STRING);
	708	GBDATA *gb_node_entry = GB_search(gb_con, "name", GB_STRING);
746	709	seq_assert(gb_node_entry);
747	710	GB_write_string(gb_node_entry, backup->name);
748	711
749		gb_node_entry = GB_search(gb_con, "value",
750		GB_FLOAT); seq_assert(gb_node_entry);
	712	gb_node_entry = GB_search(gb_con, "value", GB_FLOAT); seq_assert(gb_node_entry);
751	713	GB_write_float(gb_node_entry, value1);
752	714
753		gb_node_entry = GB_search(gb_con,
754		"num_species", GB_INT); seq_assert(gb_node_entry);
	715	gb_node_entry = GB_search(gb_con, "num_species", GB_INT); seq_assert(gb_node_entry);
755	716	GB_write_int(gb_node_entry, value3);
756	717
757		gb_node_entry = GB_search(gb_dev, "name",
758		GB_STRING); seq_assert(gb_node_entry);
	718	gb_node_entry = GB_search(gb_dev, "name", GB_STRING); seq_assert(gb_node_entry);
759	719	GB_write_string(gb_node_entry, backup->name);
760	720
761		gb_node_entry = GB_search(gb_dev, "value",
762		GB_FLOAT); seq_assert(gb_node_entry);
	721	gb_node_entry = GB_search(gb_dev, "value", GB_FLOAT); seq_assert(gb_node_entry);
763	722	GB_write_float(gb_node_entry, value2);
764	723
765		gb_node_entry = GB_search(gb_dev,
766		"num_species", GB_INT); seq_assert(gb_node_entry);
	724	gb_node_entry = GB_search(gb_dev, "num_species", GB_INT); seq_assert(gb_node_entry);
767	725	GB_write_int(gb_node_entry, value3);
768	726
…	…
832	790	evaluation = sq_round(eval);
833	791	}
834		GBDATA *gb_result5 = GB_search(gb_quality_ali,
835		"consensus_evaluated", GB_INT);
	792	GBDATA *gb_result5 = GB_search(gb_quality_ali, "consensus_evaluated", GB_INT);
836	793	seq_assert(gb_result5);
837	794	GB_write_int(gb_result5, evaluation);
…	…
853	810	}
854	811
855		GB_ERROR SQ_pass2_no_tree(const SQ_GroupData * globalData, GBDATA * gb_main,
856		AP_filter * filter) {
	812	GB_ERROR SQ_pass2_no_tree(const SQ_GroupData * globalData, GBDATA * gb_main, AP_filter * filter, arb_progress& progress) {
857	813	char *alignment_name;
858	814
…	…
867	823	GB_push_transaction(gb_main);
868	824	gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);
869		alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
870		getFirst = GBT_first_species;
871		getNext = GBT_next_species;
	825	alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
	826	getFirst = GBT_first_species;
	827	getNext = GBT_next_species;
872	828
873	829	/* second pass operations */
874		for (gb_species = getFirst(gb_main); gb_species && !error; gb_species
875		= getNext(gb_species)) {
	830	for (gb_species = getFirst(gb_main); gb_species && !error; gb_species = getNext(gb_species)) {
876	831	gb_name = GB_entry(gb_species, "name");
877	832
…	…
884	839	}
885	840	else {
886		GBDATA *gb_quality = GB_search(gb_species, "quality",
887		GB_CREATE_CONTAINER);
	841	GBDATA *gb_quality = GB_search(gb_species, "quality", GB_CREATE_CONTAINER);
888	842	if (!gb_quality)
889	843	error = GB_get_error();
890	844
891		GBDATA *gb_quality_ali = GB_search(gb_quality, alignment_name,
892		GB_CREATE_CONTAINER);
	845	GBDATA *gb_quality_ali = GB_search(gb_quality, alignment_name, GB_CREATE_CONTAINER);
893	846	if (!gb_quality_ali)
894	847	error = GB_get_error();
…	…
910	863	double gcp = 0;
911	864
912		const char *rawSequence = SQ_fetch_filtered_sequence(
913		read_sequence, filter);
	865	const char *rawSequence = SQ_fetch_filtered_sequence(read_sequence, filter);
914	866
915	867	/*
…	…
917	869	a single sequence in group from it
918	870	*/
919		GBDATA *gb_result1 = GB_search(gb_quality_ali,
920		"number_of_bases", GB_INT);
	871	GBDATA *gb_result1 = GB_search(gb_quality_ali, "number_of_bases", GB_INT);
921	872	bases = GB_read_int(gb_result1);
922	873	avg_bases = globalData->SQ_get_avg_bases();
…	…
928	879	}
929	880
930		GBDATA *gb_result2 = GB_search(gb_quality_ali,
931		"percent_base_deviation", GB_INT);
	881	GBDATA *gb_result2 = GB_search(gb_quality_ali, "percent_base_deviation", GB_INT);
932	882	seq_assert(gb_result2);
933	883	GB_write_int(gb_result2, diff_percent);
…	…
937	887	a single sequence in group from it
938	888	*/
939		GBDATA *gb_result6 = GB_search(gb_quality_ali,
940		"GC_proportion", GB_FLOAT);
	889	GBDATA *gb_result6 = GB_search(gb_quality_ali, "GC_proportion", GB_FLOAT);
941	890	gcp = GB_read_float(gb_result6);
942	891	avg_gc = globalData->SQ_get_avg_gc();
…	…
948	897	}
949	898
950		GBDATA *gb_result7 = GB_search(gb_quality_ali,
951		"percent_GC_difference", GB_INT);
	899	GBDATA *gb_result7 = GB_search(gb_quality_ali, "percent_GC_difference", GB_INT);
952	900	seq_assert(gb_result7);
953	901	GB_write_int(gb_result7, diff_percent);
…	…
958	906	evaluate sequence with group consensus
959	907	*/
960		GBDATA *gb_con = GB_search(gb_quality_ali,
961		"consensus_conformity", GB_CREATE_CONTAINER);
	908	GBDATA *gb_con = GB_search(gb_quality_ali, "consensus_conformity", GB_CREATE_CONTAINER);
962	909	if (!gb_con)
963	910	error = GB_get_error();
964		GBDATA *gb_dev = GB_search(gb_quality_ali,
965		"consensus_deviation", GB_CREATE_CONTAINER);
	911	GBDATA *gb_dev = GB_search(gb_quality_ali, "consensus_deviation", GB_CREATE_CONTAINER);
966	912	if (!gb_dev)
967	913	error = GB_get_error();
968	914
969		consensus_result cr =
970		globalData->SQ_calc_consensus(rawSequence);
	915	consensus_result cr = globalData->SQ_calc_consensus(rawSequence);
971	916	value1 = cr.conformity;
972	917	value2 = cr.deviation;
973	918	value3 = globalData->SQ_get_nr_sequences();
974	919
975		GBDATA *gb_node_entry = GB_search(gb_con, "name",
976		GB_STRING);
	920	GBDATA *gb_node_entry = GB_search(gb_con, "name", GB_STRING);
977	921	seq_assert(gb_node_entry);
978	922	GB_write_string(gb_node_entry, "one global consensus");
…	…
981	925	GB_write_float(gb_node_entry, value1);
982	926
983		gb_node_entry = GB_search(gb_con, "num_species",
984		GB_INT); seq_assert(gb_node_entry);
	927	gb_node_entry = GB_search(gb_con, "num_species", GB_INT); seq_assert(gb_node_entry);
985	928	GB_write_int(gb_node_entry, value3);
986	929
…	…
991	934	GB_write_float(gb_node_entry, value2);
992	935
993		gb_node_entry = GB_search(gb_dev, "num_species",
994		GB_INT); seq_assert(gb_node_entry);
	936	gb_node_entry = GB_search(gb_dev, "num_species", GB_INT); seq_assert(gb_node_entry);
995	937	GB_write_int(gb_node_entry, value3);
996	938
…	…
1052	994	evaluation = sq_round(eval);
1053	995	}
1054		GBDATA *gb_result5 = GB_search(gb_quality_ali,
1055		"consensus_evaluated", GB_INT);
	996	GBDATA *gb_result5 = GB_search(gb_quality_ali, "consensus_evaluated", GB_INT);
1056	997	seq_assert(gb_result5);
1057	998	GB_write_int(gb_result5, evaluation);
1058	999	// --------end cut this-------
1059		~~pass2_counter_notree++;~~
1060		~~aw_status((double) pass2_counter_notree~~
1061		~~/ (double) globalcounter_notree);~~
1062
1063	1000	delete(rawSequence);
1064	1001	}
1065	1002	}
1066	1003	}
	1004	progress.inc_and_check_user_abort(error);
1067	1005	}
1068	1006	free(alignment_name);
…	…
1076	1014	}
1077	1015
1078		// counts number of named groups in subtree
1079		int SQ_count_nr_of_groups(GBT_TREE * node) {
1080		if (node->is_leaf)
1081		return 0;
1082
1083		return (node->name != 0) + SQ_count_nr_of_groups(node->leftson)
1084		+ SQ_count_nr_of_groups(node->rightson);
1085		}
1086
1087		// counts number of species
1088		GB_ERROR SQ_count_nr_of_species(GBDATA * gb_main) {
1089		char *alignment_name;
1090
1091		GBDATA *read_sequence = 0;
1092		GBDATA *gb_species;
1093		GBDATA *gb_species_data;
1094		GBDATA *gb_name;
1095		GBDATA (getFirst)(GBDATA *) = 0;
1096		GBDATA (getNext)(GBDATA *) = 0;
1097		GB_ERROR error = 0;
1098
1099		GB_push_transaction(gb_main);
1100		gb_species_data = GB_search(gb_main, "species_data", GB_CREATE_CONTAINER);
1101		alignment_name = GBT_get_default_alignment(gb_main); seq_assert(alignment_name);
1102		getFirst = GBT_first_species;
1103		getNext = GBT_next_species;
1104
1105		for (gb_species = getFirst(gb_main); gb_species && !error; gb_species
1106		= getNext(gb_species)) {
1107
1108		gb_name = GB_entry(gb_species, "name");
1109
1110		if (!gb_name)
1111		error = GB_get_error();
1112		else {
1113		GBDATA *gb_ali = GB_entry(gb_species, alignment_name);
1114
1115		if (!gb_ali) {
1116		error = no_data_error(gb_species, alignment_name);
1117		}
1118		else {
1119		GBDATA *gb_quality = GB_search(gb_species, "quality",
1120		GB_CREATE_CONTAINER);
1121		if (!gb_quality)
1122		error = GB_get_error();
1123		read_sequence = GB_entry(gb_ali, "data");
1124
1125		if (read_sequence) {
1126		globalcounter_notree++;
1127		}
1128		}
1129		}
1130		}
1131		free(alignment_name);
1132
1133		if (error)
1134		GB_abort_transaction(gb_main);
1135		else
1136		GB_pop_transaction(gb_main);
1137
1138		return error;
1139		}
1140
1141		void SQ_reset_counters(GBT_TREE * root) {
1142		globalcounter = 0;
1143		groupcounter = SQ_count_nr_of_groups(root);
	1016	int SQ_count_nodes(GBT_TREE *node) {
	1017	// calculate number of nodes in tree
	1018	return GBT_count_leafs(node)*2-1;
1144	1019	}
1145	1020
…	…
1150	1025	}
1151	1026
1152		void SQ_calc_and_apply_group_data(GBT_TREE * node, GBDATA * gb_main,
1153		SQ_GroupData * data, AP_filter * filter) {
	1027	void SQ_calc_and_apply_group_data(GBT_TREE * node, GBDATA * gb_main, SQ_GroupData * data, AP_filter * filter, arb_progress& progress) {
1154	1028	if (node->is_leaf) {
1155	1029	if (node->gb_node) {
…	…
1167	1041	if (data->getSize() == 0) {
1168	1042	parentIsEmpty = true;
1169		SQ_calc_and_apply_group_data(node1, gb_main, data, filter); // process left branch with empty data
	1043	SQ_calc_and_apply_group_data(node1, gb_main, data, filter, progress); // process left branch with empty data
1170	1044	seq_assert(data->getSize()> 0);
1171	1045	}
1172	1046	else {
1173	1047	leftData = data->clone(); // create new empty SQ_GroupData
1174		SQ_calc_and_apply_group_data(node1, gb_main, leftData, filter); // process left branch
	1048	SQ_calc_and_apply_group_data(node1, gb_main, leftData, filter, progress); // process left branch
1175	1049	seq_assert(leftData->getSize()> 0);
1176	1050	}
1177	1051
1178	1052	rightData = data->clone(); // create new empty SQ_GroupData
1179		SQ_calc_and_apply_group_data(node2, gb_main, rightData, filter); // process right branch
	1053	SQ_calc_and_apply_group_data(node2, gb_main, rightData, filter, progress); // process right branch
1180	1054	seq_assert(rightData->getSize()> 0);
1181	1055
…	…
1189	1063
1190	1064	create_multi_level_consensus(node, data);
1191		~~globalcounter++;~~
1192		~~aw_status((double) globalcounter / (double) groupcounter);~~
1193	1065	}
1194	1066	else {
1195		SQ_calc_and_apply_group_data(node1, gb_main, data, filter); // enter left branch
	1067	SQ_calc_and_apply_group_data(node1, gb_main, data, filter, progress); // enter left branch
1196	1068	seq_assert(data->getSize()> 0);
1197	1069
1198		SQ_calc_and_apply_group_data(node2, gb_main, data, filter); // enter right branch
	1070	SQ_calc_and_apply_group_data(node2, gb_main, data, filter, progress); // enter right branch
1199	1071	seq_assert(data->getSize()> 0);
1200	1072	}
1201	1073	}
1202		}
1203
1204		void SQ_calc_and_apply_group_data2(GBT_TREE * node, GBDATA * gb_main,
1205		~~const SQ_GroupData * data, AP_filter * filter~~) {
	1074	progress.inc();
	1075	}
	1076
	1077	void SQ_calc_and_apply_group_data2(GBT_TREE * node, GBDATA * gb_main, const SQ_GroupData * data, AP_filter * filter, arb_progress& progress) {
1206	1078	if (node->is_leaf) {
1207	1079	if (node->gb_node) {
…	…
1213	1085	GBT_TREE *node2 = node->rightson;
1214	1086
1215		if (node1) {
1216		SQ_calc_and_apply_group_data2(node1, gb_main, data, filter);
1217		}
1218		if (node2) {
1219		SQ_calc_and_apply_group_data2(node2, gb_main, data, filter);
1220		}
1221		if (node->name) { // group identified
1222		globalcounter++;
1223		aw_status((double) globalcounter / (double) groupcounter);
1224		}
1225		}
	1087	if (node1) SQ_calc_and_apply_group_data2(node1, gb_main, data, filter, progress);
	1088	if (node2) SQ_calc_and_apply_group_data2(node2, gb_main, data, filter, progress);
	1089	}
	1090	progress.inc();
1226	1091	}
1227	1092
…	…
1252	1117	}
1253	1118
1254		for (gb_species = getFirst(gb_main); gb_species; gb_species
1255		= getNext(gb_species)) {
	1119	for (gb_species = getFirst(gb_main); gb_species; gb_species = getNext(gb_species)) {
1256	1120	GBDATA *gb_ali = GB_entry(gb_species, alignment_name);
1257	1121	bool marked = false;
1258	1122	if (gb_ali) {
1259		GBDATA *gb_quality = GB_search(gb_species, "quality",
1260		GB_CREATE_CONTAINER);
	1123	GBDATA *gb_quality = GB_search(gb_species, "quality", GB_CREATE_CONTAINER);
1261	1124	if (gb_quality) {
1262	1125	read_sequence = GB_entry(gb_ali, "data");
1263	1126	if (read_sequence) {
1264		GBDATA *gb_quality_ali = GB_search(gb_quality,
1265		alignment_name, GB_CREATE_CONTAINER);
	1127	GBDATA *gb_quality_ali = GB_search(gb_quality, alignment_name, GB_CREATE_CONTAINER);
1266	1128	if (gb_quality_ali) {
1267		GBDATA *gb_result1 = GB_search(gb_quality_ali,
1268		"evaluation", GB_INT);
	1129	GBDATA *gb_result1 = GB_search(gb_quality_ali, "evaluation", GB_INT);
1269	1130	result = GB_read_int(gb_result1);
1270	1131
1271		if (result < condition) {
1272		marked = true;
1273		}
1274		pass1_counter_notree++;
1275		aw_status((double) pass1_counter_notree
1276		/ (double) globalcounter_notree);
	1132	if (result < condition) marked = true;
1277	1133	}
1278	1134	}

branches/refactor/SEQ_QUALITY/SQ_functions.h

r6381	r7097
37	37
38	38	class AP_filter;
	39	class arb_progress;
39	40	struct GBT_TREE;
40	41
…	…
48	49
49	50	GB_ERROR SQ_pass1(SQ_GroupData * globalData, GBDATA * gb_main, GBT_TREE * node, AP_filter * filter);
50		GB_ERROR SQ_pass1_no_tree(SQ_GroupData * globalData, GBDATA * gb_main, AP_filter * filter);
	51	GB_ERROR SQ_pass1_no_tree(SQ_GroupData * globalData, GBDATA * gb_main, AP_filter * filter, arb_progress& progress);
51	52
52	53	GB_ERROR SQ_pass2(const SQ_GroupData * globalData, GBDATA * gb_main, GBT_TREE * node, AP_filter * filter);
53		GB_ERROR SQ_pass2_no_tree(const SQ_GroupData * globalData, GBDATA * gb_main, AP_filter * filter);
	54	GB_ERROR SQ_pass2_no_tree(const SQ_GroupData * globalData, GBDATA * gb_main, AP_filter * filter, arb_progress& progress);
54	55
55		~~GB_ERROR SQ_count_nr_of_species(GBDATA * gb_main~~);
	56	int SQ_count_nodes(GBT_TREE *node);
56	57
57		void SQ_reset_counters(GBT_TREE * root); // reset counters used by SQ_calc_and_apply_group_data
58
59		void SQ_calc_and_apply_group_data(GBT_TREE * node, GBDATA * gb_main, SQ_GroupData * data, AP_filter * filter);
60		void SQ_calc_and_apply_group_data2(GBT_TREE * node, GBDATA * gb_main, const SQ_GroupData * data, AP_filter * filter);
	58	void SQ_calc_and_apply_group_data(GBT_TREE * node, GBDATA * gb_main, SQ_GroupData * data, AP_filter * filter, arb_progress& progress);
	59	void SQ_calc_and_apply_group_data2(GBT_TREE * node, GBDATA * gb_main, const SQ_GroupData * data, AP_filter * filter, arb_progress& progress);
61	60
62	61	void create_multi_level_consensus(GBT_TREE * node, SQ_GroupData * data);

branches/refactor/SEQ_QUALITY/SQ_main.cxx

r6858	r7097
21	21	#include <aw_awars.hxx>
22	22	#include <aw_msg.hxx>
23		#include <a~~w_status.hxx~~>
	23	#include <arb_progress.h>
24	24	#include <aw_root.hxx>
25	25	#include <arbdbt.h>
…	…
73	73	bool marked_only = (aw_root->awar(AWAR_SQ_MARK_ONLY_FLAG)->read_int() > 0);
74	74
	75	arb_progress main_progress("Calculating sequence quality");
	76
75	77	{
76	78	char *treename = aw_root->awar(AWAR_TREE)->read_string(); // contains "tree_????" if no tree is selected
…	…
123	125
124	126	/*
125		SQ_evaluate() generates the final estimation for the quality of an alignment.
126		It takes the values from the different containers, which are generated by the other functions, weights them
127		and calculates a final value. The final value is stored in "value_of_evaluation" (see options).
128		With the values stored in "weights" one can customize how important a value stored in a container becomes
129		for the final result.
130		*/
	127	SQ_evaluate() generates the final estimation for the quality of an alignment.
	128	It takes the values from the different containers, which are generated by the other functions, weights them
	129	and calculates a final value. The final value is stored in "value_of_evaluation" (see options).
	130	With the values stored in "weights" one can customize how important a value stored in a container becomes
	131	for the final result.
	132	*/
131	133
132	134	if (tree == 0) {
133	135	if (reevaluate) {
134		~~aw_openstatus("Marking Sequences...");~~
135	136	SQ_mark_species(gb_main, mark_below, marked_only);
136		~~aw_closestatus();~~
137	137	}
138	138	else {
	139	arb_progress progress(GBT_get_species_count(gb_main)*2);
139	140	SQ_GroupData *globalData = new SQ_GroupData_RNA;
140		SQ_count_nr_of_species(gb_main);
141		~~aw_openstatus("Calculating pass 1 of 2 ...~~");
142		~~SQ_pass1_no_tree(globalData, gb_main, filter~~);
143		~~aw_closestatus();~~
144		~~aw_openstatus("Calculating pass 2 of 2 ...~~");
145		~~SQ_pass2_no_tree(globalData, gb_main, filter~~);
146		~~SQ_evaluate(gb_main, weights, marked_only);~~
147		~~aw_closestatus(~~);
148		~~if (mark_flag~~) {
149		~~aw_openstatus("Marking Sequences..."~~);
150		~~SQ_mark_species(gb_main, mark_below, marked_only);~~
151		~~aw_closestatus();~~
	141
	142	progress.subtitle("pass1");
	143	error = SQ_pass1_no_tree(globalData, gb_main, filter, progress);
	144	if (!error) {
	145	progress.subtitle("pass2");
	146	error = SQ_pass2_no_tree(globalData, gb_main, filter, progress);
	147	if (!error) {
	148	error = SQ_evaluate(gb_main, weights, marked_only);
	149	if (mark_flag && !error) {
	150	SQ_mark_species(gb_main, mark_below, marked_only);
	151	}
	152	}
152	153	}
	154	if (error) progress.done();
153	155	delete globalData;
154	156	}
155	157	}
156	158	else {
157		aw_openstatus("Checking tree for irregularities...");
158		SQ_TREE_ERROR check = NONE;
159		if ((check = SQ_check_tree_structure(tree)) != NONE) {
	159	SQ_TREE_ERROR check = SQ_check_tree_structure(tree);
	160	if (check != NONE) {
160	161	switch (check) {
161		case ZOMBIE:
162		aw_message("Found one or more zombies in the tree.\nPlease remove them or use another tree before running the quality check tool.");
163		break;
164		case MISSING_NODE:
165		aw_message("Missing node(s) or unusable tree structure.\nPlease fix the tree before running the quality check tool.");
166		break;
167		default:
168		aw_message("An error occurred while traversing the tree.\nPlease fix the tree before running the quality check tool.");
169		break;
	162	case ZOMBIE:
	163	error = "Found one or more zombies in the tree.\n"
	164	"Please remove them or use another tree before running the quality check tool.";
	165	break;
	166	case MISSING_NODE:
	167	error = "Missing node(s) or unusable tree structure.\n"
	168	"Please fix the tree before running the quality check tool.";
	169	break;
	170	default:
	171	error = "An error occurred while traversing the tree.\n"
	172	"Please fix the tree before running the quality check tool.";
	173	break;
170	174	}
171		aw_closestatus();
172		return;
173		}
174		aw_closestatus();
175
176		if (reevaluate) {
177		aw_openstatus("Marking Sequences...");
178		SQ_count_nr_of_species(gb_main);
	175	}
	176	else if (reevaluate) {
179	177	SQ_mark_species(gb_main, mark_below, marked_only);
180		~~aw_closestatus();~~
181	178	}
182	179	else {
183		aw_openstatus("Calculating pass 1 of 2...");
184		SQ_reset_counters(tree);
	180	arb_progress progress(SQ_count_nodes(tree)*2);
185	181	SQ_GroupData *globalData = new SQ_GroupData_RNA;
186		SQ_calc_and_apply_group_data(tree, gb_main, globalData, filter);
187		~~aw_closestatus(~~);
188		SQ_~~reset_counters(tree~~);
189		~~aw_openstatus("Calculating pass 2 of 2...~~");
190		SQ_calc_and_apply_group_data2(tree, gb_main, globalData, filter);
	182
	183	progress.subtitle("pass1");
	184	SQ_calc_and_apply_group_data(tree, gb_main, globalData, filter, progress);
	185	progress.subtitle("pass2");
	186	SQ_calc_and_apply_group_data2(tree, gb_main, globalData, filter, progress);
191	187	SQ_evaluate(gb_main, weights, marked_only);
192		aw_closestatus();
193		SQ_reset_counters(tree);
194		if (mark_flag) {
195		aw_openstatus("Marking Sequences...");
196		SQ_count_nr_of_species(gb_main);
197		SQ_mark_species(gb_main, mark_below, marked_only);
198		aw_closestatus();
199		}
	188	if (mark_flag) SQ_mark_species(gb_main, mark_below, marked_only);
200	189	delete globalData;
201	190	}
202	191	}
203	192	}
204
205		if (error) {
206		aw_message(error);
207		}
	193
	194	if (error) aw_message(error);
208	195
209	196	SQ_clear_group_dictionary();

branches/refactor/SL/AW_NAME/AW_rename.cxx

r6871	r7097
15	15	#include <aw_root.hxx>
16	16	#include <aw_msg.hxx>
17		#include <a~~w_status.hxx~~>
	17	#include <arb_progress.h>
18	18
19	19	#include <names_client.h>
…	…
201	201
202	202	GB_ERROR connect(GBDATA *gb_main) {
	203	arb_progress::show_comment("Connecting to name server");
	204
203	205	GB_ERROR err = 0;
204	206	if (!link) {
…	…
303	305	// --------------------------------------------------------------------------------
304	306
305		GB_ERROR AWTC_generate_one_name(GBDATA gb_main, const char full_name, const char acc, const char addid, char*& new_name~~, bool openstatus, bool showstatus~~) {
	307	GB_ERROR AWTC_generate_one_name(GBDATA gb_main, const char full_name, const char acc, const char addid, char*& new_name) {
306	308	// create a unique short name for 'full_name'
307	309	// the result is written into 'new_name' (as malloc-copy)
…	…
312	314	if (!acc) acc = "";
313	315
314		if (openstatus) {
315		aw_openstatus(GBS_global_string("Short name for '%s'", full_name));
316		showstatus = true;
317		}
318
319		if (showstatus) {
320		aw_status("Connecting to name server");
321		aw_status((double)0);
322		}
	316	arb_progress progress("Generating short name");
323	317
324	318	GB_ERROR err = name_server.connect(gb_main);
325	319	if (err) return err;
326	320
327		~~if (showstatus) aw_status("Generating name");~~
328	321	static char *shrt = 0;
329	322	if (strlen(full_name)) {
…	…
356	349	}
357	350
358		~~if (openstatus) aw_closestatus();~~
359	351	name_server.disconnect();
360	352
…	…
362	354	}
363	355
364		GB_ERROR AWTC_recreate_name(GBDATA *gb_species, bool update_status) {
365		GBDATA *gb_main = GB_get_root(gb_species);
366
367		if (update_status) {
368		aw_status("Connecting to name server");
369		aw_status((double)0);
370		}
371
372		GB_ERROR error = name_server.connect(gb_main);
	356	GB_ERROR AWTC_recreate_name(GBDATA *gb_species) {
	357	GBDATA *gb_main = GB_get_root(gb_species);
	358	arb_progress progress("Recreating name");
	359	GB_ERROR error = name_server.connect(gb_main);
373	360	if (!error) {
374		~~if (update_status) aw_status("Generating name");~~
375
376	361	const char *add_field = AW_get_nameserver_addid(gb_main);
377	362	char *ali_name = GBT_get_default_alignment(gb_main);
…	…
429	414
430	415	if (error) GBT_abort_rename_session();
431		else {
432		if (update_status) GBT_commit_rename_session(aw_status, aw_status);
433		else GBT_commit_rename_session(0, 0);
434		}
	416	else error = GBT_commit_rename_session();
435	417	}
436	418
…	…
462	444	}
463	445
464		GB_ERROR AWTC_pars_names(GBDATA gb_main, ~~int update_status,~~ bool isWarningPtr)
	446	GB_ERROR AWTC_pars_names(GBDATA gb_main, bool isWarningPtr)
465	447	// rename species according to name_server
466	448	// 'isWarning' is set to true, in case of duplicates-warning
467	449	{
468		GB_ERROR err = name_server.connect(gb_main);
	450	arb_progress gen_progress("Generating new names", 2);
	451	GB_ERROR err = name_server.connect(gb_main);
469	452	bool isWarning = false;
	453
470	454
471	455	if (!err) {
…	…
473	457	if (!err) {
474	458	char *ali_name = GBT_get_default_alignment(gb_main);
475		GB_HASH *hash = GBS_create_hash(GBT_get_species_count(gb_main), GB_IGNORE_CASE);
	459	long spcount = GBT_get_species_count(gb_main);
	460	GB_HASH *hash = GBS_create_hash(spcount, GB_IGNORE_CASE);
476	461	GB_ERROR warning = 0;
477		~~long spcount = 0;~~
478		~~long count = 0;~~
479
480		~~if (update_status) {~~
481		~~aw_status("Renaming");~~
482		~~spcount = GBT_get_species_count(gb_main);~~
483		}
484
485		~~const char *add_field = AW_get_nameserver_addid(gb_main);~~
486
487		~~for (GBDATA *gb_species = GBT_first_species(gb_main);~~
488		~~gb_species && !err;~~
489		~~gb_species = GBT_next_species(gb_species))~~
490	462	{
491		if (update_status) aw_status(count++/(double)spcount);
492
493		GBDATA *gb_name = GB_entry(gb_species, "name");
494		GBDATA *gb_full_name = GB_entry(gb_species, "full_name");
495		GBDATA *gb_acc = GBT_gen_accession_number(gb_species, ali_name);
496		GBDATA *gb_addfield = add_field[0] ? GB_entry(gb_species, add_field) : 0;
497
498		char *name = gb_name ? GB_read_string (gb_name) : strdup("");
499		char *full_name = gb_full_name ? GB_read_string (gb_full_name) : strdup("");
500		char *acc = gb_acc ? GB_read_string (gb_acc) : strdup("");
501		char *addid = gb_addfield ? GB_read_as_string(gb_addfield) : strdup(""); // empty value will be set to default by nameserver
502
503		char *shrt = 0;
504
505		if (full_name[0] \|\| acc[0] \|\| addid[0]) {
506		if (aisc_nput(name_server.getLink(), AN_LOCAL, name_server.getLocs(),
507		LOCAL_FULL_NAME, full_name,
508		LOCAL_ACCESSION, acc,
509		LOCAL_ADDID, addid,
510		LOCAL_ADVICE, name,
511		NULL)) {
512		err = "Connection Problems with the NAME_SERVER";
513		}
514		if (aisc_get(name_server.getLink(), AN_LOCAL, name_server.getLocs(),
515		LOCAL_GET_SHORT, &shrt,
516		NULL)) {
517		err = "Connection Problems with the NAME_SERVER";
518		}
	463	arb_progress progress("Renaming species", spcount);
	464	const char *add_field = AW_get_nameserver_addid(gb_main);
	465
	466	for (GBDATA *gb_species = GBT_first_species(gb_main);
	467	gb_species && !err;
	468	gb_species = GBT_next_species(gb_species))
	469	{
	470	GBDATA *gb_name = GB_entry(gb_species, "name");
	471	GBDATA *gb_full_name = GB_entry(gb_species, "full_name");
	472	GBDATA *gb_acc = GBT_gen_accession_number(gb_species, ali_name);
	473	GBDATA *gb_addfield = add_field[0] ? GB_entry(gb_species, add_field) : 0;
	474
	475	char *name = gb_name ? GB_read_string (gb_name) : strdup("");
	476	char *full_name = gb_full_name ? GB_read_string (gb_full_name) : strdup("");
	477	char *acc = gb_acc ? GB_read_string (gb_acc) : strdup("");
	478	char *addid = gb_addfield ? GB_read_as_string(gb_addfield) : strdup(""); // empty value will be set to default by nameserver
	479
	480	char *shrt = 0;
	481
	482	if (full_name[0] \|\| acc[0] \|\| addid[0]) {
	483	if (aisc_nput(name_server.getLink(), AN_LOCAL, name_server.getLocs(),
	484	LOCAL_FULL_NAME, full_name,
	485	LOCAL_ACCESSION, acc,
	486	LOCAL_ADDID, addid,
	487	LOCAL_ADVICE, name,
	488	NULL)) {
	489	err = "Connection Problems with the NAME_SERVER";
	490	}
	491	if (aisc_get(name_server.getLink(), AN_LOCAL, name_server.getLocs(),
	492	LOCAL_GET_SHORT, &shrt,
	493	NULL)) {
	494	err = "Connection Problems with the NAME_SERVER";
	495	}
	496	}
	497	else {
	498	shrt = strdup(name);
	499	}
	500	if (!err) {
	501	char *newshrt = AWTC_create_numbered_suffix(hash, shrt, warning);
	502	if (newshrt) freeset(shrt, newshrt);
	503
	504	GBS_incr_hash(hash, shrt);
	505	err = GBT_rename_species(name, shrt, true);
	506	}
	507
	508	free(shrt);
	509	free(addid);
	510	free(acc);
	511	free(full_name);
	512	free(name);
	513
	514	progress.inc_and_check_user_abort(err);
519	515	}
520		else {
521		shrt = strdup(name);
522		}
523		if (!err) {
524		char *newshrt = AWTC_create_numbered_suffix(hash, shrt, warning);
525		if (newshrt) freeset(shrt, newshrt);
526
527		GBS_incr_hash(hash, shrt);
528		err = GBT_rename_species(name, shrt, true);
529		}
530
531		free(shrt);
532		free(addid);
533		free(acc);
534		free(full_name);
535		free(name);
536		}
537
538		if (err) {
539		GBT_abort_rename_session();
540		}
541		else {
542		err = GBT_commit_rename_session(aw_status, aw_status);
543		}
	516	}
	517
	518	if (err) GBT_abort_rename_session();
	519	else err = GBT_commit_rename_session();
544	520
545	521	GBS_free_hash(hash);
…	…
561	537
562	538	void awt_rename_cb(AW_window aww, GBDATA gb_main) {
563		aw_openstatus("Generating new names");
564		aw_status("Contacting name server");
565		GB_ERROR error = AWTC_pars_names(gb_main, 1);
566		aw_closestatus();
	539	GB_ERROR error = AWTC_pars_names(gb_main);
567	540	if (error) aw_message(error);
568
569	541	aww->get_root()->awar(AWAR_TREE_REFRESH)->touch();
570	542	}

branches/refactor/SL/AW_NAME/AW_rename.hxx

r6858	r7097
40	40
41	41	char AWTC_create_numbered_suffix(GB_HASH species_name_hash, const char *shortname, GB_ERROR& warning);
42		GB_ERROR AWTC_pars_names(GBDATA gb_main, ~~int update_status = 0,~~ bool isWarning = 0);
43		GB_ERROR AWTC_generate_one_name(GBDATA gb_main, const char full_name, const char acc, const char addid, char*& new_name~~, bool openstatus, bool showstatus~~);
44		GB_ERROR AWTC_recreate_name(GBDATA *gb_main~~, bool update_status~~);
	42	GB_ERROR AWTC_pars_names(GBDATA gb_main, bool isWarning = 0);
	43	GB_ERROR AWTC_generate_one_name(GBDATA gb_main, const char full_name, const char acc, const char addid, char*& new_name);
	44	GB_ERROR AWTC_recreate_name(GBDATA *gb_main);
45	45
46	46	// return name of additional field used for species identification

branches/refactor/SL/AW_NAME/Makefile

r7089	r7097
74	74	AW_rename.o: $(ARBHOME)/INCLUDE/arb_error.h
75	75	AW_rename.o: $(ARBHOME)/INCLUDE/arb_msg.h
	76	AW_rename.o: $(ARBHOME)/INCLUDE/arb_progress.h
76	77	AW_rename.o: $(ARBHOME)/INCLUDE/arb_string.h
77	78	AW_rename.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
86	87	AW_rename.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
87	88	AW_rename.o: $(ARBHOME)/INCLUDE/aw_root.hxx
88		~~AW_rename.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
89	89	AW_rename.o: $(ARBHOME)/INCLUDE/aw_window.hxx
90	90	AW_rename.o: $(ARBHOME)/INCLUDE/bytestring.h

branches/refactor/SL/DB_SCANNER/Makefile

r7089	r7097
43	43	db_scanner.o: $(ARBHOME)/INCLUDE/arb_error.h
44	44	db_scanner.o: $(ARBHOME)/INCLUDE/arb_msg.h
	45	db_scanner.o: $(ARBHOME)/INCLUDE/arb_progress.h
45	46	db_scanner.o: $(ARBHOME)/INCLUDE/arb_str.h
46	47	db_scanner.o: $(ARBHOME)/INCLUDE/arb_string.h
…	…
58	59	db_scanner.o: $(ARBHOME)/INCLUDE/aw_root.hxx
59	60	db_scanner.o: $(ARBHOME)/INCLUDE/aw_select.hxx
60		~~db_scanner.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
61	61	db_scanner.o: $(ARBHOME)/INCLUDE/aw_window.hxx
62	62	db_scanner.o: $(ARBHOME)/INCLUDE/awt.hxx

branches/refactor/SL/DB_SCANNER/db_scanner.cxx

r6861	r7097
18	18	#include <aw_select.hxx>
19	19	#include <aw_msg.hxx>
20		#include <a~~w_status.hxx~~>
	20	#include <arb_progress.h>
21	21	#include <aw_root.hxx>
22	22
…	…
164	164
165	165	if (selector->type == AWT_QUERY_ITEM_SPECIES) { // species
	166	arb_progress progress("Renaming species");
166	167	char *name = nulldup(GBT_read_name(cbs->gb_user));
167		~~aw_openstatus("Renaming species");~~
168	168
169	169	if (strlen(value)) {
…	…
173	173
174	174	if (error) GBT_abort_rename_session();
175		else ~~GBT_commit_rename_session(aw_status, aw_status~~);
	175	else error = GBT_commit_rename_session();
176	176	}
177	177	else {
178		error = AWTC_recreate_name(cbs->gb_user, true);
179		}
180
181		aw_closestatus();
	178	error = AWTC_recreate_name(cbs->gb_user);
	179	}
	180
182	181	free(name);
183	182	}

branches/refactor/SL/FAST_ALIGNER/Makefile

r7089	r7097
80	80	fast_aligner.o: $(ARBHOME)/INCLUDE/arb_defs.h
81	81	fast_aligner.o: $(ARBHOME)/INCLUDE/arb_error.h
82		~~fast_aligner.o: $(ARBHOME)/INCLUDE/arb_handlers.h~~
83	82	fast_aligner.o: $(ARBHOME)/INCLUDE/arb_msg.h
	83	fast_aligner.o: $(ARBHOME)/INCLUDE/arb_progress.h
84	84	fast_aligner.o: $(ARBHOME)/INCLUDE/arb_string.h
85	85	fast_aligner.o: $(ARBHOME)/INCLUDE/arb_unit_test.h
…	…
95	95	fast_aligner.o: $(ARBHOME)/INCLUDE/aw_msg.hxx
96	96	fast_aligner.o: $(ARBHOME)/INCLUDE/aw_root.hxx
97		~~fast_aligner.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
98	97	fast_aligner.o: $(ARBHOME)/INCLUDE/aw_window.hxx
99	98	fast_aligner.o: $(ARBHOME)/INCLUDE/awt_sel_boxes.hxx

branches/refactor/SL/FAST_ALIGNER/fast_aligner.cxx

r7091	r7097
22	22	#include <aw_window.hxx>
23	23	#include <aw_awars.hxx>
24		~~#include <aw_status.hxx>~~
25	24	#include <aw_root.hxx>
26	25
…	…
28	27
29	28	#include <arb_defs.h>
30		#include <arb_~~handler~~s.h>
	29	#include <arb_progress.h>
31	30
32	31	#include <cctype>
…	…
1168	1167
1169	1168	{
1170		~~const char *to_align_name = read_name(gb_toAlign);~~
1171		~~const char *align_to_name = read_name(gb_alignTo);~~
1172
1173		~~const char *stat_buf = GBS_global_string("Aligning #%i:%i %s (to %s)",~~
1174		~~currentSequenceNumber, overallSequenceNumber,~~
1175		~~to_align_name, align_to_name);~~
1176
1177	1169	static GBDATA *last_gb_toAlign = 0;
1178	1170	if (gb_toAlign!=last_gb_toAlign) {
…	…
1180	1172	currentSequenceNumber++;
1181	1173	}
1182
1183		~~GB_status(stat_buf);~~
1184	1174	}
1185	1175
…	…
1520	1510	FamilyFinder *familyFinder = relSearch.getFamilyFinder();
1521	1511
1522		~~GB_status("Searching relatives");~~
1523	1512	error = familyFinder->searchFamily(toAlignExpSequence, FF_FORWARD, relativesToTest+1);
1524	1513
…	…
2065	2054	case FA_MARKED: { // align all marked sequences
2066	2055	int count = GBT_count_marked_species(gb_main);
2067		~~int done = 0;~~
2068	2056	GBDATA *gb_species = GBT_first_marked_species_rel_species_data(gb_species_data);
	2057
	2058	arb_progress progress("Aligning marked species", count);
	2059	progress.auto_subtitles("Species");
2069	2060
2070	2061	currentSequenceNumber = 1;
…	…
2072	2063
2073	2064	while (gb_species && !error) {
2074		error = alignToReference(gb_species, ref);
2075		done++;
2076		GB_status(double(done)/double(count));
	2065	error = alignToReference(gb_species, ref);
	2066	progress.inc_and_check_user_abort(error);
2077	2067	gb_species = GBT_next_marked_species(gb_species);
2078	2068	}
…	…
2081	2071	case FA_SELECTED: { // align all selected species
2082	2072	int count;
2083		~~int done = 0;~~
2084	2073	GBDATA *gb_species = get_first_selected_species(&count);
2085	2074
	2075
2086	2076	currentSequenceNumber = 1;
2087	2077	overallSequenceNumber = count;
…	…
2090	2080	aw_message("There is no selected species!");
2091	2081	}
2092
2093		while (gb_species && !error) {
2094		error = alignToReference(gb_species, ref);
2095		done++;
2096		GB_status(double(done)/double(count));
2097		gb_species = get_next_selected_species();
2098		}
2099
	2082	else {
	2083	arb_progress progress("Aligning selected species", count);
	2084	progress.auto_subtitles("Species");
	2085
	2086	while (gb_species && !error) {
	2087	error = alignToReference(gb_species, ref);
	2088	progress.inc_and_check_user_abort(error);
	2089	gb_species = get_next_selected_species();
	2090	}
	2091	}
2100	2092	break;
2101	2093	}
…	…
2398	2390
2399	2391	{
2400		aw_openstatus("FastAligner");
	2392	arb_progress progress("FastAligner");
	2393	progress.allow_title_reuse();
	2394
2401	2395	Aligner aligner(gb_main,
2402	2396	alignWhat,
…	…
2405	2399	get_first_selected_species,
2406	2400	get_next_selected_species,
2407
	2401
2408	2402	reference,
2409	2403	get_consensus ? data_access->get_group_consensus : NULL,
…	…
2416	2410	(FA_errorAction)root->awar(FA_AWAR_ACTION_ON_ERROR)->read_int());
2417	2411	error = aligner.run();
2418		~~aw_closestatus();~~
2419	2412	}
2420	2413
…	…
2998	2991	}
2999	2992
3000		~~static int fake_status_gauge(double) { return 0; }~~
3001		~~static int fake_status_msg(const char*) { return 0; }~~
3002
3003	2993	void test_install_fakes(GBDATA *gb_main) {
3004	2994	selection_fake_gb_main = gb_main;
3005		~~GB_install_status(fake_status_gauge, fake_status_msg);~~
3006	2995	}
3007	2996
…	…
3042	3031
3043	3032	test_install_fakes(gb_main);
	3033	arb_suppress_progress silence;
3044	3034
3045	3035	// bool cont_on_err = true;
…	…
3175	3165
3176	3166	test_install_fakes(gb_main);
	3167	arb_suppress_progress silence;
3177	3168
3178	3169	bool cont_on_err = true;

branches/refactor/SL/SEQIO/Makefile

r7089	r7097
47	47	seq_export.o: $(ARBHOME)/INCLUDE/arb_error.h
48	48	seq_export.o: $(ARBHOME)/INCLUDE/arb_msg.h
	49	seq_export.o: $(ARBHOME)/INCLUDE/arb_progress.h
49	50	seq_export.o: $(ARBHOME)/INCLUDE/arb_string.h
50	51	seq_export.o: $(ARBHOME)/INCLUDE/arbdb.h

branches/refactor/SL/SEQIO/seq_export.cxx

r7059	r7097
14	14	#include <arbdbt.h>
15	15	#include <xml.hxx>
	16	#include <arb_progress.h>
16	17
17	18	#define sio_assert(cond) arb_assert(cond)
…	…
288	289	gap_column[gap_columns] = max_ali_len;
289	290
290		size_t spec_count = count_species();
291		size_t stat_update = spec_count/1000;
292
293		if (stat_update == 0) stat_update = 1;
294
295		size_t count = 0;
296		size_t next_stat = count+stat_update;
297
298		GB_status("Calculating vertical gaps");
299		GB_status(0.0);
	291	arb_progress progress("Calculating vertical gaps", count_species());
300	292
301	293	for (GBDATA *gb_species = first_species();
…	…
321	313	gap_columns -= skipped_columns;
322	314	}
323		++count;
324		if (count >= next_stat) {
325		if (GB_status(count/double(spec_count))) err = "User abort";
326		next_stat = count+stat_update;
327		}
328		}
329
330		GB_status(1.0);
	315	progress.inc_and_check_user_abort(err);
	316	}
331	317
332	318	if (!err) {
…	…
567	553	sio_assert(GB_is_privatefile(intermediate_export, false));
568	554
569		GB_~~status(GBS_global_string("Converting to %s", efo.suffix)~~);
	555	GB_informationf("Converting to %s", efo.suffix);
570	556
571	557	char srt = GBS_global_string_copy("$<=%s:$>=%s", intermediate_export, resulting_outname);
572	558	char *sys = GBS_string_eval(efo.system, srt, 0);
573	559
574		GB_~~status(GBS_global_string("exec '%s'", efo.system)~~);
	560	GB_informationf("exec '%s'", efo.system);
575	561	error = GB_system(sys);
576	562
577	563	GB_unlink_or_warn(intermediate_export, &error);
578		~~GB_status(1 - double(export_depth-1)/export_depth_max);~~
579	564
580	565	free(sys);
…	…
589	574	XML_Document *xml = 0;
590	575
591		~~GB_status("Saving data");~~
592	576	export_depth_max = export_depth;
593
594		~~if (efo.export_mode == EXPORT_XML) {~~
595		~~xml = new XML_Document("ARB_SEQ_EXPORT", "arb_seq_export.dtd", out);~~
596		{
597		~~xml->add_attribute("database", db_name);~~
598		}
599		~~xml->add_attribute("export_date", GB_date_string());~~
600		{
601		~~XML_Comment rem("There is a basic version of ARB_seq_export.dtd in $ARBHOME/lib/dtd\n"~~
602		~~"but you might need to expand it by yourself,\n"~~
603		~~"because the ARB-database may contain any kind of fields.");~~
604		}
605		}
606	577
607	578	int allCount = 0;
…	…
613	584	}
614	585
615		int count = 0;
	586	arb_progress progress(allCount);
	587	progress.auto_subtitles("Saving species");
	588
	589	if (efo.export_mode == EXPORT_XML) {
	590	xml = new XML_Document("ARB_SEQ_EXPORT", "arb_seq_export.dtd", out);
	591	{
	592	xml->add_attribute("database", db_name);
	593	}
	594	xml->add_attribute("export_date", GB_date_string());
	595	{
	596	XML_Comment rem("There is a basic version of ARB_seq_export.dtd in $ARBHOME/lib/dtd\n"
	597	"but you might need to expand it by yourself,\n"
	598	"because the ARB-database may contain any kind of fields.");
	599	}
	600	}
	601
616	602	for (GBDATA *gb_species = esd->first_species();
617	603	gb_species && !error;
618	604	gb_species = esd->next_species(gb_species))
619	605	{
620		~~GB_status(GBS_global_string("Saving species %i/%i", ++count, allCount));~~
621	606	switch (efo.export_mode) {
622	607	case EXPORT_USING_FORM:
…	…
632	617	break;
633	618	}
634		~~GB_status(double(count)/allCount~~);
	619	progress.inc_and_check_user_abort(error);
635	620	}
636	621
…	…
656	641	GB_ERROR error = 0;
657	642
658		~~GB_status(0.0);~~
659
660	643	if (multiple) {
661	644	char path, name, *suffix;
662	645	GB_split_full_path(outname, &path, NULL, &name, &suffix);
663
664	646	*resulting_outname = NULL;
665	647
666		size_t species_count = esd->count_species();
667		size_t count = 0;
	648	arb_progress progress("Exporting data", esd->count_species());
668	649
669	650	for (GBDATA *gb_species = esd->first_species();
…	…
675	656	else {
676	657	const char *fname = GB_append_suffix(GBS_global_string("%s_%s", name, species_name), suffix);
677		~~GB_status~~(fname);
	658	progress.subtitle(fname);
678	659
679	660	char *oname = strdup(GB_concat_path(path, fname));
…	…
683	664	error = export_format_single(dbname, formname, oname, &res_oname);
684	665	esd->set_single_mode(NULL);
685
686		~~GB_status(++count/double(species_count));~~
687	666
688	667	if (!*resulting_outname \|\| // not set yet
…	…
695	674	free(oname);
696	675	}
	676
	677	progress.inc_and_check_user_abort(error);
697	678	}
698	679
…	…
702	683	}
703	684	else {
	685	arb_progress progress("Exporting data");
704	686	error = export_format_single(dbname, formname, outname, resulting_outname);
705	687	}

branches/refactor/SOURCE_TOOLS/generate_all_links.sh

r7086	r7097
300	300	symlink_file ../WINDOW/aw_root.hxx INCLUDE/aw_root.hxx &&
301	301	symlink_file ../WINDOW/aw_select.hxx INCLUDE/aw_select.hxx &&
302		~~symlink_file ../WINDOW/aw_status.hxx INCLUDE/aw_status.hxx &&~~
303	302	symlink_file ../WINDOW/aw_window.hxx INCLUDE/aw_window.hxx &&
304	303	symlink_file ../WINDOW/aw_window_Xm_interface.hxx INCLUDE/aw_window_Xm_interface.hxx &&

branches/refactor/STAT/Makefile

r7089	r7097
46	46	ST_ml.o: $(ARBHOME)/INCLUDE/arb_error.h
47	47	ST_ml.o: $(ARBHOME)/INCLUDE/arb_msg.h
	48	ST_ml.o: $(ARBHOME)/INCLUDE/arb_progress.h
48	49	ST_ml.o: $(ARBHOME)/INCLUDE/arb_string.h
49	50	ST_ml.o: $(ARBHOME)/INCLUDE/ARB_Tree.hxx
…	…
55	56	ST_ml.o: $(ARBHOME)/INCLUDE/aw_base.hxx
56	57	ST_ml.o: $(ARBHOME)/INCLUDE/aw_color_groups.hxx
57		~~ST_ml.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
58	58	ST_ml.o: $(ARBHOME)/INCLUDE/ColumnStat.hxx
59	59	ST_ml.o: $(ARBHOME)/INCLUDE/downcast.h
…	…
76	76	ST_quality.o: $(ARBHOME)/INCLUDE/arb_error.h
77	77	ST_quality.o: $(ARBHOME)/INCLUDE/arb_msg.h
	78	ST_quality.o: $(ARBHOME)/INCLUDE/arb_progress.h
78	79	ST_quality.o: $(ARBHOME)/INCLUDE/arb_string.h
79	80	ST_quality.o: $(ARBHOME)/INCLUDE/arbdb.h
…	…
86	87	ST_quality.o: $(ARBHOME)/INCLUDE/aw_base.hxx
87	88	ST_quality.o: $(ARBHOME)/INCLUDE/aw_keysym.hxx
88		~~ST_quality.o: $(ARBHOME)/INCLUDE/aw_status.hxx~~
89	89	ST_quality.o: $(ARBHOME)/INCLUDE/aw_window.hxx
90	90	ST_quality.o: $(ARBHOME)/INCLUDE/BI_helix.hxx

branches/refactor/STAT/ST_ml.cxx

r6920	r7097
15	15	#include <AP_filter.hxx>
16	16	#include <AP_Tree.hxx>
17		#include <a~~w_status.hxx~~>
	17	#include <arb_progress.h>
18	18	#include <gui_aliview.hxx>
19	19
…	…
471	471	GB_ERROR ST_ML::init_st_ml(const char tree_name, const char alignment_namei,
472	472	const char *species_names, int marked_only,
473		ColumnStat colstat, ~~bool show_status,~~ const WeightedFilter weighted_filter)
	473	ColumnStat colstat, const WeightedFilter weighted_filter)
474	474	{
475	475	/! this is the real constructor, call only once /
…	…
482	482	else {
483	483	GB_transaction ta(gb_main);
484
485		if (show_status) aw_openstatus("Activating column statistic");
	484	arb_progress progress("Activating column statistic");
486	485
487	486	column_stat = colstat;
…	…
516	515	}
517	516
518		~~if (show_status) aw_status("load tree");~~
519	517	tree_root->loadFromDB(tree_name); // tree is not linked!
520	518
521		~~if (show_status) aw_status("link tree");~~
522	519	{
523	520	size_t species_in_tree = count_species_in_tree();
…	…
544	541	GBS_free_hash(keep_species_hash);
545	542	keep_species_hash = 0;
546		GBT_link_tree(tree_root->get_root_node()->get_gbt_tree(), gb_main, ~~show_status~~, 0, 0);
	543	GBT_link_tree(tree_root->get_root_node()->get_gbt_tree(), gb_main, true, 0, 0);
547	544	}
548	545	}
549	546	else { // keep marked/all
550		GBT_link_tree(tree_root->get_root_node()->get_gbt_tree(), gb_main, show_status, 0, 0);
551		aw_status("clean tree");
	547	GBT_link_tree(tree_root->get_root_node()->get_gbt_tree(), gb_main, true, 0, 0);
552	548	tree_root->remove_leafs((marked_only ? AWT_REMOVE_NOT_MARKED : 0)\|AWT_REMOVE_DELETED);
553	549
…	…
559	555	// calc frequencies
560	556
561		~~if (show_status) aw_status~~("calculating frequencies");
	557	progress.subtitle("calculating frequencies");
562	558
563	559	size_t filtered_length = get_filtered_length();
…	…
597	593	error = ta.close(error);
598	594	}
599
600		~~if (show_status) aw_closestatus();~~
601	595	}
602	596	return error;

branches/refactor/STAT/ST_quality.cxx

r6858	r7097
17	17	#include <AP_filter.hxx>
18	18	#include <aw_awars.hxx>
19		#include <a~~w_status.hxx~~>
	19	#include <arb_progress.h>
20	20	#include <arbdbt.h>
21	21
…	…
244	244	#endif // DEVEL_RALF
245	245	ST_ML st_ml(gb_main);
246		GB_ERROR error = st_ml.init_st_ml(tree_name, alignment_name, 0, marked_only, colstat, true, weighted_filter);
	246	GB_ERROR error = st_ml.init_st_ml(tree_name, alignment_name, 0, marked_only, colstat, weighted_filter);
	247	arb_progress glob_progress("Sequence Quality Check");
247	248
248	249	if (!error) {
249		GB_HASH *species_to_info_hash = GBS_create_dynaval_hash(GBT_get_species_count(gb_main), GB_IGNORE_CASE, destroy_ColumnQualityInfo);
250		GB_CSTR *snames = GBT_get_names_of_species_in_tree(st_ml.get_gbt_tree());
251
252		aw_openstatus("Sequence Quality Check");
253		aw_status(0.0);
254
255		int seq_len = st_ml.get_filtered_length();
256		size_t parts = (seq_len-1)/ST_MAX_SEQ_PART+1;
257		size_t species_count = 0;
258		while (snames[species_count]) ++species_count;
259
260		aw_status_counter progress(parts*species_count);
261
262		for (int pos = 0; pos < seq_len && !progress.aborted_by_user(); pos += ST_MAX_SEQ_PART) {
263		int end = pos + ST_MAX_SEQ_PART - 1;
264		if (end > seq_len) end = seq_len;
265
266		for (GB_CSTR pspecies_name = snames; pspecies_name; pspecies_name++) {
267		st_ml_add_sequence_part_to_stat(&st_ml, colstat, *pspecies_name, seq_len, bucket_size, species_to_info_hash, pos, end);
268		progress.inc();
269		}
270		}
271
272		if (!error && !progress.aborted_by_user()) {
273		aw_status("Generating Result String");
274		progress.restart(species_count);
	250	GB_HASH *species2info = GBS_create_dynaval_hash(GBT_get_species_count(gb_main), GB_IGNORE_CASE, destroy_ColumnQualityInfo);
	251	size_t species_count;
	252	GB_CSTR *snames = GBT_get_names_of_species_in_tree(st_ml.get_gbt_tree(), &species_count);
	253	int seq_len = st_ml.get_filtered_length();
	254	size_t parts = (seq_len-1)/ST_MAX_SEQ_PART+1;
	255
	256	{
	257	arb_progress add_progress("Calculating stat", parts*species_count);
	258
	259	for (int pos = 0; pos < seq_len && !error; pos += ST_MAX_SEQ_PART) {
	260	int end = pos + ST_MAX_SEQ_PART - 1;
	261	if (end > seq_len) end = seq_len;
	262
	263	for (GB_CSTR pspecies_name = snames; pspecies_name && !error; pspecies_name++) {
	264	st_ml_add_sequence_part_to_stat(&st_ml, colstat, *pspecies_name, seq_len, bucket_size, species2info, pos, end);
	265	add_progress.inc_and_check_user_abort(error);
	266	}
	267	}
	268	}
	269
	270	if (!error) {
	271	arb_progress res_progress("Calculating result", species_count);
275	272	const AP_filter *filter = st_ml.get_filter();
276		for (GB_CSTR pspecies_name = snames; pspecies_name && !error && !progress.aborted_by_user(); pspecies_name++) {
277		error = st_ml_add_quality_string_to_species(gb_main, filter, alignment_name, *pspecies_name, bucket_size, species_to_info_hash, report, dest_field);
278		progress.inc();
279		}
280		}
281
282		if (!error && progress.aborted_by_user()) error = "Aborted by user";
283
284		aw_closestatus();
	273
	274	for (GB_CSTR pspecies_name = snames; pspecies_name && !error; pspecies_name++) {
	275	error = st_ml_add_quality_string_to_species(gb_main, filter, alignment_name, *pspecies_name, bucket_size, species2info, report, dest_field);
	276	res_progress.inc_and_check_user_abort(error);
	277	}
	278	}
	279
285	280	free(snames);
286		GBS_free_hash(species~~_to_info_hash~~);
	281	GBS_free_hash(species2info);
287	282	}
288	283

branches/refactor/STAT/ST_window.cxx

r6861	r7097
48	48	GB_ERROR error = GB_push_transaction(st_ml->get_gb_main());
49	49	if (!error) {
50		error = st_ml->init_st_ml(tree_name, alignment_name, NULL, marked_only, st_ml->get_column_statistic(), ~~true,~~ NULL);
	50	error = st_ml->init_st_ml(tree_name, alignment_name, NULL, marked_only, st_ml->get_column_statistic(), NULL);
51	51	if (!error) st_ml->do_refresh();
52	52	}

branches/refactor/STAT/st_ml.hxx

r7084	r7097
174	174	int marked_only,
175	175	ColumnStat *colstat,
176		~~bool show_status,~~
177	176	const WeightedFilter *weighted_filter) __ATTR__USERESULT;
178	177

branches/refactor/TOOLS/Makefile

r7089	r7097
87	87	arb_2_ascii.o: $(ARBHOME)/INCLUDE/arb_core.h
88	88	arb_2_ascii.o: $(ARBHOME)/INCLUDE/arb_error.h
89		~~arb_2_ascii.o: $(ARBHOME)/INCLUDE/arb_handlers.h~~
90	89	arb_2_ascii.o: $(ARBHOME)/INCLUDE/arb_msg.h
91	90	arb_2_ascii.o: $(ARBHOME)/INCLUDE/arb_string.h

branches/refactor/TOOLS/arb_2_ascii.cxx

r7088	r7097
10	10
11	11	#include <arbdb.h>
12		~~#include <arb_handlers.h>~~
13
14		~~static void to_stderr(const char *msg) {~~
15		~~fprintf(stderr, "arb_2_ascii: %s\n", msg);~~
16		}
17	12
18	13	int main(int argc, char **argv) {
…	…
50	45
51	46	if (!out \|\| strcmp(out, "-") == 0) {
52		saveflags = "aS";
53		GB_install_information(to_stderr);
54		GB_install_warning(to_stderr);
	47	saveflags = "aS";
55	48	}
56	49	}

branches/refactor/UNIT_TESTER/Makefile.setup

r7073	r7097
39	39	#RESTRICT_LIB=NTREE
40	40	#RESTRICT_LIB=SEQIO
	41	#RESTRICT_LIB=CORE
41	42
42	43	#RESTRICT_LIB=SEQIO:CONVERTALN

branches/refactor/WINDOW/AW_status.cxx

r6952	r7097
56	56	#endif // DEBUG
57	57
58		enum {
	58	enum StatusCommand {
59	59	// messages send from status-process to main-process :
60	60	AW_STATUS_OK = 0,
…	…
64	64	AW_STATUS_CMD_OPEN,
65	65	AW_STATUS_CMD_CLOSE,
	66	AW_STATUS_CMD_NEW_TITLE,
66	67	AW_STATUS_CMD_TEXT,
67	68	AW_STATUS_CMD_GAUGE,
…	…
74	75	int fd_to[2];
75	76	int fd_from[2];
76		~~int~~ mode;
	77	bool mode;
77	78	int hide;
78	79	int hide_delay; // in seconds
…	…
281	282	if (cmd == AW_STATUS_CMD_TEXT \|\|
282	283	cmd == AW_STATUS_CMD_OPEN \|\|
	284	cmd == AW_STATUS_CMD_NEW_TITLE \|\|
283	285	cmd == AW_STATUS_CMD_MESSAGE) {
284	286	char *p = buffer;
…	…
635	637	break;
636	638
	639	case AW_STATUS_CMD_NEW_TITLE:
	640	#if defined(TRACE_STATUS)
	641	fprintf(stderr, "received AW_STATUS_CMD_NEW_TITLE\n"); fflush(stdout);
	642	#endif // TRACE_STATUS
	643	#if defined(ARB_LOGGING)
	644	aw_status_append_to_log(str);
	645	#endif // ARB_LOGGING
	646	awr->awar(AWAR_STATUS_TITLE)->write_string(str);
	647	break;
	648
637	649	case AW_STATUS_CMD_GAUGE: {
638	650	#if defined(TRACE_STATUS)
…	…
752	764
753	765	void aw_initstatus() {
	766	// fork status window.
	767	// Note: call this function once as early as possible
	768
754	769	aw_assert(aw_stg.pid == 0); // do not init status twice!
755	770	aw_assert(!AW_root::SINGLETON); // aw_initstatus has to be called before constructing AW_root
…	…
852	867	}
853	868
854
855
	869	static void status_write_cmd_and_text(StatusCommand cmd, const char *text, int textlen) {
	870	aw_status_write(aw_stg.fd_to[1], cmd);
	871	safe_write(aw_stg.fd_to[1], text, textlen+1);
	872	}
	873	static void status_write_cmd_and_text(StatusCommand cmd, const char *text) {
	874	if (!text) text = "";
	875	status_write_cmd_and_text(cmd, text, strlen(text));
	876	}
856	877
857	878	void aw_openstatus(const char *title)
…	…
862	883	aw_status_write(aw_stg.fd_to[1], AW_STATUS_CMD_INIT);
863	884	}
864		aw_status_write(aw_stg.fd_to[1], AW_STATUS_CMD_OPEN);
865		safe_write(aw_stg.fd_to[1], title, strlen(title)+1);
866		}
867
868		void aw_closestatus()
869		{
	885	status_write_cmd_and_text(AW_STATUS_CMD_OPEN, title);
	886	}
	887
	888	void aw_closestatus() {
870	889	aw_status_write(aw_stg.fd_to[1], AW_STATUS_CMD_CLOSE);
871	890	}
872	891
873		int aw_status(const char *text) {
874		if (!text) text = "";
875
876		aw_status_write(aw_stg.fd_to[1], AW_STATUS_CMD_TEXT);
877		int len = strlen(text)+1;
878
879		safe_write(aw_stg.fd_to[1], text, len);
880
881		return aw_status();
882		}
883
884		int aw_status(double gauge) {
	892	bool AW_status(const char *text) {
	893	status_write_cmd_and_text(AW_STATUS_CMD_TEXT, text);
	894	return AW_status();
	895	}
	896
	897	bool aw_status_title(const char *new_title) {
	898	status_write_cmd_and_text(AW_STATUS_CMD_NEW_TITLE, new_title);
	899	return AW_status();
	900	}
	901
	902	bool AW_status(double gauge) {
885	903	static int last_val = -1;
886	904	int val = (int)(gauge*AW_GAUGE_GRANULARITY);
…	…
894	912	last_val = val;
895	913	}
896		return aw_status();
897		}
898
899		~~int aw~~_status() {
	914	return AW_status();
	915	}
	916
	917	bool AW_status() {
900	918	char *str = 0;
901	919	int cmd;
…	…
932	950	aw_status_write(aw_stg.fd_to[1], AW_STATUS_CMD_INIT);
933	951	}
934		aw_status_write(aw_stg.fd_to[1], AW_STATUS_CMD_MESSAGE);
935		int len = strlen(msg)+1;
936		safe_write(aw_stg.fd_to[1], msg, len);
	952	status_write_cmd_and_text(AW_STATUS_CMD_MESSAGE, msg);
937	953	}
938	954	}

branches/refactor/WINDOW/AW_window.cxx

r7088	r7097
1379	1379	}
1380	1380
1381		static void aw_message_dump_stderr(const char *msg) {
	1381	static void dump_stdout(const char *msg) {
	1382	fprintf(stdout, "ARB: %s\n", msg);
	1383	}
	1384	static void aw_message_and_dump_stderr(const char *msg) {
	1385	fflush(stdout);
1382	1386	fprintf(stderr, "ARB: %s\n", msg); // print to console as well
	1387	fflush(stderr);
1383	1388	aw_message(msg);
1384	1389	}
	1390
	1391	static arb_status_implementation AW_status_impl = {
	1392	AST_RANDOM,
	1393	aw_openstatus,
	1394	aw_closestatus,
	1395	aw_status_title, // set_title
	1396	AW_status, // set_subtitle
	1397	AW_status, // set_gauge
	1398	AW_status, // user_abort
	1399	};
	1400
	1401	static arb_handlers aw_handlers = {
	1402	aw_message_and_dump_stderr,
	1403	aw_message,
	1404	dump_stdout,
	1405	AW_status_impl,
	1406	};
1385	1407
1386	1408	void AW_root::init_root(const char *programname, bool no_exit) {
…	…
1400	1422	fallback_resources[i] = 0;
1401	1423
1402		GB_install_error_handler(aw_message_dump_stderr);
1403		GB_install_warning(aw_message);
1404		GB_install_information(NULL); // NULL means -> write to stdout only
1405		GB_install_status(aw_status, aw_status);
1406
	1424	ARB_install_handlers(aw_handlers);
	1425
1407	1426	// @@@ FIXME: the next line hangs if program runs inside debugger
1408	1427	p_r->toplevel_widget = XtOpenApplication(&(p_r->context), programname,

branches/refactor/WINDOW/aw_root.hxx

r7084	r7097
74	74	KEY_RELEASED = 3
75	75	} AW_ProcessEventType;
	76
	77	void aw_initstatus();
76	78
77	79	class AW_root {

branches/refactor/WINDOW/aw_status.hxx

r6858	r7097
2	2	// //
3	3	// File : aw_status.hxx //
4		// Purpose : Provide aw_status and related functions //
	4	// Purpose : Provide AW_status and related functions //
5	5	// //
6	6	// Coded by Ralf Westram (coder@reallysoft.de) in September 2010 //
…	…
13	13	#define AW_STATUS_HXX
14	14
15		#ifndef ARB_ASSERT_H
16		#include <arb_assert.h>
17		#endif
18		#ifndef ARBTOOLS_H
19		#include <arbtools.h>
20		#endif
	15	bool AW_status(const char *text); // return 1 if exit button is pressed + set statustext
	16	bool AW_status(double gauge); // return 1 if exit button is pressed + set progress bar
	17	bool AW_status(); // return 1 if exit button is pressed
21	18
22
23		#ifndef aw_assert
24		#define aw_assert(bed) arb_assert(bed)
25		#endif
26
27		int aw_status(const char *text); // return 1 if exit button is pressed + set statustext
28		int aw_status(double gauge); // return 1 if exit button is pressed + set progress bar
29		int aw_status(); // return 1 if exit button is pressed
	19	bool aw_status_title(const char *text); // return 1 if exit button is pressed + set status title
30	20
31	21	// ---------------------
32	22	// progress bar
33	23
34		~~void aw_initstatus(); // call this function only once as early as possible~~
35	24	void aw_openstatus(const char *title); // show status
36	25	void aw_closestatus(); // hide status
37
38		~~class aw_status_counter : Noncopyable { // progress object~~
39		~~int counter;~~
40		~~int maxcount;~~
41		~~int autoUpdateEvery;~~
42		~~int nextAutoUpdate;~~
43		~~bool aborted;~~
44
45		~~void track_abort(int aw_status_result) { if (aw_status_result) aborted = true; }~~
46		~~void init(int overallCount) {~~
47		~~counter = 0;~~
48		~~maxcount = overallCount;~~
49		~~autoUpdateEvery = overallCount <= 250 ? 1 : int(overallCount/250.0+0.5);~~
50		~~nextAutoUpdate = counter+autoUpdateEvery;~~
51		}
52
53		~~public:~~
54		~~aw_status_counter(int overallCount) : aborted(false) {~~
55		~~init(overallCount);~~
56		}
57
58		~~void inc(int incr = 1) {~~
59		~~counter += incr;~~
60		~~aw_assert(counter <= maxcount);~~
61		~~if (counter >= nextAutoUpdate) {~~
62		~~update();~~
63		~~nextAutoUpdate += autoUpdateEvery;~~
64		}
65		}
66		~~void update() { track_abort(aw_status(counter/double(maxcount))); }~~
67
68		~~bool aborted_by_user() const { return aborted; }~~
69		~~void restart(int overallCount) { init(overallCount); update(); }~~
70		};
71
72	26
73	27	#else

Context Navigation

Legend:

Download in other formats: