source: tags/initial/NTREE/ad_trees.cxx

Last change on this file was 2, checked in by oldcode, 25 years ago

Initial revision
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.9 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <memory.h>
4#include <malloc.h>
5#include <string.h>
6
7#include <arbdb.h>
8#include <arbdbt.h>
9#include <aw_root.hxx>
10#include <aw_device.hxx>
11#include <aw_window.hxx>
12#include <aw_awars.hxx>
13#include <awt.hxx>
14#include <awt_imp_exp.hxx>
15#include <cat_tree.hxx>
16#include <awt_tree_cmp.hxx>
17
18extern GBDATA *gb_main;
19
20const char *AWAR_TREE_NAME              =       "tmp/ad_tree/tree_name";
21const char *AWAR_TREE_DEST              =       "tmp/ad_tree/tree_dest";
22const char *AWAR_TREE_SECURITY  =       "tmp/ad_tree/tree_security";
23const char *AWAR_TREE_REM               =       "tmp/ad_tree/tree_rem";
24
25#define AWAR_TREE_EXPORT                    "tmp/ad_tree/export_tree"
26#define AWAR_TREE_IMPORT                    "tmp/ad_tree/import_tree"
27#define AWAR_NODE_INFO_ONLY_MARKED          "tmp/ad_tree/import_only_marked_node_info"
28
29void tree_vars_callback(AW_root *aw_root)               // Map tree vars to display objects
30{
31        GB_push_transaction(gb_main);
32        char *treename = aw_root->awar(AWAR_TREE_NAME)->read_string();
33        GBDATA *ali_cont = GBT_get_tree(gb_main,treename);
34        if (!ali_cont) {
35                aw_root->awar(AWAR_TREE_SECURITY)->unmap();
36                aw_root->awar(AWAR_TREE_REM)->unmap();
37        }else{
38
39        GBDATA *tree_prot =     GB_search(ali_cont,"security",  GB_FIND);
40        if (!tree_prot) {
41            GBT_read_int2(ali_cont,"security",
42                          GB_read_security_write(ali_cont));
43        }
44        tree_prot =     GB_search(ali_cont,"security",  GB_INT);
45        GBDATA *tree_rem =      GB_search(ali_cont,"remark",    GB_STRING);
46        aw_root->awar(AWAR_TREE_SECURITY)->map((void*)tree_prot);
47        aw_root->awar(AWAR_TREE_REM)->map((void*)tree_rem);
48        }
49        char *fname = GBS_string_eval(treename,"*=*1.tree:tree_*=*1",0);
50        aw_root->awar(AWAR_TREE_EXPORT "/file_name")->write_string(fname);      // create default file name
51        delete fname;
52        GB_pop_transaction(gb_main);   
53        free(treename);
54}
55/*      update import tree name depending on file name */
56void tree_import_callback(AW_root *aw_root) {
57        GB_transaction dummy(gb_main);
58        char *treename = aw_root->awar(AWAR_TREE_IMPORT "/file_name")->read_string();
59
60        char *fname = GBS_string_eval(treename,"*.tree=tree_*1",0);
61        aw_root->awar(AWAR_TREE_IMPORT "/tree_name")->write_string(fname);
62        delete fname;
63        delete treename;
64}
65
66
67void ad_tree_set_security(AW_root *aw_root)
68{
69        GB_transaction dummy(gb_main);
70        char *treename = aw_root->awar(AWAR_TREE_NAME)->read_string();
71        GBDATA *ali_cont = GBT_get_tree(gb_main,treename);
72        if (ali_cont) {
73                long prot = aw_root->awar(AWAR_TREE_SECURITY)->read_int();
74                long old;
75                old = GB_read_security_delete(ali_cont);
76                GB_ERROR error = 0;
77                if (old != prot){
78                        error = GB_write_security_delete(ali_cont,prot);
79                        if (!error)
80                error = GB_write_security_write(ali_cont,prot);
81                }
82                if (error ) aw_message(error);
83        }
84        free(treename);
85}
86
87void update_filter_cb(AW_root *root){
88        int NDS = root->awar(AWAR_TREE_EXPORT "/NDS")->read_int();
89        switch(NDS){
90        case 1: root->awar(AWAR_TREE_EXPORT "/filter")->write_string("tree");break;
91        case 2: root->awar(AWAR_TREE_EXPORT "/filter")->write_string("otb");break;
92        default:root->awar(AWAR_TREE_EXPORT "/filter")->write_string("ntree");break;
93        }
94}
95
96void create_trees_var(AW_root *aw_root, AW_default aw_def)
97{
98        aw_root->awar_string( AWAR_TREE_NAME,           0,      aw_def ) ->set_srt( GBT_TREE_AWAR_SRT);
99        aw_root->awar_string( AWAR_TREE_DEST,           0,      aw_def ) ->set_srt( GBT_TREE_AWAR_SRT);
100        aw_root->awar_int(      AWAR_TREE_SECURITY,     0,      aw_def );
101        aw_root->awar_string( AWAR_TREE_REM,            0,      aw_def );
102
103        aw_root->awar_string( AWAR_TREE_EXPORT "/file_name", "treefile",aw_def);
104        aw_root->awar_string( AWAR_TREE_EXPORT "/directory", "",        aw_def);
105        aw_root->awar_string( AWAR_TREE_EXPORT "/filter", "tree",       aw_def);
106        aw_root->awar_int(    AWAR_TREE_EXPORT "/NDS", 0,               aw_def)-> add_callback(update_filter_cb);
107
108        aw_root->awar_string( AWAR_TREE_IMPORT "/file_name", "treefile",aw_def);
109        aw_root->awar_string( AWAR_TREE_IMPORT "/directory", "",        aw_def);
110        aw_root->awar_string( AWAR_TREE_IMPORT "/filter", "tree",       aw_def);
111        aw_root->awar_string( AWAR_TREE_IMPORT "/tree_name", "tree_",   aw_def) ->set_srt( GBT_TREE_AWAR_SRT);
112
113        aw_root->awar(AWAR_TREE_IMPORT "/file_name")->add_callback( tree_import_callback);
114        aw_root->awar(AWAR_TREE_NAME)->add_callback( tree_vars_callback);
115        aw_root->awar(AWAR_TREE_SECURITY)->add_callback( ad_tree_set_security);
116   
117        aw_root->awar_int( AWAR_NODE_INFO_ONLY_MARKED, 0,       aw_def);
118   
119        tree_vars_callback(aw_root);
120}
121
122void tree_rename_cb(AW_window *aww){
123        GB_ERROR error = 0;
124        char *source = aww->get_root()->awar(AWAR_TREE_NAME)->read_string();
125        char *dest = aww->get_root()->awar(AWAR_TREE_DEST)->read_string();
126        error = GBT_check_tree_name(dest);
127        if (!error) {
128                GB_begin_transaction(gb_main);
129                GBDATA *gb_tree_data =
130                        GB_search(gb_main,"tree_data",GB_CREATE_CONTAINER);
131                GBDATA *gb_tree_name =
132                        GB_find(gb_tree_data,source,0,down_level);
133                GBDATA *gb_dest =
134                        GB_find(gb_tree_data,dest,0,down_level);
135                if (gb_dest) {
136                        error = "Sorry: Tree already exists";
137                }else   if (gb_tree_name) {
138                        GBDATA *gb_new_tree = GB_create_container(gb_tree_data,dest);
139                        GB_copy(gb_new_tree, gb_tree_name);
140                        error = GB_delete(gb_tree_name);
141                }else{
142                        error = "Please select a tree first";
143                }
144                if (!error) GB_commit_transaction(gb_main);
145                else    GB_abort_transaction(gb_main);
146        }
147        if (error) aw_message(error);
148        else aww->hide();
149        delete source;
150        delete dest;
151}
152
153void tree_copy_cb(AW_window *aww){
154        GB_ERROR error = 0;
155        char *source = aww->get_root()->awar(AWAR_TREE_NAME)->read_string();
156        char *dest = aww->get_root()->awar(AWAR_TREE_DEST)->read_string();
157        error = GBT_check_tree_name(dest);
158        if (!error) {
159                GB_begin_transaction(gb_main);
160                GBDATA *gb_tree_data =
161                        GB_search(gb_main,"tree_data",GB_CREATE_CONTAINER);
162                GBDATA *gb_tree_name =
163                        GB_find(gb_tree_data,source,0,down_level);
164                GBDATA *gb_dest =
165                        GB_find(gb_tree_data,dest,0,down_level);
166                if (gb_dest) {
167                        error = "Sorry: Tree already exists";
168                }else                   if (gb_tree_name) {
169                        gb_dest = GB_create_container(gb_tree_data,dest);
170                        error = GB_copy(gb_dest,gb_tree_name);
171                }else{
172                        error = "Please select a tree first";
173                }
174                if (!error) GB_commit_transaction(gb_main);
175                else    GB_abort_transaction(gb_main);
176        }
177        if (error) aw_message(error);
178        else aww->hide();
179        delete source;
180        delete dest;
181}
182
183void create_tree_last_window(AW_window *aww) {
184        GB_ERROR error = 0;
185        char *source = aww->get_root()->awar(AWAR_TREE_NAME)->read_string();
186        GB_begin_transaction(gb_main);
187        GBDATA *gb_tree_data =  GB_search(gb_main,"tree_data",GB_CREATE_CONTAINER);
188        GBDATA *gb_tree_name =  GB_find(gb_tree_data,source,0,down_level);
189        GBDATA *gb_dest = GB_create_container(gb_tree_data,source);
190        error = GB_copy(gb_dest,gb_tree_name);
191        if (!error) error = GB_delete(gb_tree_name);
192        if (!error) GB_commit_transaction(gb_main);
193        else    GB_abort_transaction(gb_main);
194        if (error) aw_message(error);
195        delete source;
196
197}
198
199void tree_save_cb(AW_window *aww){
200        AW_root *aw_root = aww->get_root();
201        GB_ERROR error = 0;
202        long NDS = aw_root->awar(AWAR_TREE_EXPORT "/NDS")->read_int();
203        char *fname = aw_root->awar(AWAR_TREE_EXPORT "/file_name")->read_string();
204        char *tree_name = aw_root->awar(AWAR_TREE_NAME)->read_string();
205        if (!tree_name || !strlen(tree_name)) error = GB_export_error("Please select a tree first");
206        if (!error){
207                switch(NDS){
208                        case 2:
209                                error = create_and_save_CAT_tree(gb_main,tree_name,fname);
210                                break;
211                        default:
212                                error = AWT_export_tree(gb_main,tree_name,(int)NDS,fname);
213                                break;
214                }
215        }
216
217        if (error) aw_message(error);
218        else{
219                aw_root->awar(AWAR_TREE_EXPORT "/directory")->touch();
220                aww->hide();
221        }
222        delete fname;
223        delete tree_name;
224}
225
226AW_window *create_tree_export_window(AW_root *root)
227{
228        AW_window_simple *aws = new AW_window_simple;
229        aws->init( root, "SAVE_TREE", "TREE SAVE", 100, 100 );
230        aws->load_xfig("sel_box.fig");
231
232        aws->callback( (AW_CB0)AW_POPDOWN);
233        aws->at("close");
234        aws->create_button("CLOSE","CLOSE","C");                           
235
236        aws->at("help");
237        aws->callback(AW_POPUP_HELP,(AW_CL)"tr_export.hlp");
238        aws->create_button("HELP","HELP","H");                     
239
240        aws->at("user");
241        aws->create_option_menu(AWAR_TREE_EXPORT "/NDS",0,0);
242        aws->insert_option("PLAIN FORMAT","P",0);
243        aws->insert_option("USE NDS (CANNOT BE RELOADED)","N",1);
244        aws->insert_option("ORS TRANSFER BINARY FORMAT","O",2);
245        aws->update_option_menu();
246
247        awt_create_selection_box((AW_window *)aws,AWAR_TREE_EXPORT "");
248
249        aws->at("save2");
250        aws->callback(tree_save_cb);
251        aws->create_button("SAVE","SAVE","o");                     
252
253        aws->callback( (AW_CB0)AW_POPDOWN);
254        aws->at("cancel2");
255        aws->create_button("CANCEL","CANCEL","C");                         
256
257        return (AW_window *)aws;
258}
259
260void tree_load_cb(AW_window *aww){
261        AW_root *aw_root = aww->get_root();
262        GB_ERROR error = 0;
263        char *fname = aw_root->awar(AWAR_TREE_IMPORT "/file_name")->read_string();
264        char *tree_name = aw_root->awar(AWAR_TREE_IMPORT "/tree_name")->read_string();
265        GBT_TREE *tree = GBT_load_tree(fname,sizeof(GBT_TREE));
266
267    //  long fuzzy = aw_root->awar( AWAR_TREE_IMPORT "/fuzzy")->read_int();
268
269        if (!tree){
270                error = GB_get_error();
271        }else{
272                GB_transaction dummy(gb_main);
273        //              if (fuzzy) {
274        //                      error = GBT_fuzzy_link_tree(tree,gb_main);
275        //              }
276                if (!error) error = GBT_write_tree(gb_main,0,tree_name,tree);
277                GBT_delete_tree(tree);
278        }
279        if (error) aw_message(error);
280        else{
281            aww->hide();
282            aw_root->awar(AWAR_TREE)->write_string(tree_name);  // show new tree
283        }
284        delete fname;
285        delete tree_name;
286}
287
288AW_window *create_tree_import_window(AW_root *root)
289{
290        AW_window_simple *aws = new AW_window_simple;
291        aws->init( root, "LOAD_TREE", "TREE LOAD", 100, 100 );
292        aws->load_xfig("sel_box.fig");
293
294        aws->callback( (AW_CB0)AW_POPDOWN);
295        aws->at("close");
296        aws->create_button("CLOSE","CLOSE","C");                           
297
298
299        aws->at("user");
300        aws->label("tree_name:");
301        aws->create_input_field(AWAR_TREE_IMPORT "/tree_name",15);
302
303        awt_create_selection_box((AW_window *)aws,AWAR_TREE_IMPORT "");
304
305        aws->at("save2");
306        aws->callback(tree_load_cb);
307        aws->create_button("LOAD","LOAD","o");                     
308
309        aws->callback( (AW_CB0)AW_POPDOWN);
310        aws->at("cancel2");
311        aws->create_button("CANCEL","CANCEL","C");                         
312
313        return (AW_window *)aws;
314}
315
316AW_window *create_tree_rename_window(AW_root *root)
317{
318        AW_window_simple *aws = new AW_window_simple;
319        aws->init( root, "RENAME_TREE","TREE RENAME", 100, 100 );
320        aws->load_xfig("ad_al_si.fig");
321
322        aws->callback( (AW_CB0)AW_POPDOWN);
323        aws->at("close");
324        aws->create_button("CLOSE","CLOSE","C");                           
325
326        aws->at("label");
327        aws->create_button(0,"Please enter the new name\nof the tree");
328
329        aws->at("input");
330        aws->create_input_field(AWAR_TREE_DEST,15);
331
332        aws->at("ok");
333        aws->callback(tree_rename_cb);
334        aws->create_button("GO","GO","G");                         
335
336        return (AW_window *)aws;
337}
338
339AW_window *create_tree_copy_window(AW_root *root)
340{
341        AW_window_simple *aws = new AW_window_simple;
342        aws->init( root, "COPY_TREE", "TREE COPY", 100, 100 );
343        aws->load_xfig("ad_al_si.fig");
344
345        aws->callback( (AW_CB0)AW_POPDOWN);
346        aws->at("close");
347        aws->create_button("CLOSE","CLOSE","C");                           
348
349        aws->at("label");
350        aws->create_button(0,"Please enter the name\nof the new tree");
351
352        aws->at("input");
353        aws->create_input_field(AWAR_TREE_DEST,15);
354
355        aws->at("ok");
356        aws->callback(tree_copy_cb);
357        aws->create_button("GO","GO","G");                         
358
359        return (AW_window *)aws;
360}
361
362void ad_move_tree_info(AW_window *aww,AW_CL mode){
363    /*
364      mode == 0 -> move info (=overwrite info from source tree)
365      mode == 1 -> compare info
366      mode == 2 -> add info
367    */
368    char *t1 = aww->get_root()->awar(AWAR_TREE_NAME)->read_string();
369    char *t2 = aww->get_root()->awar(AWAR_TREE_DEST)->read_string();
370    char *log_file = strdup(GBS_global_string("/tmp/arb_log_%s_%i",GB_getenvUSER(),GB_getuid()));
371   
372    AW_BOOL compare_node_info = mode==1;
373    AW_BOOL delete_old_nodes = mode==0;
374    AW_BOOL nodes_with_marked_only = (mode==0 || mode==2) && aww->get_root()->awar(AWAR_NODE_INFO_ONLY_MARKED)->read_int();
375   
376    // move or add node-info writes a log file (containing errors)
377    // compare_node_info only sets remark branches
378   
379    if ( compare_node_info ) { delete log_file;log_file = 0; } // no log if compare_node_info
380   
381    AWT_move_info(gb_main, t1, t2, log_file, compare_node_info, delete_old_nodes, nodes_with_marked_only);
382   
383    if (log_file) GB_edit(log_file);
384   
385    delete log_file;
386    delete t2;
387    delete t1;
388    aww->hide();
389}
390
391AW_window *create_tree_diff_window(AW_root *root){
392    static AW_window_simple *aws = 0;
393    if (aws) return aws;
394    GB_transaction dummy(gb_main);
395    aws = new AW_window_simple;
396    aws->init( root, "CMP_TOPOLOGY", "COMPARE TREE TOPOLOGIES", 200, 0 );
397    aws->load_xfig("ad_tree_cmp.fig");
398   
399    aws->callback( AW_POPDOWN);
400    aws->at("close");
401    aws->create_button("CLOSE","CLOSE","C");                   
402
403    aws->callback( AW_POPUP_HELP,(AW_CL)"tree_diff.hlp");
404    aws->at("help");
405    aws->create_button("HELP","HELP","H");                     
406
407    root->awar_string(AWAR_TREE_NAME);
408    root->awar_string(AWAR_TREE_DEST);
409
410    aws->at("tree1");
411    awt_create_selection_list_on_trees(gb_main,(AW_window *)aws,AWAR_TREE_NAME);
412    aws->at("tree2");
413    awt_create_selection_list_on_trees(gb_main,(AW_window *)aws,AWAR_TREE_DEST);
414       
415    aws->button_length(20);
416   
417    aws->at("move");
418    aws->callback(ad_move_tree_info,1); // compare
419    aws->create_button("CMP_TOPOLOGY","COMPARE TOPOLOGY");                     
420
421    return aws;
422}
423AW_window *create_tree_cmp_window(AW_root *root){
424    static AW_window_simple *aws = 0;
425    if (aws) return aws;
426    GB_transaction dummy(gb_main);
427    aws = new AW_window_simple;
428    aws->init( root, "COPY_NODE_INFO_OF_TREE", "TREE COPY INFO", 200, 0 );
429    aws->load_xfig("ad_tree_cmp.fig");
430   
431    aws->callback( AW_POPDOWN);
432    aws->at("close");
433    aws->create_button("CLOSE","CLOSE","C");                   
434
435    aws->callback( AW_POPUP_HELP,(AW_CL)"tree_cmp.hlp");
436    aws->at("help");
437    aws->create_button("HELP","HELP","H");                     
438
439    root->awar_string(AWAR_TREE_NAME);
440    root->awar_string(AWAR_TREE_DEST);
441   
442    aws->at("tree1");
443    awt_create_selection_list_on_trees(gb_main,(AW_window *)aws,AWAR_TREE_NAME);
444    aws->at("tree2");
445    awt_create_selection_list_on_trees(gb_main,(AW_window *)aws,AWAR_TREE_DEST);
446       
447    aws->at("move");
448    aws->callback(ad_move_tree_info,0); // move
449    aws->create_button("COPY_INFO","COPY INFO");                       
450
451    aws->at("cmp");
452    aws->callback(ad_move_tree_info,2); // add
453    aws->create_button("ADD_INFO","ADD INFO");                 
454   
455    aws->at("only_marked");
456    aws->label("only info containing marked species");
457    aws->create_toggle(AWAR_NODE_INFO_ONLY_MARKED);   
458   
459    return aws;
460}
461void ad_tr_delete_cb(AW_window *aww){
462        GB_ERROR error = 0;
463        char *source = aww->get_root()->awar(AWAR_TREE_NAME)->read_string();
464        GB_begin_transaction(gb_main);
465        GBDATA *gb_tree_data =  GB_search(gb_main,"tree_data",GB_CREATE_CONTAINER);
466        GBDATA *gb_tree_name =  GB_find(gb_tree_data,source,0,down_level);
467        if (gb_tree_name) {
468            char *newname = GBT_get_next_tree_name(gb_main,source);
469            error = GB_delete(gb_tree_name);
470            if (newname){
471            aww->get_root()->awar(AWAR_TREE_NAME)->write_string(newname);
472            delete newname;
473            }
474        }else{
475        error = "Please select a tree first";
476        }
477
478        if (!error) GB_commit_transaction(gb_main);
479        else    GB_abort_transaction(gb_main);
480
481        if (error) aw_message(error);
482        delete source;
483}
484
485AW_window *create_trees_window(AW_root *aw_root)
486{
487        static AW_window_simple *aws = 0;
488        if (aws) return aws;
489        aws = new AW_window_simple;
490        aws->init( aw_root, "TREE_ADMIN","TREE ADMIN", 200, 0 );
491        aws->load_xfig("ad_tree.fig");
492
493        aws->callback( AW_POPDOWN);
494        aws->at("close");
495        aws->create_button("CLOSE","CLOSE","C");                           
496
497        aws->callback( AW_POPUP_HELP,(AW_CL)"treeadm.hlp");
498        aws->at("help");
499        aws->create_button("HELP","HELP","H");                     
500
501        aws->button_length(20);
502
503        aws->at("delete");
504        aws->callback(ad_tr_delete_cb);
505        aws->create_button("DELETE","DELETE","D");                         
506
507        aws->at("rename");
508        aws->callback(AW_POPUP,(AW_CL)create_tree_rename_window,0);
509        aws->create_button("RENAME","RENAME","R");                         
510
511        aws->at("copy");
512        aws->callback(AW_POPUP,(AW_CL)create_tree_copy_window,0);
513        aws->create_button("COPY","COPY","C");                     
514
515        aws->at("move");
516        aws->callback(AW_POPUP,(AW_CL)create_tree_cmp_window,0);
517        aws->create_button("MOVE_NODE_INFO","MOVE NODE INFO","C");                         
518       
519        aws->at("cmp");
520        aws->callback(AW_POPUP,(AW_CL)create_tree_diff_window,0);
521        aws->create_button("CMP_TOPOLOGY","COMPARE TOPOLOGY","T");                         
522       
523        aws->at("export");
524        aws->callback(AW_POPUP,(AW_CL)create_tree_export_window,0);
525        aws->create_button("EXPORT","EXPORT","E");                         
526
527        aws->at("import");
528        aws->callback(AW_POPUP,(AW_CL)create_tree_import_window,0);
529        aws->create_button("IMPORT","IMPORT","I");                         
530
531        aws->at("last");
532        aws->callback(create_tree_last_window);
533        aws->create_button("PUT_TO_END","PUT TO END","P");                         
534
535        aws->at("list");
536        awt_create_selection_list_on_trees(gb_main,(AW_window *)aws,AWAR_TREE_NAME);
537
538        aws->at("security");
539        aws->create_option_menu(AWAR_TREE_SECURITY);
540        aws->insert_option("0","0",0);
541        aws->insert_option("1","1",1);
542        aws->insert_option("2","2",2);
543        aws->insert_option("3","3",3);
544        aws->insert_option("4","4",4);
545        aws->insert_option("5","5",5);
546        aws->insert_default_option("6","6",6);
547        aws->update_option_menu();
548
549        aws->at("rem");
550        aws->create_text_field(AWAR_TREE_REM);
551
552        return (AW_window *)aws;
553}
Note: See TracBrowser for help on using the repository browser.