Context Navigation

source: tags/cvs_2_svn/GENOM/GEN_interface.cxx

Visit:

Last change on this file was 5340, checked in by westram, 16 years ago
use GB_CASE parameter changed GBS_string_[s]cmp
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.4 KB

Line
1	#include <cstdlib>
2	#include <cstring>
3	#include <awt.hxx>
4	#include <awt_canvas.hxx>
5	#include <awt_changekey.hxx>
6	#include <awt_sel_boxes.hxx>
7	#include <aw_awars.hxx>
8	#include <db_scanner.hxx>
9
10	#include <arbdbt.h>
11	#include <probe_design.hxx>
12
13	#include <ntree.hxx>
14	#include <../NTREE/ad_spec.hxx>
15	#include <../NTREE/nt_internal.h>
16
17	#ifndef GEN_LOCAL_HXX
18	#include "GEN_local.hxx"
19	#endif
20	#ifndef GEN_NDS_HXX
21	#include "GEN_nds.hxx"
22	#endif
23
24	using namespace std;
25
26	// --------------------------------------------------------------------------------
27
28	#define AD_F_ALL (AW_active)(-1)
29
30	// --------------------------------------------------------------------------------
31
32	void GEN_select_gene(GBDATA* /gb_main/, AW_root aw_root, const char item_name) {
33	char *organism = GB_strdup(item_name);
34	char *gene = strchr(organism, '/');
35
36	if (gene) {
37	*gene++ = 0;
38	aw_root->awar(AWAR_ORGANISM_NAME)->write_string(organism);
39	aw_root->awar(AWAR_GENE_NAME)->write_string(gene);
40	}
41	else {
42	aw_message(GBS_global_string("Illegal item_name '%s' in GEN_select_gene()", item_name));
43	}
44	free(organism);
45	}
46
47	static char gen_get_gene_id(GBDATA /gb_main/, GBDATA *gb_gene) {
48	GBDATA *gb_name = GB_entry(gb_gene, "name");
49	if (!gb_name) return 0; // gene w/o name -> skip
50
51	GBDATA *gb_species = GB_get_father(GB_get_father(gb_gene));
52	GBDATA *gb_sp_name = GB_entry(gb_species, "name");
53	if (!gb_sp_name) return 0; // species w/o name -> skip
54
55	char *species_name = GB_read_as_string(gb_sp_name);
56	char *gene_name = GB_read_as_string(gb_name);
57
58	char result = (char)malloc(strlen(species_name)+1+strlen(gene_name)+1);
59	strcpy(result, species_name);
60	strcat(result, "/");
61	strcat(result, gene_name);
62
63	free(gene_name);
64	free(species_name);
65
66	return result;
67	}
68
69	static GBDATA gen_find_gene_by_id(GBDATA gb_main, const char *id) {
70	char *organism = GB_strdup(id);
71	char *gene = strchr(organism, '/');
72	GBDATA *result = 0;
73
74	if (gene) {
75	*gene++ = 0;
76	GBDATA *gb_organism = GEN_find_organism(gb_main, organism);
77	if (gb_organism) {
78	result = GEN_find_gene(gb_organism, gene);
79	}
80	}
81
82	free(organism);
83	return result;
84	}
85
86
87	static char *old_species_marks = 0; // configuration storing marked species
88
89	// --------------------------------------------------------------------------------------------------------------
90	// extern "C" GB_ERROR GEN_mark_organism_or_corresponding_organism(GBDATA gb_species, int client_data)
91	// --------------------------------------------------------------------------------------------------------------
92	extern "C" GB_ERROR GEN_mark_organism_or_corresponding_organism(GBDATA gb_species, int client_data) {
93	AWUSE(client_data);
94	GB_ERROR error = 0;
95
96	if (GEN_is_pseudo_gene_species(gb_species)) {
97	GBDATA *gb_organism = GEN_find_origin_organism(gb_species, 0);
98	if (gb_organism) {
99	GB_write_flag(gb_organism, 1);
100	}
101	else {
102	error = GEN_organism_not_found(gb_species);
103	}
104	}
105	else if (GEN_is_organism(gb_species)) {
106	GB_write_flag(gb_species, 1);
107	}
108
109	return error;
110	}
111
112	// ---------------------------------------------------------------------------------------------------------
113	// static GBDATA GEN_get_first_gene_data(GBDATA gb_main, AW_root *aw_root, AWT_QUERY_RANGE range)
114	// ---------------------------------------------------------------------------------------------------------
115	static GBDATA GEN_get_first_gene_data(GBDATA gb_main, AW_root *aw_root, AWT_QUERY_RANGE range) {
116	GBDATA *gb_organism = 0;
117	GB_ERROR error = 0;
118
119	switch (range) {
120	case AWT_QUERY_CURRENT_SPECIES: {
121	char *species_name = aw_root->awar(AWAR_ORGANISM_NAME)->read_string();
122	gb_organism = GEN_find_organism(gb_main, species_name);
123	free(species_name);
124	break;
125	}
126	case AWT_QUERY_MARKED_SPECIES: {
127	gb_organism = GEN_first_marked_organism(gb_main);
128	GBDATA *gb_pseudo = GEN_first_marked_pseudo_species(gb_main);
129
130	gb_assert(old_species_marks == 0); // this occurs in case of recursive calls (not possible)
131
132	if (gb_pseudo) { // there are marked pseudo-species..
133	old_species_marks = GBT_store_marked_species(gb_main, 1); // store and unmark marked species
134
135	error = GBT_with_stored_species(gb_main, old_species_marks, GEN_mark_organism_or_corresponding_organism, 0); // mark organisms related with stored
136	if (!error) gb_organism = GEN_first_marked_organism(gb_main);
137	}
138
139	break;
140	}
141	case AWT_QUERY_ALL_SPECIES: {
142	gb_organism = GEN_first_organism(gb_main);
143	break;
144	}
145	default: {
146	gen_assert(0);
147	break;
148	}
149	}
150
151	if (error) GB_export_error(error);
152	return gb_organism ? GEN_expect_gene_data(gb_organism) : 0;
153	}
154	// -------------------------------------------------------------------------------------------
155	// static GBDATA GEN_get_next_gene_data(GBDATA gb_gene_data, AWT_QUERY_RANGE range)
156	// -------------------------------------------------------------------------------------------
157	static GBDATA GEN_get_next_gene_data(GBDATA gb_gene_data, AWT_QUERY_RANGE range) {
158	GBDATA *gb_organism = 0;
159	switch (range) {
160	case AWT_QUERY_CURRENT_SPECIES: {
161	break;
162	}
163	case AWT_QUERY_MARKED_SPECIES: {
164	GBDATA *gb_last_organism = GB_get_father(gb_gene_data);
165	gb_organism = GEN_next_marked_organism(gb_last_organism);
166
167	if (!gb_organism && old_species_marks) { // got all -> clean up
168	GBT_restore_marked_species(GLOBAL_gb_main, old_species_marks);
169	free(old_species_marks);
170	old_species_marks = 0;
171	}
172
173	break;
174	}
175	case AWT_QUERY_ALL_SPECIES: {
176	GBDATA *gb_last_organism = GB_get_father(gb_gene_data);
177	gb_organism = GEN_next_organism(gb_last_organism);
178	break;
179	}
180	default: {
181	gen_assert(0);
182	break;
183	}
184	}
185
186	return gb_organism ? GEN_expect_gene_data(gb_organism) : 0;
187	}
188
189	// ----------------------------------------------------
190	// struct ad_item_selector GEN_item_selector =
191	// ----------------------------------------------------
192	struct ad_item_selector GEN_item_selector = {
193	AWT_QUERY_ITEM_GENES,
194	GEN_select_gene,
195	gen_get_gene_id,
196	gen_find_gene_by_id,
197	(AW_CB)awt_gene_field_selection_list_update_cb,
198	25,
199	CHANGE_KEY_PATH_GENES,
200	"gene",
201	"genes",
202	GEN_get_first_gene_data,
203	GEN_get_next_gene_data,
204	GEN_first_gene_rel_gene_data,
205	GEN_next_gene,
206	GEN_get_current_gene,
207	&AWT_organism_selector
208	};
209
210	// -------------------------------------------------------
211	// void GEN_species_name_changed_cb(AW_root *awr)
212	// -------------------------------------------------------
213	void GEN_species_name_changed_cb(AW_root *awr) {
214	char *species_name = awr->awar(AWAR_SPECIES_NAME)->read_string();
215	GBDATA *gb_species = GBT_find_species(GLOBAL_gb_main, species_name);
216
217	if (gb_species) {
218	if (GEN_is_pseudo_gene_species(gb_species)) {
219	awr->awar(AWAR_ORGANISM_NAME)->write_string(GEN_origin_organism(gb_species));
220	awr->awar(AWAR_GENE_NAME)->write_string(GEN_origin_gene(gb_species));
221	}
222	else {
223	awr->awar(AWAR_ORGANISM_NAME)->write_string(species_name);
224	}
225	}
226	free(species_name);
227	}
228
229	// ----------------------------------------------------------------------------------------------------------------------------
230	// static void GB_auto_select_pseudo_species_cb(AW_root awr, GBDATA gb_main, const char organism, const char gene)
231	// ----------------------------------------------------------------------------------------------------------------------------
232	static void auto_select_pseudo_species(AW_root awr, GBDATA gb_main, const char organism, const char gene) {
233	GB_transaction dummy(gb_main);
234	GBDATA *gb_pseudo = GEN_find_pseudo_species(gb_main, organism, gene, 0); // search for pseudo species..
235
236	if (gb_pseudo) {
237	GBDATA *gb_name = GB_entry(gb_pseudo, "name");
238	char *pseudo_name = GB_read_string(gb_name);
239
240	awr->awar(AWAR_SPECIES_NAME)->write_string(pseudo_name); // ..and select it if found
241	free(pseudo_name);
242	}
243	else {
244	awr->awar(AWAR_SPECIES_NAME)->write_string(organism); // otherwise select organism
245	}
246	}
247
248	// --------------------------------------------------------------------
249	// void GEN_update_GENE_CONTENT(GBDATA gb_main, AW_root awr)
250	// --------------------------------------------------------------------
251	void GEN_update_GENE_CONTENT(GBDATA gb_main, AW_root awr) {
252	GB_transaction dummy(gb_main);
253	GBDATA *gb_gene = GEN_get_current_gene(gb_main, awr);
254	bool clear = true;
255
256	if (gb_gene) {
257	char *gene_content = GBT_read_gene_sequence(gb_gene, GB_FALSE); // ignore complement here (to highlight gene in ARB_EDIT4)
258
259	awr->awar(AWAR_GENE_CONTENT)->write_string(gene_content);
260	clear = false;
261	free(gene_content);
262	}
263	else {
264	char *gene_name = awr->awar(AWAR_GENE_NAME)->read_string();
265	const int prefix_len = 10;
266
267	if (strncmp(gene_name, "intergene_", prefix_len) == 0) { // special case (non-gene result from gene pt server)
268	char *start_pos_ptr = gene_name+prefix_len;
269	char *end_pos_ptr = strchr(start_pos_ptr, '_');
270
271	gen_assert(end_pos_ptr);
272	if (end_pos_ptr) {
273	*end_pos_ptr++ = 0;
274	long start_pos = atol(start_pos_ptr);
275	long end_pos = atol(end_pos_ptr);
276
277	gen_assert(end_pos >= start_pos);
278
279	GBDATA *gb_organism = GEN_get_current_organism(gb_main, awr);
280	if (gb_organism) {
281	GBDATA *gb_seq = GBT_read_sequence(gb_organism, GENOM_ALIGNMENT);
282	const char *seq_data = GB_read_char_pntr(gb_seq);
283
284	long len = end_pos-start_pos+1;
285	char buffer = (char)malloc(len+1);
286	memcpy(buffer, seq_data+start_pos, len);
287	buffer[len] = 0;
288
289	awr->awar(AWAR_GENE_CONTENT)->write_string(buffer);
290	clear = false;
291
292	free(buffer);
293	}
294	}
295	}
296	free(gene_name);
297	}
298
299	if (clear) {
300	awr->awar(AWAR_GENE_CONTENT)->write_string(""); // if we did not detect any gene sequence -> clear
301	}
302	}
303
304	// --------------------------------------------------
305	// void GEN_update_combined_cb(AW_root *awr)
306	// --------------------------------------------------
307	void GEN_update_combined_cb(AW_root *awr) {
308	char *organism = awr->awar(AWAR_ORGANISM_NAME)->read_string();
309	char *gene = awr->awar(AWAR_GENE_NAME)->read_string();
310	char *old_combined = awr->awar(AWAR_COMBINED_GENE_NAME)->read_string();
311	const char *combined = GBS_global_string("%s/%s", organism, gene);
312
313	if (strcmp(combined, old_combined) != 0) {
314	awr->awar(AWAR_COMBINED_GENE_NAME)->write_string(combined);
315	auto_select_pseudo_species(awr, GLOBAL_gb_main, organism, gene);
316	GEN_update_GENE_CONTENT(GLOBAL_gb_main, awr);
317	}
318
319	free(old_combined);
320	free(gene);
321	free(organism);
322	}
323
324	// -------------------------------------------------------------------
325	// void GEN_create_awars(AW_root *aw_root, AW_default aw_def)
326	// -------------------------------------------------------------------
327	void GEN_create_awars(AW_root *aw_root, AW_default aw_def) {
328	aw_root->awar_string(AWAR_COMBINED_GENE_NAME,"",GLOBAL_gb_main);
329	aw_root->awar_string(AWAR_GENE_CONTENT,"",GLOBAL_gb_main);
330
331	aw_root->awar_string(AWAR_GENE_NAME, "" , GLOBAL_gb_main)->add_callback((AW_RCB0)GEN_update_combined_cb);
332	aw_root->awar_string(AWAR_ORGANISM_NAME, "" , GLOBAL_gb_main)->add_callback((AW_RCB0)GEN_update_combined_cb);
333
334	aw_root->awar_string(AWAR_SPECIES_NAME,"",GLOBAL_gb_main)->add_callback((AW_RCB0)GEN_species_name_changed_cb);
335
336	aw_root->awar_string(AWAR_GENE_DEST, "" , aw_def);
337	aw_root->awar_string(AWAR_GENE_POS1, "" , aw_def);
338	aw_root->awar_string(AWAR_GENE_POS2, "" , aw_def);
339	aw_root->awar_int(AWAR_GENE_COMPLEMENT, 0, aw_def);
340
341	aw_root->awar_string(AWAR_GENE_EXTRACT_ALI, "ali_gene_" , aw_def);
342	}
343
344
345	// ---------------------------------------------------------------------------
346	// GBDATA GEN_get_current_organism(GBDATA gb_main, AW_root *aw_root)
347	// ---------------------------------------------------------------------------
348	GBDATA GEN_get_current_organism(GBDATA gb_main, AW_root *aw_root) {
349	char *species_name = aw_root->awar(AWAR_ORGANISM_NAME)->read_string();
350	GBDATA *gb_species = GBT_find_species(gb_main,species_name);
351	free(species_name);
352	return gb_species;
353	}
354
355	// -----------------------------------------------------------------------------
356	// GBDATA* GEN_get_current_gene_data(GBDATA gb_main, AW_root aw_root)
357	// -----------------------------------------------------------------------------
358	GBDATA* GEN_get_current_gene_data(GBDATA gb_main, AW_root aw_root) {
359	GBDATA *gb_species = GEN_get_current_organism(gb_main, aw_root);
360	GBDATA *gb_gene_data = 0;
361
362	if (gb_species) gb_gene_data = GEN_expect_gene_data(gb_species);
363
364	return gb_gene_data;
365	}
366
367	// ---------------------------------------------------------------------
368	// GBDATA GEN_get_current_gene(GBDATA gb_main, AW_root *root)
369	// ---------------------------------------------------------------------
370	GBDATA GEN_get_current_gene(GBDATA gb_main, AW_root *aw_root) {
371	GBDATA *gb_species = GEN_get_current_organism(gb_main, aw_root);
372	GBDATA *gb_gene = 0;
373
374	if (gb_species) {
375	char *gene_name = aw_root->awar(AWAR_GENE_NAME)->read_string();
376	gb_gene = GEN_find_gene(gb_species,gene_name);
377	free(gene_name);
378	}
379
380	return gb_gene;
381	}
382
383
384	static AW_CL ad_global_scannerid = 0;
385	static AW_root *ad_global_scannerroot = 0;
386	AW_CL gene_query_global_cbs = 0;
387
388	// -------------------------------------------
389	// void gene_rename_cb(AW_window *aww)
390	// -------------------------------------------
391	void gene_rename_cb(AW_window *aww){
392
393	GB_ERROR error = 0;
394	AW_root *aw_root = aww->get_root();
395	char *source = aw_root->awar(AWAR_GENE_NAME)->read_string();
396	char *dest = aw_root->awar(AWAR_GENE_DEST)->read_string();
397
398	if (strcmp(source, dest) != 0) {
399	GB_begin_transaction(GLOBAL_gb_main);
400
401	GBDATA *gb_gene_data = GEN_get_current_gene_data(GLOBAL_gb_main, aww->get_root());
402
403	if (!gb_gene_data) error = "Please select a species first";
404	else {
405	GBDATA *gb_source = GEN_find_gene_rel_gene_data(gb_gene_data, source);
406	GBDATA *gb_dest = GEN_find_gene_rel_gene_data(gb_gene_data, dest);
407
408	if (!gb_source) error = "Please select a gene first";
409	else if (gb_dest) error = GB_export_error("Sorry: gene '%s' already exists", dest);
410	else {
411	GBDATA *gb_name = GB_search(gb_source, "name", GB_STRING);
412	error = GB_write_string(gb_name, dest);
413	if (!error) aww->get_root()->awar(AWAR_GENE_NAME)->write_string(dest);
414	}
415	}
416
417	if (!error){
418	aww->hide();
419	GB_commit_transaction(GLOBAL_gb_main);
420	}else{
421	GB_abort_transaction(GLOBAL_gb_main);
422	}
423	}
424
425	if (error) aw_message(error);
426	delete source;
427	delete dest;
428	}
429
430
431	// -----------------------------------------------------------
432	// AW_window create_gene_rename_window(AW_root root)
433	// -----------------------------------------------------------
434	AW_window create_gene_rename_window(AW_root root)
435	{
436	AW_window_simple *aws = new AW_window_simple;
437	aws->init( root, "RENAME_GENE", "GENE RENAME");
438	aws->load_xfig("ad_al_si.fig");
439
440	aws->callback( (AW_CB0)AW_POPDOWN);
441	aws->at("close");
442	aws->create_button("CLOSE","CLOSE","C");
443
444	aws->at("label");
445	aws->create_autosize_button(0,"Please enter the new name\nof the gene");
446
447	aws->at("input");
448	aws->create_input_field(AWAR_GENE_DEST,15);
449	aws->at("ok");
450	aws->callback(gene_rename_cb);
451	aws->create_button("GO","GO","G");
452
453	return (AW_window *)aws;
454	}
455
456	// -----------------------------------------
457	// void gene_copy_cb(AW_window *aww)
458	// -----------------------------------------
459	void gene_copy_cb(AW_window *aww){
460	GB_begin_transaction(GLOBAL_gb_main);
461
462	GB_ERROR error = 0;
463	char *source = aww->get_root()->awar(AWAR_GENE_NAME)->read_string();
464	char *dest = aww->get_root()->awar(AWAR_GENE_DEST)->read_string();
465	GBDATA *gb_gene_data = GEN_get_current_gene_data(GLOBAL_gb_main, aww->get_root());
466
467	if (!gb_gene_data) {
468	error = "Please select a species first.";
469	}
470	else {
471	GBDATA *gb_source = GEN_find_gene_rel_gene_data(gb_gene_data, source);
472	GBDATA *gb_dest = GEN_find_gene_rel_gene_data(gb_gene_data, dest);
473
474	if (!gb_source) error = "Please select a gene first";
475	else if (gb_dest) error = GB_export_error("Sorry: gene '%s' already exists", dest);
476	else {
477	gb_dest = GB_create_container(gb_gene_data,"gene");
478	error = GB_copy(gb_dest, gb_source);
479	if (!error) {
480	GBDATA *gb_name = GB_search(gb_dest,"name",GB_STRING);
481	error = GB_write_string(gb_name,dest);
482	}
483	if (!error) {
484	aww->get_root()->awar(AWAR_GENE_NAME)->write_string(dest);
485	}
486	}
487	}
488
489	if (!error){
490	aww->hide();
491	GB_commit_transaction(GLOBAL_gb_main);
492	}else{
493	GB_abort_transaction(GLOBAL_gb_main);
494	}
495	if (error) aw_message(error);
496	delete source;
497	delete dest;
498	}
499
500	// ---------------------------------------------------------
501	// AW_window create_gene_copy_window(AW_root root)
502	// ---------------------------------------------------------
503	AW_window create_gene_copy_window(AW_root root)
504	{
505	AW_window_simple *aws = new AW_window_simple;
506	aws->init( root, "COPY_GENE", "GENE COPY");
507	aws->load_xfig("ad_al_si.fig");
508
509	aws->callback( (AW_CB0)AW_POPDOWN);
510	aws->at("close");
511	aws->create_button("CLOSE","CLOSE","C");
512
513	aws->at("label");
514	aws->create_autosize_button(0,"Please enter the name\nof the new gene");
515
516	aws->at("input");
517	aws->create_input_field(AWAR_GENE_DEST,15);
518
519	aws->at("ok");
520	aws->callback(gene_copy_cb);
521	aws->create_button("GO","GO","G");
522
523	return (AW_window *)aws;
524	}
525
526	// -------------------------------------------
527	// void gene_create_cb(AW_window *aww)
528	// -------------------------------------------
529	void gene_create_cb(AW_window *aww){
530	GB_begin_transaction(GLOBAL_gb_main);
531
532	GB_ERROR error = 0;
533	AW_root *aw_root = aww->get_root();
534	char *dest = aw_root->awar(AWAR_GENE_DEST)->read_string();
535	int pos1 = atoi(aw_root->awar(AWAR_GENE_POS1)->read_string());
536	int pos2 = atoi(aw_root->awar(AWAR_GENE_POS2)->read_string());
537	int complement = aw_root->awar(AWAR_GENE_COMPLEMENT)->read_int();
538	GBDATA *gb_gene_data = GEN_get_current_gene_data(GLOBAL_gb_main, aw_root);
539	GBDATA *gb_dest = GEN_find_gene_rel_gene_data(gb_gene_data, dest);
540
541	if (!gb_gene_data) error = "Please select a species first";
542	else if (gb_dest) error = GBS_global_string("Gene '%s' already exists", dest);
543	else {
544	GB_ERROR pos_error = 0;
545	if (pos1<1 \|\| pos2<1) {
546	pos_error = "positions have to be above zero";
547	}
548	else if (pos2<pos1) {
549	pos_error = "endpos has to be greater than startpos";
550	}
551	else {
552	GBDATA *gb_organism = GB_get_father(gb_gene_data);
553	GBDATA *gb_genome = GBT_read_sequence(gb_organism, GENOM_ALIGNMENT);
554	int genome_length = GB_read_count(gb_genome);
555
556	if (pos2 > genome_length) {
557	pos_error = GBS_global_string("endpos is behind sequence end (%i)", genome_length);
558	}
559	}
560
561	if (pos_error) {
562	error = GBS_global_string("Illegal position(s): %s", pos_error);
563	}
564	else {
565	gb_dest = GEN_create_gene_rel_gene_data(gb_gene_data, dest);
566	if (gb_dest) {
567	GBDATA *gb_pos = GB_create(gb_dest, "pos_begin", GB_INT);
568	if (!gb_pos) error = GB_get_error();
569	else GB_write_int(gb_pos, pos1);
570
571	if (!error) {
572	gb_pos = GB_create(gb_dest, "pos_end", GB_INT);
573	if (!gb_pos) error = GB_get_error();
574	else GB_write_int(gb_pos, pos2);
575	}
576
577	if (!error) {
578	GBDATA *gb_compl = GB_create(gb_dest, "complement", GB_BYTE);
579	if (!gb_compl) error = GB_get_error();
580	else GB_write_byte(gb_compl, complement);
581	}
582	}
583	else {
584	error = GB_get_error();
585	}
586	if (!error) aww->get_root()->awar(AWAR_GENE_NAME)->write_string(dest);
587	}
588	}
589	if (!error) GB_commit_transaction(GLOBAL_gb_main);
590	else GB_abort_transaction(GLOBAL_gb_main);
591	if (error) aw_message(error);
592	delete dest;
593	}
594
595	// -----------------------------------------------------------
596	// AW_window create_gene_create_window(AW_root root)
597	// -----------------------------------------------------------
598	AW_window create_gene_create_window(AW_root root)
599	{
600	AW_window_simple *aws = new AW_window_simple;
601	aws->init( root, "CREATE_GENE","GENE CREATE");
602	aws->load_xfig("ad_al_si3.fig");
603
604	aws->callback( (AW_CB0)AW_POPDOWN);
605	aws->at("close");
606	aws->create_button("CLOSE","CLOSE","C");
607
608	aws->at("label"); aws->create_autosize_button(0,"Please enter the name\nof the new gene");
609	aws->at("input"); aws->create_input_field(AWAR_GENE_DEST,15);
610
611	aws->at("label1"); aws->create_autosize_button(0,"Start position");
612	aws->at("input1"); aws->create_input_field(AWAR_GENE_POS1,12);
613
614	aws->at("label2"); aws->create_autosize_button(0,"End position");
615	aws->at("input2"); aws->create_input_field(AWAR_GENE_POS2,12);
616
617	aws->at("toggle");
618	aws->label("Complentary strand");
619	aws->create_toggle(AWAR_GENE_COMPLEMENT);
620
621	aws->at("ok");
622	aws->callback(gene_create_cb);
623	aws->create_button("GO","GO","G");
624
625	return (AW_window *)aws;
626	}
627
628
629
630	// -------------------------------------------
631	// void gene_delete_cb(AW_window *aww)
632	// -------------------------------------------
633	void gene_delete_cb(AW_window *aww){
634	if (aw_message("Are you sure to delete the gene","OK,CANCEL")) return;
635
636	GB_begin_transaction(GLOBAL_gb_main);
637
638	GB_ERROR error = 0;
639	GBDATA *gb_gene = GEN_get_current_gene(GLOBAL_gb_main, aww->get_root()); // aw_root);
640
641	if (gb_gene) error = GB_delete(gb_gene);
642	else error = "Please select a gene first";
643
644	if (!error) GB_commit_transaction(GLOBAL_gb_main);
645	else GB_abort_transaction(GLOBAL_gb_main);
646
647	if (error) aw_message(error);
648	}
649
650
651
652	// ------------------------------------------------------------
653	// void GEN_map_gene(AW_root *aw_root, AW_CL scannerid)
654	// ------------------------------------------------------------
655	void GEN_map_gene(AW_root *aw_root, AW_CL scannerid)
656	{
657	GB_transaction dummy(GLOBAL_gb_main);
658	GBDATA *gb_gene = GEN_get_current_gene(GLOBAL_gb_main, aw_root);
659
660	if (gb_gene) awt_map_arbdb_scanner(scannerid, gb_gene, 0, CHANGE_KEY_PATH_GENES);
661	}
662
663	// ----------------------------------------------------
664	// void GEN_create_field_items(AW_window *aws)
665	// ----------------------------------------------------
666	void GEN_create_field_items(AW_window *aws) {
667	aws->insert_menu_topic("reorder_fields", "Reorder fields ...", "R", "spaf_reorder.hlp", AD_F_ALL, AW_POPUP, (AW_CL)NT_create_ad_list_reorder, (AW_CL)&GEN_item_selector);
668	aws->insert_menu_topic("delete_field", "Delete/Hide field ...", "D", "spaf_delete.hlp", AD_F_ALL, AW_POPUP, (AW_CL)NT_create_ad_field_delete, (AW_CL)&GEN_item_selector);
669	aws->insert_menu_topic("create_field", "Create fields ...", "C", "spaf_create.hlp", AD_F_ALL, AW_POPUP, (AW_CL)NT_create_ad_field_create, (AW_CL)&GEN_item_selector);
670	aws->insert_separator();
671	aws->insert_menu_topic("unhide_fields", "Show all hidden fields", "S", "scandb.hlp", AD_F_ALL, (AW_CB)awt_gene_field_selection_list_unhide_all_cb, (AW_CL)GLOBAL_gb_main, AWT_NDS_FILTER);
672	aws->insert_separator();
673	aws->insert_menu_topic("scan_unknown_fields", "Scan unknown fields", "u", "scandb.hlp", AD_F_ALL, (AW_CB)awt_gene_field_selection_list_scan_unknown_cb, (AW_CL)GLOBAL_gb_main, AWT_NDS_FILTER);
674	aws->insert_menu_topic("del_unused_fields", "Remove unused fields", "e", "scandb.hlp", AD_F_ALL, (AW_CB)awt_gene_field_selection_list_delete_unused_cb, (AW_CL)GLOBAL_gb_main, AWT_NDS_FILTER);
675	aws->insert_menu_topic("refresh_fields", "Refresh fields (both)", "f", "scandb.hlp", AD_F_ALL, (AW_CB)awt_gene_field_selection_list_update_cb, (AW_CL)GLOBAL_gb_main, AWT_NDS_FILTER);
676	}
677
678
679	// ------------------------------------------------------------
680	// AW_window GEN_create_gene_window(AW_root aw_root)
681	// ------------------------------------------------------------
682	AW_window GEN_create_gene_window(AW_root aw_root) {
683	static AW_window_simple_menu *aws = 0;
684	if (aws) return (AW_window *)aws;
685
686	aws = new AW_window_simple_menu;
687	aws->init( aw_root, "GENE_INFORMATION", "GENE INFORMATION");
688	aws->load_xfig("ad_spec.fig");
689
690	aws->button_length(8);
691
692	aws->at("close");
693	aws->callback( (AW_CB0)AW_POPDOWN);
694	aws->create_button("CLOSE","CLOSE","C");
695
696	aws->at("search");
697	aws->callback(AW_POPUP, (AW_CL)GEN_create_gene_query_window, 0);
698	aws->create_button("SEARCH","SEARCH","S");
699
700	aws->at("help");
701	aws->callback(AW_POPUP_HELP, (AW_CL)"gene_info.hlp");
702	aws->create_button("HELP","HELP","H");
703
704
705	AW_CL scannerid = awt_create_arbdb_scanner(GLOBAL_gb_main, aws, "box",0,"field","enable",AWT_VIEWER,0,"mark",AWT_NDS_FILTER, &GEN_item_selector);
706	ad_global_scannerid = scannerid;
707	ad_global_scannerroot = aws->get_root();
708
709	aws->create_menu( 0, "GENE", "G", "spa_gene.hlp", AD_F_ALL );
710	aws->insert_menu_topic("gene_delete", "Delete", "D","spa_delete.hlp", AD_F_ALL, (AW_CB)gene_delete_cb, 0, 0);
711	aws->insert_menu_topic("gene_rename", "Rename ...", "R","spa_rename.hlp", AD_F_ALL, AW_POPUP, (AW_CL)create_gene_rename_window, 0);
712	aws->insert_menu_topic("gene_copy", "Copy ...", "y","spa_copy.hlp", AD_F_ALL, AW_POPUP, (AW_CL)create_gene_copy_window, 0);
713	aws->insert_menu_topic("gene_create", "Create ...", "C","spa_create.hlp", AD_F_ALL, AW_POPUP, (AW_CL)create_gene_create_window, 0);
714	aws->insert_separator();
715
716	aws->create_menu( 0, "FIELDS", "F", "gene_fields.hlp", AD_F_ALL );
717	GEN_create_field_items(aws);
718
719	{
720	Awar_Callback_Info *cb_info = new Awar_Callback_Info(aws->get_root(), AWAR_GENE_NAME, GEN_map_gene, scannerid); // do not delete!
721	AW_detach_information *detach_info = new AW_detach_information(cb_info); // do not delete!
722
723	cb_info->add_callback();
724
725	aws->at("detach");
726	aws->callback(NT_detach_information_window, (AW_CL)&aws, (AW_CL)detach_info);
727	aws->create_button("DETACH", "DETACH", "D");
728
729	detach_info->set_detach_button(aws->get_last_button_widget());
730	}
731
732	// aws->get_root()->awar(AWAR_GENE_NAME)->add_callback(GEN_map_gene,scannerid);
733
734	aws->show();
735	GEN_map_gene(aws->get_root(),scannerid);
736	return (AW_window *)aws;
737	}
738
739	void GEN_popup_gene_window(AW_window *aww, AW_CL, AW_CL) { // w/o this DETACH does not work
740	AW_window *aws = GEN_create_gene_window(aww->get_root());
741	aws->show();
742	}
743
744	// ------------------------------------------------------------------
745	// AW_window GEN_create_gene_query_window(AW_root aw_root)
746	// ------------------------------------------------------------------
747	AW_window GEN_create_gene_query_window(AW_root aw_root) {
748
749	static AW_window_simple_menu *aws = 0;
750	if (aws){
751	return (AW_window *)aws;
752	}
753	aws = new AW_window_simple_menu;
754	aws->init( aw_root, "GEN_QUERY", "Gene SEARCH and QUERY");
755	aws->create_menu(0,"More functions","f");
756	aws->load_xfig("ad_query.fig");
757
758	awt_query_struct awtqs;
759
760	awtqs.gb_main = GLOBAL_gb_main;
761	awtqs.species_name = AWAR_SPECIES_NAME;
762	awtqs.tree_name = AWAR_TREE;
763	// awtqs.query_genes = true;
764	// awtqs.gene_name = AWAR_GENE_NAME;
765	awtqs.select_bit = 1;
766	awtqs.use_menu = 1;
767	awtqs.ere_pos_fig = "ere3";
768	awtqs.where_pos_fig = "where3";
769	awtqs.by_pos_fig = "by3";
770	awtqs.qbox_pos_fig = "qbox";
771	awtqs.rescan_pos_fig = 0;
772	awtqs.key_pos_fig = 0;
773	awtqs.query_pos_fig = "content";
774	awtqs.result_pos_fig = "result";
775	awtqs.count_pos_fig = "count";
776	awtqs.do_query_pos_fig = "doquery";
777	awtqs.config_pos_fig = "doconfig";
778	awtqs.do_mark_pos_fig = "domark";
779	awtqs.do_unmark_pos_fig = "dounmark";
780	awtqs.do_delete_pos_fig = "dodelete";
781	awtqs.do_set_pos_fig = "doset";
782	awtqs.do_refresh_pos_fig = "dorefresh";
783	awtqs.open_parser_pos_fig = "openparser";
784	awtqs.create_view_window = (AW_CL)GEN_create_gene_window;
785	awtqs.selector = &GEN_item_selector;
786
787	AW_CL cbs = (AW_CL)awt_create_query_box((AW_window*)aws,&awtqs);
788	gene_query_global_cbs = cbs;
789
790	aws->create_menu( 0, "More search", "s" );
791	aws->insert_menu_topic( "search_equal_fields_within_db","Search For Equal Fields and Mark Duplikates", "E",0, -1, (AW_CB)awt_search_equal_entries, cbs, 0 );
792	aws->insert_menu_topic( "search_equal_words_within_db", "Search For Equal Words Between Fields and Mark Duplikates", "W",0, -1, (AW_CB)awt_search_equal_entries, cbs, 1 );
793
794	aws->button_length(7);
795
796	aws->at("close");
797	aws->callback( (AW_CB0)AW_POPDOWN);
798	aws->create_button("CLOSE","CLOSE","C");
799	aws->at("help");
800	aws->callback( AW_POPUP_HELP,(AW_CL)"gene_search.hlp");
801	aws->create_button("HELP","HELP","H");
802
803	return (AW_window *)aws;
804
805	}
806
807

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

Download in other formats: