source: tags/svn.1.5.4/GENOM/EXP_interface.cxx

Last change on this file was 8360, checked in by westram, 13 years ago
  • renamed menu separator functions
  • removed macro AWMIMT
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.1 KB
Line 
1//  ==================================================================== //
2//                                                                       //
3//    File      : EXP_interface.cxx                                      //
4//    Purpose   :                                                        //
5//                                                                       //
6//                                                                       //
7//  Coded by Ralf Westram (coder@reallysoft.de) in September 2001        //
8//  Copyright Department of Microbiology (Technical University Munich)   //
9//                                                                       //
10//  Visit our web site at: http://www.arb-home.de/                       //
11//                                                                       //
12//                                                                       //
13//  ==================================================================== //
14
15#include "EXP_local.hxx"
16#include "GEN_local.hxx"
17
18#include <db_query.h>
19#include <db_scanner.hxx>
20#include <dbui.h>
21#include <awt_sel_boxes.hxx>
22#include <item_sel_list.h>
23#include <aw_awar_defs.hxx>
24#include <aw_detach.hxx>
25#include <aw_msg.hxx>
26#include <aw_question.hxx>
27#include <arbdbt.h>
28
29using namespace std;
30
31#define AD_F_ALL AWM_ALL
32
33static GBDATA* EXP_get_current_experiment_data(GBDATA *gb_main, AW_root *aw_root) {
34    GBDATA *gb_species         = GEN_get_current_organism(gb_main, aw_root);
35    GBDATA *gb_experiment_data = 0;
36
37    if (gb_species) gb_experiment_data = EXP_get_experiment_data(gb_species);
38
39    return gb_experiment_data;
40}
41
42static void EXP_select_experiment(GBDATA* /* gb_main */, AW_root *aw_root, const char *item_name) {
43    char *name  = strdup(item_name);
44    char *slash = strchr(name, '/');
45
46    if (slash) {
47        slash[0] = 0;
48        aw_root->awar(AWAR_ORGANISM_NAME)->write_string(name);
49        aw_root->awar(AWAR_EXPERIMENT_NAME)->write_string(slash+1);
50    }
51    free(name);
52}
53
54static char *EXP_get_experiment_id(GBDATA * /* gb_main */, GBDATA *gb_experiment) {
55    GBDATA *gb_species = GB_get_grandfather(gb_experiment);
56    return GBS_global_string_copy("%s/%s", GBT_read_name(gb_species), GBT_read_name(gb_experiment));
57}
58
59static GBDATA *EXP_find_experiment_by_id(GBDATA *gb_main, const char *id) {
60    char   *organism = strdup(id);
61    char   *exp     = strchr(organism, '/');
62    GBDATA *result   = 0;
63
64    if (exp) {
65        *exp++ = 0;
66        GBDATA *gb_organism = GEN_find_organism(gb_main, organism);
67        if (gb_organism) {
68            result = EXP_find_experiment(gb_organism, exp);
69        }
70    }
71
72    free(organism);
73    return result;
74}
75
76static char *old_species_marks = 0; // configuration storing marked species
77
78inline void exp_restore_old_species_marks(GBDATA *gb_main) {
79    if (old_species_marks) {
80        GBT_restore_marked_species(gb_main, old_species_marks);
81        freenull(old_species_marks);
82    }
83}
84
85static GBDATA *EXP_get_first_experiment_data(GBDATA *gb_main, AW_root *aw_root, QUERY_RANGE range) {
86    GBDATA   *gb_organism = 0;
87    GB_ERROR  error      = 0;
88
89    exp_restore_old_species_marks(gb_main);
90
91    switch (range) {
92        case QUERY_CURRENT_ITEM: {
93            char *species_name = aw_root->awar(AWAR_ORGANISM_NAME)->read_string();
94            gb_organism         = GBT_find_species(gb_main, species_name);
95            free(species_name);
96            break;
97        }
98        case QUERY_MARKED_ITEMS: {
99            GBDATA *gb_pseudo = GEN_first_marked_pseudo_species(gb_main);
100
101            if (gb_pseudo) {    // there are marked pseudo-species..
102                old_species_marks = GBT_store_marked_species(gb_main, 1); // store and unmark marked species
103                error             = GBT_with_stored_species(gb_main, old_species_marks, GEN_mark_organism_or_corresponding_organism, 0); // mark organisms related with stored
104
105                if (!error) gb_organism = GEN_first_marked_organism(gb_main);
106            }
107            else {
108                gb_organism = GEN_first_marked_organism(gb_main);
109            }
110
111            break;
112        }
113        case QUERY_ALL_ITEMS: {
114            gb_organism = GBT_first_species(gb_main);
115            break;
116        }
117        default: {
118            gen_assert(0);
119            break;
120        }
121    }
122
123    if (error) GB_export_error(error);
124    return gb_organism ? EXP_get_experiment_data(gb_organism) : 0;
125}
126
127static GBDATA *EXP_get_next_experiment_data(GBDATA *gb_experiment_data, QUERY_RANGE range) {
128    GBDATA *gb_organism = 0;
129    switch (range) {
130        case QUERY_CURRENT_ITEM: {
131            break;
132        }
133        case QUERY_MARKED_ITEMS: {
134            GBDATA *gb_last_species = GB_get_father(gb_experiment_data);
135            gb_organism             = GEN_next_marked_organism(gb_last_species);
136
137            if (!gb_organism) exp_restore_old_species_marks(GB_get_root(gb_experiment_data)); // got all -> clean up
138
139            break;
140        }
141        case QUERY_ALL_ITEMS: {
142            GBDATA *gb_last_species = GB_get_father(gb_experiment_data);
143            gb_organism             = GBT_next_species(gb_last_species);
144            break;
145        }
146        default: {
147            gen_assert(0);
148            break;
149        }
150    }
151
152    return gb_organism ? EXP_get_experiment_data(gb_organism) : 0;
153}
154
155static GBDATA *EXP_get_current_experiment(GBDATA *gb_main, AW_root *aw_root) {
156    GBDATA *gb_organism    = GEN_get_current_organism(gb_main, aw_root);
157    GBDATA *gb_experiment = 0;
158
159    if (gb_organism) {
160        char *experiment_name = aw_root->awar(AWAR_EXPERIMENT_NAME)->read_string();
161        gb_experiment         = EXP_find_experiment(gb_organism, experiment_name);
162        free(experiment_name);
163    }
164
165    return gb_experiment;
166}
167
168static GBDATA *first_experiment_in_range(GBDATA *gb_experiment_data, QUERY_RANGE range) {
169    GBDATA *gb_first = NULL;
170    switch (range) {
171        case QUERY_ALL_ITEMS:    gb_first = EXP_first_experiment_rel_exp_data(gb_experiment_data); break;
172        case QUERY_MARKED_ITEMS: gb_first = GB_first_marked(gb_experiment_data, "experiment"); break;
173        case QUERY_CURRENT_ITEM: gb_first = EXP_get_current_experiment(GB_get_root(gb_experiment_data), AW_root::SINGLETON); break;
174    }
175    return gb_first;
176}
177static GBDATA *next_experiment_in_range(GBDATA *gb_prev, QUERY_RANGE range) {
178    GBDATA *gb_next = NULL;
179    switch (range) {
180        case QUERY_ALL_ITEMS:    gb_next = EXP_next_experiment(gb_prev); break;
181        case QUERY_MARKED_ITEMS: gb_next = GB_next_marked(gb_prev, "experiment"); break;
182        case QUERY_CURRENT_ITEM: gb_next = NULL; break;
183    }
184    return gb_next;
185}
186
187#if defined(WARN_TODO)
188#warning move EXP_item_selector to SL/ITEMS
189#endif
190
191static struct MutableItemSelector EXP_item_selector = {
192    QUERY_ITEM_EXPERIMENTS,
193    EXP_select_experiment,
194    EXP_get_experiment_id,
195    EXP_find_experiment_by_id,
196    (AW_CB)experiment_field_selection_list_update_cb,
197    -1, // unknown
198    CHANGE_KEY_PATH_EXPERIMENTS,
199    "experiment",
200    "experiments",
201    "name",
202    EXP_get_first_experiment_data,
203    EXP_get_next_experiment_data,
204    first_experiment_in_range,
205    next_experiment_in_range,
206    EXP_get_current_experiment,
207    &ORGANISM_get_selector(), GB_get_grandfather,
208};
209
210ItemSelector& EXP_get_selector() { return EXP_item_selector; }
211
212static QUERY::DbQuery *GLOBAL_experiment_query = 0;
213
214static AW_window *EXP_create_experiment_window(AW_root *aw_root, AW_CL cl_gb_main);
215
216#if defined(WARN_TODO)
217#warning move EXP_create_experiment_query_window to SL/DB_UI
218#endif
219
220AW_window *EXP_create_experiment_query_window(AW_root *aw_root, AW_CL cl_gb_main) {
221    static AW_window_simple_menu *aws = 0;
222    if (!aws) {
223        GBDATA *gb_main = (GBDATA*)cl_gb_main;
224
225        aws = new AW_window_simple_menu;
226        aws->init(aw_root, "EXPERIMENT_QUERY", "Experiment SEARCH and QUERY");
227        aws->create_menu("More functions", "f");
228        aws->load_xfig("ad_query.fig");
229
230        QUERY::query_spec awtqs(EXP_get_selector());
231
232        awtqs.gb_main             = gb_main;
233        awtqs.species_name        = AWAR_SPECIES_NAME;
234        awtqs.tree_name           = AWAR_TREE;
235        awtqs.select_bit          = 1;
236        awtqs.use_menu            = 1;
237        awtqs.ere_pos_fig         = "ere3";
238        awtqs.where_pos_fig       = "where3";
239        awtqs.by_pos_fig          = "by3";
240        awtqs.qbox_pos_fig        = "qbox";
241        awtqs.rescan_pos_fig      = 0;
242        awtqs.key_pos_fig         = 0;
243        awtqs.query_pos_fig       = "content";
244        awtqs.result_pos_fig      = "result";
245        awtqs.count_pos_fig       = "count";
246        awtqs.do_query_pos_fig    = "doquery";
247        awtqs.config_pos_fig      = "doconfig";
248        awtqs.do_mark_pos_fig     = "domark";
249        awtqs.do_unmark_pos_fig   = "dounmark";
250        awtqs.do_delete_pos_fig   = "dodelete";
251        awtqs.do_set_pos_fig      = "doset";
252        awtqs.do_refresh_pos_fig  = "dorefresh";
253        awtqs.open_parser_pos_fig = "openparser";
254        awtqs.create_view_window  = EXP_create_experiment_window;
255
256        QUERY::DbQuery *query   = create_query_box(aws, &awtqs, "exp");
257        GLOBAL_experiment_query = query;
258
259        aws->create_menu("More search",     "s");
260        aws->insert_menu_topic("exp_search_equal_fields_within_db", "Search For Equal Fields and Mark Duplicates",              "E", "search_duplicates.hlp", AWM_ALL, (AW_CB)QUERY::search_duplicated_field_content, (AW_CL)query, 0);
261        aws->insert_menu_topic("exp_search_equal_words_within_db", "Search For Equal Words Between Fields and Mark Duplicates", "W", "search_duplicates.hlp", AWM_ALL, (AW_CB)QUERY::search_duplicated_field_content, (AW_CL)query, 1);
262
263        aws->button_length(7);
264
265        aws->at("close");
266        aws->callback((AW_CB0)AW_POPDOWN);
267        aws->create_button("CLOSE", "CLOSE", "C");
268        aws->at("help");
269        aws->callback(AW_POPUP_HELP, (AW_CL)"experiment_search.hlp");
270        aws->create_button("HELP", "HELP", "H");
271    }
272    return aws;
273}
274
275static void experiment_delete_cb(AW_window *aww, AW_CL cl_gb_main) {
276    if (aw_ask_sure("experiment_delete", "Are you sure to delete the experiment")) {
277        GBDATA         *gb_main       = (GBDATA*)cl_gb_main;
278        GB_transaction  ta(gb_main);
279        GB_ERROR        error         = 0;
280        GBDATA         *gb_experiment = EXP_get_current_experiment(gb_main, aww->get_root());
281
282        error = gb_experiment ? GB_delete(gb_experiment) : "Please select a experiment first";
283        if (error) {
284            error = ta.close(error);
285            aw_message(error);
286        }
287    }
288}
289
290static void experiment_create_cb(AW_window *aww, AW_CL cl_gb_main) {
291    AW_root  *aw_root = aww->get_root();
292    char     *dest    = aw_root->awar(AWAR_EXPERIMENT_DEST)->read_string();
293    GBDATA   *gb_main = (GBDATA*)cl_gb_main;
294    GB_ERROR  error   = GB_begin_transaction(gb_main);
295
296    if (!error) {
297        GBDATA *gb_experiment_data = EXP_get_current_experiment_data(gb_main, aw_root);
298
299        if (!gb_experiment_data) {
300            error = "Please select an organism";
301        }
302        else {
303            GBDATA *gb_dest = EXP_find_experiment_rel_exp_data(gb_experiment_data, dest);
304
305            if (gb_dest) {
306                error  = GBS_global_string("Experiment '%s' already exists", dest);
307            }
308            else {
309                gb_dest             = EXP_find_or_create_experiment_rel_exp_data(gb_experiment_data, dest);
310                if (!gb_dest) error = GB_await_error();
311                else aww->get_root()->awar(AWAR_EXPERIMENT_NAME)->write_string(dest);
312            }
313        }
314    }
315
316    GB_end_transaction_show_error(gb_main, error, aw_message);
317    free(dest);
318}
319
320static void experiment_rename_cb(AW_window *aww, AW_CL cl_gb_main) {
321    AW_root *aw_root = aww->get_root();
322    char    *source  = aw_root->awar(AWAR_EXPERIMENT_NAME)->read_string();
323    char    *dest    = aw_root->awar(AWAR_EXPERIMENT_DEST)->read_string();
324
325    if (strcmp(source, dest) != 0) {
326        GBDATA   *gb_main = (GBDATA*)cl_gb_main;
327        GB_ERROR  error   = GB_begin_transaction(gb_main);
328
329        if (!error) {
330            GBDATA *gb_experiment_data = EXP_get_current_experiment_data(gb_main, aww->get_root());
331
332            if (!gb_experiment_data) error = "Please select a species first";
333            else {
334                GBDATA *gb_source = EXP_find_experiment_rel_exp_data(gb_experiment_data, source);
335                GBDATA *gb_dest   = EXP_find_experiment_rel_exp_data(gb_experiment_data, dest);
336
337                if (!gb_source) error   = "Please select an experiment";
338                else if (gb_dest) error = GB_export_errorf("Experiment '%s' already exists", dest);
339                else {
340                    GBDATA *gb_name     = GB_search(gb_source, "name", GB_STRING);
341                    if (!gb_name) error = GB_await_error();
342                    else {
343                        error = GB_write_string(gb_name, dest);
344                        if (!error) aww->get_root()->awar(AWAR_EXPERIMENT_NAME)->write_string(dest);
345                    }
346                }
347            }
348        }
349        error = GB_end_transaction(gb_main, error);
350        aww->hide_or_notify(error);
351    }
352
353    free(source);
354    free(dest);
355}
356
357static void experiment_copy_cb(AW_window *aww, AW_CL cl_gb_main) {
358    char     *source  = aww->get_root()->awar(AWAR_EXPERIMENT_NAME)->read_string();
359    char     *dest    = aww->get_root()->awar(AWAR_EXPERIMENT_DEST)->read_string();
360    GBDATA   *gb_main = (GBDATA*)cl_gb_main;
361    GB_ERROR  error   = GB_begin_transaction(gb_main);
362
363    if (!error) {
364        GBDATA *gb_experiment_data = EXP_get_current_experiment_data(gb_main, aww->get_root());
365
366        if (!gb_experiment_data) {
367            error = "Please select a species first.";
368        }
369        else {
370            GBDATA *gb_source = EXP_find_experiment_rel_exp_data(gb_experiment_data, source);
371            GBDATA *gb_dest   = EXP_find_experiment_rel_exp_data(gb_experiment_data, dest);
372
373            if (!gb_source) error   = "Please select a experiment";
374            else if (gb_dest) error = GB_export_errorf("Experiment '%s' already exists", dest);
375            else {
376                gb_dest             = GB_create_container(gb_experiment_data, "experiment");
377                if (!gb_dest) error = GB_await_error();
378                else error          = GB_copy(gb_dest, gb_source);
379
380                if (!error) {
381                    error = GBT_write_string(gb_dest, "name", dest);
382                    if (!error) aww->get_root()->awar(AWAR_EXPERIMENT_NAME)->write_string(dest);
383                }
384            }
385        }
386    }
387
388    error = GB_end_transaction(gb_main, error);
389    aww->hide_or_notify(error);
390
391    free(source);
392    free(dest);
393}
394
395static AW_window *create_experiment_rename_window(AW_root *root, AW_CL cl_gb_main) {
396    AW_window_simple *aws = new AW_window_simple;
397    aws->init(root, "RENAME_EXPERIMENT", "EXPERIMENT RENAME");
398    aws->load_xfig("ad_al_si.fig");
399
400    aws->callback((AW_CB0)AW_POPDOWN);
401    aws->at("close");
402    aws->create_button("CLOSE", "CLOSE", "C");
403
404    aws->at("label");
405    aws->create_autosize_button(0, "Please enter the new name\nof the experiment");
406
407    aws->at("input");
408    aws->create_input_field(AWAR_EXPERIMENT_DEST, 15);
409    aws->at("ok");
410    aws->callback(experiment_rename_cb, cl_gb_main);
411    aws->create_button("GO", "GO", "G");
412
413    return (AW_window *)aws;
414}
415
416static AW_window *create_experiment_copy_window(AW_root *root, AW_CL cl_gb_main) {
417    AW_window_simple *aws = new AW_window_simple;
418    aws->init(root, "COPY_EXPERIMENT", "EXPERIMENT COPY");
419    aws->load_xfig("ad_al_si.fig");
420
421    aws->callback((AW_CB0)AW_POPDOWN);
422    aws->at("close");
423    aws->create_button("CLOSE", "CLOSE", "C");
424
425    aws->at("label");
426    aws->create_autosize_button(0, "Please enter the name\nof the new experiment");
427
428    aws->at("input");
429    aws->create_input_field(AWAR_EXPERIMENT_DEST, 15);
430
431    aws->at("ok");
432    aws->callback(experiment_copy_cb, cl_gb_main);
433    aws->create_button("GO", "GO", "G");
434
435    return (AW_window *)aws;
436}
437
438static AW_window *create_experiment_create_window(AW_root *root, AW_CL cl_gb_main) {
439    AW_window_simple *aws = new AW_window_simple;
440    aws->init(root, "CREATE_EXPERIMENT", "EXPERIMENT CREATE");
441    aws->load_xfig("ad_al_si.fig");
442
443    aws->callback((AW_CB0)AW_POPDOWN);
444    aws->at("close");
445    aws->create_button("CLOSE", "CLOSE", "C");
446
447    aws->at("label"); aws->create_autosize_button(0, "Please enter the name\nof the new experiment");
448    aws->at("input"); aws->create_input_field(AWAR_EXPERIMENT_DEST, 15);
449
450    aws->at("ok");
451    aws->callback(experiment_create_cb, cl_gb_main);
452    aws->create_button("GO", "GO", "G");
453
454    return aws;
455}
456
457static void EXP_map_experiment(AW_root *aw_root, AW_CL cl_scanner, AW_CL cl_gb_main) {
458    GBDATA         *gb_main       = (GBDATA*)cl_gb_main;
459    GB_transaction  ta(gb_main);
460    GBDATA         *gb_experiment = EXP_get_current_experiment(gb_main, aw_root);
461
462    if (gb_experiment) map_db_scanner((DbScanner*)cl_scanner, gb_experiment, CHANGE_KEY_PATH_EXPERIMENTS);
463}
464
465static void EXP_create_field_items(AW_window *aws, GBDATA *gb_main) {
466    static BoundItemSel *bis = new BoundItemSel(gb_main, EXP_get_selector());
467    exp_assert(bis->gb_main == gb_main);
468
469    aws->insert_menu_topic("exp_reorder_fields", "Reorder fields ...",    "R", "spaf_reorder.hlp", AD_F_ALL, AW_POPUP, (AW_CL)DBUI::create_fields_reorder_window, (AW_CL)bis);
470    aws->insert_menu_topic("exp_delete_field",   "Delete/Hide Field ...", "D", "spaf_delete.hlp",  AD_F_ALL, AW_POPUP, (AW_CL)DBUI::create_field_delete_window, (AW_CL)bis);
471    aws->insert_menu_topic("exp_create_field",   "Create fields ...",     "C", "spaf_create.hlp",  AD_F_ALL, AW_POPUP, (AW_CL)DBUI::create_field_create_window, (AW_CL)bis);
472    aws->sep______________();
473    aws->insert_menu_topic("exp_unhide_fields", "Show all hidden fields", "S", "scandb.hlp", AD_F_ALL, (AW_CB)experiment_field_selection_list_unhide_all_cb, (AW_CL)gb_main, FIELD_FILTER_NDS);
474    aws->sep______________();
475    aws->insert_menu_topic("exp_scan_unknown_fields", "Scan unknown fields",   "u", "scandb.hlp", AD_F_ALL, (AW_CB)experiment_field_selection_list_scan_unknown_cb,  (AW_CL)gb_main, FIELD_FILTER_NDS);
476    aws->insert_menu_topic("exp_del_unused_fields",   "Remove unused fields",  "e", "scandb.hlp", AD_F_ALL, (AW_CB)experiment_field_selection_list_delete_unused_cb, (AW_CL)gb_main, FIELD_FILTER_NDS);
477    aws->insert_menu_topic("exp_refresh_fields",      "Refresh fields (both)", "f", "scandb.hlp", AD_F_ALL, (AW_CB)experiment_field_selection_list_update_cb,        (AW_CL)gb_main, FIELD_FILTER_NDS);
478}
479
480#if defined(WARN_TODO)
481#warning move EXP_create_experiment_window to SL/DB_UI
482#endif
483
484
485static AW_window *EXP_create_experiment_window(AW_root *aw_root, AW_CL cl_gb_main) {
486    static AW_window_simple_menu *aws = 0;
487
488    if (!aws) {
489        GBDATA *gb_main = (GBDATA*)cl_gb_main;
490
491        aws = new AW_window_simple_menu;
492        aws->init(aw_root, "EXPERIMENT_INFORMATION", "EXPERIMENT INFORMATION");
493        aws->load_xfig("ad_spec.fig");
494
495        aws->button_length(8);
496
497        aws->at("close");
498        aws->callback((AW_CB0)AW_POPDOWN);
499        aws->create_button("CLOSE", "CLOSE", "C");
500
501        aws->at("search");
502        aws->callback(AW_POPUP, (AW_CL)EXP_create_experiment_query_window, (AW_CL)gb_main);
503        aws->create_button("SEARCH", "SEARCH", "S");
504
505        aws->at("help");
506        aws->callback(AW_POPUP_HELP, (AW_CL)"experiment_info.hlp");
507        aws->create_button("HELP", "HELP", "H");
508
509
510        DbScanner *scanner = create_db_scanner(gb_main, aws, "box", 0, "field", "enable", DB_VIEWER, 0, "mark", FIELD_FILTER_NDS, EXP_get_selector());
511
512        aws->create_menu("EXPERIMENT", "E", AD_F_ALL);
513        aws->insert_menu_topic("experiment_delete", "Delete",     "D", "spa_delete.hlp", AD_F_ALL, (AW_CB)experiment_delete_cb, (AW_CL)gb_main,                         0);
514        aws->insert_menu_topic("experiment_rename", "Rename ...", "R", "spa_rename.hlp", AD_F_ALL, AW_POPUP,                    (AW_CL)create_experiment_rename_window, (AW_CL)gb_main);
515        aws->insert_menu_topic("experiment_copy",   "Copy ...",   "y", "spa_copy.hlp",   AD_F_ALL, AW_POPUP,                    (AW_CL)create_experiment_copy_window,   (AW_CL)gb_main);
516        aws->insert_menu_topic("experiment_create", "Create ...", "C", "spa_create.hlp", AD_F_ALL, AW_POPUP,                    (AW_CL)create_experiment_create_window, (AW_CL)gb_main);
517        aws->sep______________();
518
519        aws->create_menu("FIELDS", "F", AD_F_ALL);
520        EXP_create_field_items(aws, gb_main);
521
522        {
523            Awar_Callback_Info    *cb_info     = new Awar_Callback_Info(aws->get_root(), AWAR_EXPERIMENT_NAME, EXP_map_experiment, (AW_CL)scanner, (AW_CL)gb_main); // do not delete!
524            AW_detach_information *detach_info = new AW_detach_information(cb_info); // do not delete!
525            cb_info->add_callback();
526
527            aws->at("detach");
528            aws->callback(DBUI::detach_info_window, (AW_CL)&aws, (AW_CL)cb_info);
529            aws->create_button("DETACH", "DETACH", "D");
530
531            detach_info->set_detach_button(aws->get_last_widget());
532        }
533
534        aws->show();
535        EXP_map_experiment(aws->get_root(), (AW_CL)scanner, (AW_CL)gb_main);
536    }
537    return aws;
538}
539
540void EXP_popup_experiment_window(AW_window *aww, AW_CL cl_gb_main, AW_CL) {
541    AW_window *aws = EXP_create_experiment_window(aww->get_root(), cl_gb_main);
542    aws->activate();
543}
544
Note: See TracBrowser for help on using the repository browser.