root/trunk/AWT/AWT_tables.cxx

Revision 8309, 19.3 KB (checked in by westram, 5 months ago)
  • moved much code into static scope
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1// ================================================================ //
2//                                                                  //
3//   File      : AWT_tables.cxx                                     //
4//   Purpose   :                                                    //
5//                                                                  //
6//   Institute of Microbiology (Technical University Munich)        //
7//   http://www.arb-home.de/                                        //
8//                                                                  //
9// ================================================================ //
10
11#include "awt.hxx"
12#include "awtlocal.hxx"
13#include "awt_sel_boxes.hxx"
14
15#include <aw_window.hxx>
16#include <aw_awar.hxx>
17#include <aw_file.hxx>
18#include <aw_msg.hxx>
19#include <aw_root.hxx>
20
21#include <arbdbt.h>
22
23static void ad_table_field_reorder_cb(AW_window *aws, awt_table *awtt) {
24    char *source = aws->get_root()->awar(awtt->awar_field_reorder_source)->read_string();
25    char *dest   = aws->get_root()->awar(awtt->awar_field_reorder_dest)  ->read_string();
26
27    GB_ERROR  error    = GB_begin_transaction(awtt->gb_main);
28    GBDATA   *gb_table = NULL;
29   
30    if (!error) {
31        gb_table = GBT_open_table(awtt->gb_main, awtt->table_name, true);
32        if (!gb_table) error = GBS_global_string("Table '%s' does not exist", awtt->table_name);
33    }
34
35    if (!error) {
36        GBDATA *gb_source = GBT_find_table_field(gb_table, source);
37        GBDATA *gb_dest   = GBT_find_table_field(gb_table, dest);
38
39        if (!gb_source || !gb_dest) error    = "Please select two valid fields";
40        else if (gb_dest == gb_source) error = "Please select two different fields";
41        else {
42            GBDATA *gb_fields = GB_get_father(gb_source);
43            int     nitems    = 0;
44
45            for (GBDATA *gb_cnt=GB_child(gb_fields); gb_cnt; gb_cnt = GB_nextChild(gb_cnt)) {
46                nitems++;
47            }
48
49            GBDATA **new_order = new GBDATA *[nitems];
50            nitems             = 0;
51            for (GBDATA *gb_cnt=GB_child(gb_fields); gb_cnt; gb_cnt = GB_nextChild(gb_cnt)) {
52                if (gb_cnt != gb_source) {
53                    new_order[nitems++] = gb_cnt;
54                    if (gb_cnt == gb_dest) {
55                        new_order[nitems++] = gb_source;
56                    }
57                }
58            }
59            GB_ERROR warning = GB_resort_data_base(awtt->gb_main, new_order, nitems);
60            if (warning) aw_message(warning);
61
62            delete [] new_order;
63        }
64    }
65
66    GB_end_transaction_show_error(awtt->gb_main, error, aw_message);
67
68    free(dest);
69    free(source);
70}
71
72static AW_window *create_ad_table_field_reorder_window(AW_root *root, awt_table *awtt)
73{
74    AW_window_simple *aws = new AW_window_simple;
75    aws->init(root, "REORDER_FIELDS", "REORDER FIELDS");
76    aws->load_xfig("ad_kreo.fig");
77
78    aws->callback((AW_CB0)AW_POPDOWN);
79    aws->at("close");
80    aws->create_button("CLOSE", "CLOSE", "C");
81
82    aws->callback(AW_POPUP_HELP, (AW_CL)"spaf_reorder.hlp");
83    aws->at("help");
84    aws->create_button("HELP", "HELP", "H");
85
86    aws->at("doit");
87    aws->button_length(0);
88    aws->callback((AW_CB1)ad_table_field_reorder_cb, (AW_CL)awtt);
89    aws->help_text("spaf_reorder.hlp");
90    aws->create_button("MOVE_TO_NEW_POSITION", "MOVE  SELECTED LEFT  ITEM\nAFTER SELECTED RIGHT ITEM", "P");
91
92    aws->at("source");
93    awt_create_selection_list_on_table_fields(awtt->gb_main, aws, awtt->table_name, awtt->awar_field_reorder_source);
94
95    aws->at("dest");
96    awt_create_selection_list_on_table_fields(awtt->gb_main, aws, awtt->table_name, awtt->awar_field_reorder_dest);
97
98    return (AW_window *)aws;
99}
100
101static void awt_table_field_hide_cb(AW_window *aws, awt_table *awtt) {
102    GB_begin_transaction(awtt->gb_main);
103    GB_ERROR  error    = 0;
104    GBDATA   *gb_table = GBT_open_table(awtt->gb_main, awtt->table_name, true);
105
106    if (!gb_table) {
107        error = GBS_global_string("Table '%s' does not exist", awtt->table_name);
108    }
109    else {
110        char   *source    = aws->get_root()->awar(awtt->awar_selected_field)->read_string();
111        GBDATA *gb_source = GBT_find_table_field(gb_table, source);
112
113        if (!gb_source) error = "Please select an item you want to delete";
114        else error            = GB_delete(gb_source);
115
116        free(source);
117    }
118    GB_end_transaction_show_error(awtt->gb_main, error, aw_message);
119}
120
121static void awt_table_field_delete_cb(AW_window *aws, awt_table *awtt) {
122    GB_begin_transaction(awtt->gb_main);
123
124    GB_ERROR  error    = 0;
125    GBDATA   *gb_table = GBT_open_table(awtt->gb_main, awtt->table_name, true);
126    if (!gb_table) {
127        error = GBS_global_string("Table '%s' does not exist", awtt->table_name);
128    }
129    else {
130        char   *source    = aws->get_root()->awar(awtt->awar_selected_field)->read_string();
131        GBDATA *gb_source = GBT_find_table_field(gb_table, source);
132
133        if (!gb_source) error = "Please select an item you want to delete";
134        else error            = GB_delete(gb_source);
135
136        for (GBDATA *gb_table_entry = GBT_first_table_entry(gb_table);
137             gb_table_entry && !error;
138             gb_table_entry = GBT_next_table_entry(gb_table_entry))
139        {
140            GBDATA *gb_table_entry_field;
141            while (!error && (gb_table_entry_field = GB_search(gb_table_entry, source, GB_FIND))) {
142                error = GB_delete(gb_table_entry_field);
143            }
144        }
145        free(source);
146    }
147
148    GB_end_transaction_show_error(awtt->gb_main, error, aw_message);
149}
150
151
152static void ad_table_field_create_cb(AW_window *aws, awt_table *awtt) {
153    GB_push_transaction(awtt->gb_main);
154    char *name = aws->get_root()->awar(awtt->awar_field_new_name)->read_string();
155    GB_ERROR error = GB_check_key(name);
156    GB_ERROR error2 = GB_check_hkey(name);
157    if (error && !error2) {
158        aw_message("Warning: Your key contain a '/' character,\n"
159                   "    that means it is a hierarchical key");
160        error = 0;
161    }
162    GBDATA *gb_table = GBT_open_table(awtt->gb_main, awtt->table_name, true);
163    if (gb_table) {
164        GB_TYPES type = (GB_TYPES)aws->get_root()->awar(awtt->awar_field_new_type)->read_int();
165        if (!error) {
166            GBDATA *gb_table_field = GBT_open_table_field(gb_table, name, type);
167            if (!gb_table_field) error = GB_await_error();
168        }
169    }
170    else {
171        error = GBS_global_string("Table '%s' does not exist", awtt->table_name);
172    }
173    aws->hide_or_notify(error);
174
175    free(name);
176    GB_pop_transaction(awtt->gb_main);
177}
178
179static AW_window *create_ad_table_field_create_window(AW_root *root, awt_table *awtt) {
180    static AW_window_simple *aws = new AW_window_simple;
181    aws->init(root, "CREATE_FIELD", "CREATE A NEW FIELD");
182    aws->load_xfig("ad_fcrea.fig");
183
184    aws->callback((AW_CB0)AW_POPDOWN);
185    aws->at("close");
186    aws->create_button("CLOSE", "CLOSE", "C");
187
188
189    aws->at("input");
190    aws->label("FIELD NAME");
191    aws->create_input_field(awtt->awar_field_new_name, 15);
192
193    aws->at("type");
194    aws->create_toggle_field(awtt->awar_field_new_type, "FIELD TYPE", "F");
195    aws->insert_toggle("Ascii Text", "S",       (int)GB_STRING);
196    aws->insert_toggle("Link", "L",         (int)GB_LINK);
197    aws->insert_toggle("Rounded Numerical", "N", (int)GB_INT);
198    aws->insert_toggle("Numerical", "R",    (int)GB_FLOAT);
199    aws->insert_toggle("MASK = 01 Text", "0",   (int)GB_BITS);
200    aws->update_toggle_field();
201
202
203    aws->at("ok");
204    aws->callback((AW_CB1)ad_table_field_create_cb, (AW_CL)awtt);
205    aws->create_button("CREATE", "CREATE", "C");
206
207    return (AW_window *)aws;
208}
209
210awt_table::awt_table(GBDATA *igb_main, AW_root *awr, const char *itable_name) {
211    gb_main    = igb_main;
212    GB_transaction tscope(gb_main);
213    table_name = strdup(itable_name);
214
215    char *tname = GBS_string_2_key(table_name);
216   
217    awar_field_reorder_source = GBS_global_string_copy(AWAR_TABLE_FIELD_REORDER_SOURCE_TEMPLATE, tname);
218    awar_field_reorder_dest   = GBS_global_string_copy(AWAR_TABLE_FIELD_REORDER_DEST_TEMPLATE, tname);
219    awar_field_rem            = GBS_global_string_copy(AWAR_TABLE_FIELD_REM_TEMPLATE, tname);
220    awar_field_new_name       = GBS_global_string_copy(AWAR_TABLE_FIELD_NEW_NAME_TEMPLATE, tname);
221    awar_field_new_type       = GBS_global_string_copy(AWAR_TABLE_FIELD_NEW_TYPE_TEMPLATE, tname);
222    awar_selected_field       = GBS_global_string_copy(AWAR_TABLE_SELECTED_FIELD_TEMPLATE, tname);
223
224    awr->awar_string(awar_field_reorder_source, "");
225    awr->awar_string(awar_field_reorder_dest, "");
226    awr->awar_string(awar_field_new_name, "");
227    awr->awar_int(awar_field_new_type, GB_STRING);
228    awr->awar_string(awar_field_rem, "No comment");
229    awr->awar_string(awar_selected_field, "");
230
231    free(tname);
232}
233
234awt_table::~awt_table() {
235    free(table_name);
236    free(awar_field_reorder_source);
237    free(awar_field_reorder_dest);
238    free(awar_field_new_name);
239    free(awar_field_rem);
240    free(awar_selected_field);
241}
242
243static void   awt_map_table_field_rem(AW_root *aw_root, awt_table *awtt) {
244    GB_transaction tscope(awtt->gb_main);
245    GBDATA *gb_table = GBT_open_table(awtt->gb_main, awtt->table_name, true);
246    if (!gb_table) {
247        aw_root->awar(awtt->awar_field_rem)->unmap();
248        return;
249    }
250    char *field_name  = aw_root->awar(awtt->awar_selected_field)->read_string();
251    GBDATA *gb_table_field = GBT_find_table_field(gb_table, field_name);
252    if (!gb_table_field) {
253        delete field_name;
254        aw_root->awar(awtt->awar_field_rem)->unmap();
255        return;
256    }
257    GBDATA *gb_desc = GB_search(gb_table_field, "description", GB_STRING);
258    aw_root->awar(awtt->awar_field_rem)->map(gb_desc);
259}
260
261static void create_ad_table_field_admin(AW_window *aww, GBDATA *gb_main, const char *tname) {
262    static GB_HASH *table_to_win_hash = GBS_create_hash(256, GB_MIND_CASE);
263    AW_root        *aw_root           = aww->get_root();
264    char           *table_name;
265    if (tname) {
266        table_name = strdup(tname);
267    }
268    else {
269        table_name = aw_root->awar(AWAR_TABLE_NAME)->read_string();
270    }
271
272    AW_window_simple *aws = (AW_window_simple *)GBS_read_hash(table_to_win_hash, table_name);
273    if (!aws) {
274        awt_table *awtt = new awt_table(gb_main, aw_root, table_name);
275        aws = new AW_window_simple;
276        const char *table_header = GBS_global_string("TABLE_ADMIN_%s", table_name);
277        aws->init(aw_root, table_header, table_header);
278
279        aws->load_xfig("ad_table_fields.fig");
280
281        aws->callback(AW_POPDOWN);
282        aws->at("close");
283        aws->create_button("CLOSE", "CLOSE", "C");
284
285        aws->callback(AW_POPUP_HELP, (AW_CL)"tableadm.hlp");
286        aws->at("help");
287        aws->create_button("HELP", "HELP", "H");
288
289        aws->at("table_name");
290        aws->create_button(table_name, table_name, "A");
291
292        aws->button_length(13);
293
294        aws->at("delete");
295        aws->callback((AW_CB1)awt_table_field_delete_cb, (AW_CL)awtt);
296        aws->create_button("DELETE", "DELETE", "D");
297
298        aws->at("hide");
299        aws->callback((AW_CB1)awt_table_field_hide_cb, (AW_CL)awtt);
300        aws->create_button("HIDE", "HIDE", "D");
301
302        aws->at("create");
303        aws->callback(AW_POPUP, (AW_CL)create_ad_table_field_create_window, (AW_CL)awtt);
304        aws->create_button("CREATE", "CREATE", "C");
305
306        aws->at("reorder");
307        aws->callback(AW_POPUP, (AW_CL)create_ad_table_field_reorder_window, (AW_CL)awtt);
308        aws->create_button("REORDER", "REORDER", "R");
309
310        aws->at("list");
311        awt_create_selection_list_on_table_fields(gb_main, (AW_window *)aws, table_name, awtt->awar_selected_field);
312
313        aws->at("rem");
314        aws->create_text_field(awtt->awar_field_rem);
315
316        awt_map_table_field_rem(aw_root, awtt);
317        aw_root->awar(awtt->awar_selected_field)->add_callback((AW_RCB1)awt_map_table_field_rem, (AW_CL)awtt);
318    }
319
320    aws->activate();
321    free(table_name);
322}
323
324// --------------------
325//      table admin
326
327
328// #define AWAR_TABLE_IMPORT "tmp/ad_table/import_table"
329
330static void table_vars_callback(AW_root *aw_root, GBDATA *gb_main)     // Map table vars to display objects
331{
332    GB_push_transaction(gb_main);
333    char *tablename = aw_root->awar(AWAR_TABLE_NAME)->read_string();
334    GBDATA *gb_table = GBT_open_table(gb_main, tablename, true);
335    if (!gb_table) {
336        aw_root->awar(AWAR_TABLE_REM)->unmap();
337    }
338    else {
339        GBDATA *table_rem = GB_search(gb_table, "description",  GB_STRING);
340        aw_root->awar(AWAR_TABLE_REM)->map(table_rem);
341    }
342    char *fname = GBS_string_eval(tablename, "*=*1.table:table_*=*1", 0);
343    aw_root->awar(AWAR_TABLE_EXPORT "/file_name")->write_string(fname); // create default file name
344    delete fname;
345    GB_pop_transaction(gb_main);
346    free(tablename);
347}
348
349
350
351static void table_rename_cb(AW_window *aww, GBDATA *gb_main) {
352    GB_ERROR  error  = 0;
353    char     *source = aww->get_root()->awar(AWAR_TABLE_NAME)->read_string();
354    char     *dest   = aww->get_root()->awar(AWAR_TABLE_DEST)->read_string();
355
356    GB_begin_transaction(gb_main);
357    GBDATA *gb_table_dest = GBT_open_table(gb_main, dest, true);
358    if (gb_table_dest) {
359        error = "Table already exists";
360    }
361    else {
362        GBDATA *gb_table = GBT_open_table(gb_main, source, true);
363        if (gb_table) {
364            GBDATA *gb_name = GB_search(gb_table, "name", GB_STRING);
365
366            if (!gb_name) error = GB_await_error();
367            else error          = GB_write_string(gb_name, dest);
368        }
369    }
370    GB_end_transaction_show_error(gb_main, error, aw_message);
371
372    free(source);
373    free(dest);
374}
375
376static void table_copy_cb(AW_window *aww, GBDATA *gb_main) {
377    GB_ERROR  error  = 0;
378    char     *source = aww->get_root()->awar(AWAR_TABLE_NAME)->read_string();
379    char     *dest   = aww->get_root()->awar(AWAR_TABLE_DEST)->read_string();
380
381    GB_begin_transaction(gb_main);
382    GBDATA *gb_table_dest = GBT_open_table(gb_main, dest, true);
383    if (gb_table_dest) {
384        error = "Table already exists";
385    }
386    else {
387        GBDATA *gb_table = GBT_open_table(gb_main, source, true);
388        if (gb_table) {
389            GBDATA *gb_table_data = GB_entry(gb_main, "table_data");
390            gb_table_dest = GB_create_container(gb_table_data, "table");
391            error = GB_copy(gb_table_dest, gb_table);
392            if (!error) {
393                GBDATA *gb_name = GB_search(gb_table_dest, "name", GB_STRING);
394                error = GB_write_string(gb_name, dest);
395            }
396        }
397    }
398    GB_end_transaction_show_error(gb_main, error, aw_message);
399
400    free(source);
401    free(dest);
402}
403static void table_create_cb(AW_window *aww, GBDATA *gb_main) {
404    char     *dest  = aww->get_root()->awar(AWAR_TABLE_DEST)->read_string();
405    GB_ERROR  error = GB_begin_transaction(gb_main);
406    if (!error) {
407        error = GB_check_key(dest);
408        if (!error) {
409            GBDATA *gb_table     = GBT_open_table(gb_main, dest, false);
410            if (!gb_table) error = GB_await_error();
411        }
412    }
413    error = GB_end_transaction(gb_main, error);
414    aww->hide_or_notify(error);
415    free(dest);
416}
417
418static AW_window *create_table_rename_window(AW_root *root, GBDATA *gb_main)
419{
420    AW_window_simple *aws = new AW_window_simple;
421    aws->init(root, "RENAME_TABLE", "TABLE RENAME");
422    aws->load_xfig("ad_al_si.fig");
423
424    aws->callback((AW_CB0)AW_POPDOWN);
425    aws->at("close");
426    aws->create_button("CLOSE", "CLOSE", "C");
427
428    aws->at("label");
429    aws->create_autosize_button(0, "Please enter the new name\nof the table");
430
431    aws->at("input");
432    aws->create_input_field(AWAR_TABLE_DEST, 15);
433
434    aws->at("ok");
435    aws->callback((AW_CB1)table_rename_cb, (AW_CL)gb_main);
436    aws->create_button("GO", "GO", "G");
437
438    return (AW_window *)aws;
439}
440
441static AW_window *create_table_copy_window(AW_root *root, GBDATA *gb_main)
442{
443    AW_window_simple *aws = new AW_window_simple;
444    aws->init(root, "COPY_TABLE", "TABLE COPY");
445    aws->load_xfig("ad_al_si.fig");
446
447    aws->callback((AW_CB0)AW_POPDOWN);
448    aws->at("close");
449    aws->create_button("CLOSE", "CLOSE", "C");
450
451    aws->at("label");
452    aws->create_autosize_button(0, "Please enter the name\nof the new table");
453
454    aws->at("input");
455    aws->create_input_field(AWAR_TABLE_DEST, 15);
456
457    aws->at("ok");
458    aws->callback((AW_CB1)table_copy_cb, (AW_CL)gb_main);
459    aws->create_button("GO", "GO", "G");
460
461    return (AW_window *)aws;
462}
463static AW_window *create_table_create_window(AW_root *root, GBDATA *gb_main)
464{
465    AW_window_simple *aws = new AW_window_simple;
466    aws->init(root, "CREATE_TABLE", "TABLE CREATE");
467    aws->load_xfig("ad_al_si.fig");
468
469    aws->callback((AW_CB0)AW_POPDOWN);
470    aws->at("close");
471    aws->create_button("CLOSE", "CLOSE", "C");
472
473    aws->at("label");
474    aws->create_autosize_button(0, "Please enter the name\nof the new table");
475
476    aws->at("input");
477    aws->create_input_field(AWAR_TABLE_DEST, 15);
478
479    aws->at("ok");
480    aws->callback((AW_CB1)table_create_cb, (AW_CL)gb_main);
481    aws->create_button("GO", "GO", "G");
482
483    return (AW_window *)aws;
484}
485static void awt_table_delete_cb(AW_window *aww, GBDATA *gb_main) {
486    GB_ERROR  error  = 0;
487    char     *source = aww->get_root()->awar(AWAR_TABLE_NAME)->read_string();
488
489    GB_begin_transaction(gb_main);
490    GBDATA *gb_table = GBT_open_table(gb_main, source, true);
491    if (gb_table) {
492        error = GB_delete(gb_table);
493    }
494    else {
495        error = "Please select a table first";
496    }
497    GB_end_transaction_show_error(gb_main, error, aw_message);
498
499    free(source);
500}
501
502static void create_tables_var(GBDATA *gb_main, AW_root *aw_root) {
503    aw_root->awar_string(AWAR_TABLE_NAME);
504    aw_root->awar_string(AWAR_TABLE_DEST);
505    aw_root->awar_string(AWAR_TABLE_REM, "no rem");
506
507    AW_create_fileselection_awars(aw_root, AWAR_TABLE_EXPORT, "", "table", "tablefile");
508
509    AW_create_fileselection_awars(aw_root, AWAR_TABLE_IMPORT, "", "table", "tablefile");
510    aw_root->awar_string(AWAR_TABLE_IMPORT "/table_name", "table_");
511
512    aw_root->awar(AWAR_TABLE_NAME)->add_callback((AW_RCB1)table_vars_callback, (AW_CL)gb_main);
513    table_vars_callback(aw_root, gb_main);
514}
515
516AW_window *AWT_create_tables_admin_window(AW_root *aw_root, GBDATA *gb_main)
517{
518    static AW_window_simple *aws = 0;
519
520    if (aws) return aws;
521    GB_transaction tscope(gb_main);
522    create_tables_var(gb_main, aw_root);
523
524    aws = new AW_window_simple;
525    aws->init(aw_root, "TABLE_ADMIN", "TABLE ADMIN");
526    aws->load_xfig("ad_table_admin.fig");
527
528    aws->callback(AW_POPDOWN);
529    aws->at("close");
530    aws->create_button("CLOSE", "CLOSE", "C");
531
532    aws->callback(AW_POPUP_HELP, (AW_CL)"tableadm.hlp");
533    aws->at("help");
534    aws->create_button("HELP", "HELP", "H");
535
536    aws->button_length(13);
537
538    aws->at("delete");
539    aws->callback((AW_CB1)awt_table_delete_cb, (AW_CL)gb_main);
540    aws->create_button("DELETE", "DELETE", "D");
541
542    aws->at("rename");
543    aws->callback(AW_POPUP, (AW_CL)create_table_rename_window, (AW_CL)gb_main);
544    aws->create_button("RENAME", "RENAME", "R");
545
546    aws->at("copy");
547    aws->callback(AW_POPUP, (AW_CL)create_table_copy_window, (AW_CL)gb_main);
548    aws->create_button("COPY", "COPY", "C");
549
550    aws->at("cmp");
551    aws->callback(AW_POPUP, (AW_CL)create_table_create_window, (AW_CL)gb_main);
552    aws->create_button("CREATE", "CREATE", "C");
553
554    aws->at("export");
555    aws->callback((AW_CB)create_ad_table_field_admin, (AW_CL)gb_main, 0);
556    aws->create_button("ADMIN", "ADMIN", "C");
557
558    aws->at("list");
559    awt_create_selection_list_on_tables(gb_main, (AW_window *)aws, AWAR_TABLE_NAME);
560
561    aws->at("rem");
562    aws->create_text_field(AWAR_TABLE_REM);
563
564    return (AW_window *)aws;
565}
Note: See TracBrowser for help on using the browser.