47 #define AWAR_DBB_BASE "/dbbrowser"
48 #define AWAR_DBB_TMP_BASE "/tmp" AWAR_DBB_BASE
50 #define AWAR_DBB_DB AWAR_DBB_BASE "/db"
51 #define AWAR_DBB_ORDER AWAR_DBB_BASE "/order"
52 #define AWAR_DBB_PATH AWAR_DBB_BASE "/path"
53 #define AWAR_DBB_HISTORY AWAR_DBB_BASE "/history"
55 #define AWAR_DBB_BROWSE AWAR_DBB_TMP_BASE "/browse"
56 #define AWAR_DBB_INFO AWAR_DBB_TMP_BASE "/info"
58 #define AWAR_DBB_RECSIZE AWAR_DBB_BASE "/recsize"
60 #define AWAR_DUMP_HEX AWAR_DBB_BASE "/hex"
61 #define AWAR_DUMP_ASCII AWAR_DBB_BASE "/ascii"
62 #define AWAR_DUMP_SPACE AWAR_DBB_BASE "/space"
63 #define AWAR_DUMP_WIDTH AWAR_DBB_BASE "/width"
64 #define AWAR_DUMP_BLOCK AWAR_DBB_BASE "/block"
66 #define HISTORY_PSEUDO_PATH "*history*"
67 #define ENTRY_MAX_LENGTH 1000
68 #define HISTORY_MAX_LENGTH 20000
70 inline bool is_dbbrowser_pseudo_path(
const char *path) {
74 strcmp(path, HISTORY_PSEUDO_PATH) == 0;
88 static const char *sort_order_name[SORT_COUNT] = {
105 static SortOrder sort_order;
107 inline bool less_than_by_name(
const list_entry& other)
const {
109 if (cmp != 0)
return cmp<0;
110 return childCount<other.childCount;
113 inline int cmp_by_container(
const list_entry& other)
const {
return int(type !=
GB_DB) -
int(other.type !=
GB_DB); }
114 inline int cmp_by_childcount(
const list_entry& other)
const {
return childCount - other.childCount; }
116 inline bool less_than_by_container_name(
const list_entry& other)
const {
117 int cmp = cmp_by_container(other);
118 if (cmp == 0)
return less_than_by_name(other);
121 inline bool less_than_by_childcount_name(
const list_entry& other)
const {
122 int cmp = cmp_by_childcount(other);
123 if (cmp == 0)
return less_than_by_name(other);
127 bool operator<(
const list_entry& other)
const {
128 bool is_less =
false;
129 switch (sort_order) {
130 case SORT_COUNT:
break;
136 is_less = less_than_by_name(other);
140 is_less = less_than_by_container_name(other);
144 is_less = less_than_by_childcount_name(other);
148 int cmp =
ARB_stricmp(content.c_str(), other.content.c_str());
150 if (cmp != 0) is_less = cmp<0;
151 else is_less = less_than_by_container_name(other);
156 int cmp = type-other.type;
158 if (cmp == 0) is_less = less_than_by_name(other);
159 else is_less = cmp<0;
168 SortOrder list_entry::sort_order = SORT_NONE;
178 size_t separate = awr->
awar(AWAR_DUMP_BLOCK)->
read_int();
180 bool offset = (hex||ascii) && width;
182 return MemDump(offset, hex, ascii, width, separate, space);
185 static void nodedisplay_changed_cb(
AW_root *aw_root) {
190 aw_root->
awar_int (AWAR_DBB_DB, 0, aw_def);
191 aw_root->
awar_int (AWAR_DBB_ORDER, SORT_CONTAINER, aw_def);
194 aw_root->
awar_string(AWAR_DBB_INFO,
"<select an element>", aw_def);
195 aw_root->
awar_string(AWAR_DBB_HISTORY,
"", aw_def);
210 if (str[0] ==
'/' && str[1] == 0) {
214 const char *first_bracket = strchr(str,
'[');
216 const char *second_bracket = strchr(first_bracket+1,
']');
217 if (second_bracket && (second_bracket[1] == 0 || second_bracket[1] ==
'/')) {
218 int count = atoi(first_bracket+1);
219 if (count >= 0 && isdigit(first_bracket[1])) {
221 const char *previous_slash = first_bracket-1;
222 while (previous_slash >= str && previous_slash[0] !=
'/') previous_slash--;
223 if (previous_slash<str) previous_slash =
NULp;
227 if (previous_slash) {
231 if (parent_path[0] == 0) {
238 if (!gb_parent) fprintf(stderr,
"Warning: parent '%s' not found\n", parent_path);
249 const char *name_start = previous_slash ? previous_slash+1 :
str;
253 gb_son =
GB_entry(gb_parent, key_name);
254 while (c<count && gb_son) {
259 if (!gb_son) fprintf(stderr,
"Warning: did not find %i. son '%s'\n", count, key_name);
264 const char *rest =
NULp;
265 if (second_bracket[1] ==
'/') {
266 if (second_bracket[2]) {
267 rest = second_bracket+2;
272 ? GB_search_numbered(gb_son, rest, create)
277 fprintf(stderr,
"Warning: don't know where to start numbered search in '%s'\n", str);
283 fprintf(stderr,
"Warning: Illegal content in search path - expected digits at '%s'\n", first_bracket+1);
287 fprintf(stderr,
"Warning: Unbalanced or illegal [] in search path (%s)\n", str);
306 KnownDB(
GBDATA *gb_main_,
const char *description_) :
308 description(description_),
313 const string& get_description()
const {
return description; }
315 const string& get_path()
const {
return current_path; }
316 void set_path(
const string& path) { current_path = path; }
317 void set_path(
const char* path) { current_path = path; }
323 explicit hasDB(
GBDATA *gbm) : db(gbm) {}
324 bool operator()(
const KnownDB& kdb) {
return kdb.get_db() == db; }
331 static DB_browser *get_the_browser(
bool autocreate);
334 typedef vector<KnownDB>::iterator KnownDBiterator;
336 vector<KnownDB> known_databases;
344 friend DB_browser *get_the_browser(
bool autocreate);
346 void update_DB_selector();
349 DB_browser() : current_db(0), aww(
NULp), oms(
NULp) {}
352 known_databases.push_back(KnownDB(gb_main, description));
353 if (aww) update_DB_selector();
356 void del_db(
GBDATA *gb_main) {
357 KnownDBiterator known = find_if(known_databases.begin(), known_databases.end(), hasDB(gb_main));
358 if (known != known_databases.end()) known_databases.erase(known);
367 bool legal_selected_db()
const {
return current_db < known_databases.size(); }
369 size_t get_selected_db()
const {
awt_assert(legal_selected_db());
return current_db; }
370 void set_selected_db(
size_t idx) {
awt_assert(idx < known_databases.size()); current_db = idx; }
372 const char *get_path()
const {
return known_databases[get_selected_db()].get_path().c_str(); }
373 void set_path(
const char *new_path) { known_databases[get_selected_db()].set_path(new_path); }
376 return legal_selected_db() ?
const_cast<GBDATA*
>(known_databases[get_selected_db()].get_db()) :
NULp;
386 static DB_browser *get_the_browser(
bool autocreate =
true) {
387 if (DB_browser::the_browser.isNull() && autocreate) {
388 DB_browser::the_browser =
new DB_browser;
390 return &*DB_browser::the_browser;
396 void AWT_announce_db_to_browser(
GBDATA *gb_main,
const char *description) {
397 get_the_browser()->add_db(gb_main, description);
400 static void AWT_announce_properties_to_browser(
GBDATA *gb_defaults,
const char *defaults_name) {
401 AWT_announce_db_to_browser(gb_defaults,
GBS_global_string(
"Properties (%s)", defaults_name));
404 void AWT_browser_forget_db(
GBDATA *gb_main) {
406 DB_browser *browser = get_the_browser(
false);
408 if (browser) browser->del_db(gb_main);
415 static void toggle_tmp_cb(
AW_window *aww) {
421 if (path[4] ==
'/') {
425 else if (path[4] == 0) {
431 if (!done && !is_dbbrowser_pseudo_path(path)) {
434 char *lslash = strrchr(path_in_tmp,
'/');
435 if (lslash && !lslash[1]) {
444 static void show_history_cb(
AW_window *aww) {
448 static void goto_root_cb(
AW_window *aww) {
455 char *lslash = strrchr(path,
'/');
459 if (!path[0]) strcpy(path,
"/");
467 #define BROWSE_CMD_PREFIX "browse_cmd___"
468 #define BROWSE_CMD_GOTO_VALID_NODE BROWSE_CMD_PREFIX "goto_valid_node"
469 #define BROWSE_CMD_GO_UP BROWSE_CMD_PREFIX "go_up"
471 struct BrowserCommand {
485 int len = strlen(path);
486 GBDATA *gb_main = get_the_browser()->get_db();
490 while (len>0 && !GB_search_numbered(gb_main, path,
GB_FIND)) {
501 static BrowserCommand browser_command_table[] = {
502 { BROWSE_CMD_GOTO_VALID_NODE, browse_cmd_goto_valid_node },
503 { BROWSE_CMD_GO_UP, browse_cmd_go_up },
507 static void execute_DB_browser_command(
AW_window *aww,
const char *
command) {
509 for (idx = 0; browser_command_table[idx].name; ++idx) {
510 if (strcmp(command, browser_command_table[idx].name) == 0) {
517 if (!browser_command_table[idx].name) {
526 return get_the_browser()->get_window(aw_root);
531 counterPair() : occur(0), count(0) {}
534 inline void insert_history_selection(
AW_selection_list *sel,
const char *entry,
int wanted_db) {
535 const char *colon = strchr(entry,
':');
536 if (colon && (atoi(entry) == wanted_db)) {
537 sel->
insert(colon+1, colon+1);
542 static char *get_container_description(
GBDATA *gbd) {
543 char *content =
NULp;
544 const char *known_children[] = {
"@name",
"name",
"key_name",
"alignment_name",
"group_name",
"key_text",
NULp };
545 for (
int i = 0; known_children[i]; ++i) {
558 static char *get_dbentry_content(
GBDATA *gbd,
GB_TYPES type,
bool shorten_repeats,
const MemDump& dump) {
561 char *content =
NULp;
569 case GB_INT: size =
sizeof(int32_t);
break;
570 case GB_FLOAT: size =
sizeof(float);
break;
588 content = buf.release();
589 shorten_repeats =
false;
594 if (!dump.
wrapped() && len>(ENTRY_MAX_LENGTH+15)) {
595 content[ENTRY_MAX_LENGTH] = 0;
603 DB_browser *browser = get_the_browser();
609 GBDATA *gb_main = browser->get_db();
612 is_root = (strcmp(path,
"/") == 0);
613 node = GB_search_numbered(gb_main, path,
GB_FIND);
620 if (strcmp(path, HISTORY_PSEUDO_PATH) == 0) {
623 id->insert(
"Previously visited nodes:",
"");
627 for (
char *lf = strchr(start,
'\n'); lf; start = lf+1, lf = strchr(start,
'\n')) {
629 insert_history_selection(
id, start, curr_db);
631 insert_history_selection(
id, start, curr_db);
636 id->insert(
"No such node!",
"");
637 id->insert(
"-> goto valid node", BROWSE_CMD_GOTO_VALID_NODE);
641 map<string, counterPair> child_count;
646 child_count[key_name].occur++;
651 for (map<string, counterPair>::iterator i = child_count.begin(); i != child_count.end(); ++i) {
653 int keylen = i->first.length();
654 int maxcount = i->second.occur;
658 while (maxcount) { maxcount /= 10; keylen++; }
661 if (keylen>maxkeylen) maxkeylen = keylen;
667 int typelen = strlen(type_name);
669 if (typelen>maxtypelen) maxtypelen = typelen;
674 id->insert(
GBS_global_string(
"%-*s parent container", maxkeylen,
".."), BROWSE_CMD_GO_UP);
683 vector<list_entry> sorted_children;
685 MemDump simpleDump(
false,
true,
false);
689 entry.childCount = -1;
693 int occurrences = child_count[entry.key_name].occur;
694 if (occurrences != 1) {
695 entry.childCount = child_count[entry.key_name].count;
696 child_count[entry.key_name].count++;
698 char *display =
NULp;
699 if (entry.type ==
GB_DB) {
700 display = get_container_description(entry.gbd);
703 display = get_dbentry_content(entry.gbd, entry.type,
true, simpleDump);
705 if (display) entry.content = display;
706 sorted_children.push_back(entry);
709 list_entry::sort_order = (SortOrder)aw_root->
awar(AWAR_DBB_ORDER)->
read_int();
710 if (list_entry::sort_order != SORT_NONE) {
711 sort(sorted_children.begin(), sorted_children.end());
714 for (vector<list_entry>::iterator ch = sorted_children.begin(); ch != sorted_children.end(); ++ch) {
715 const list_entry& entry = *ch;
716 const char *key_name = entry.key_name;
717 char *numbered_keyname =
NULp;
719 if (entry.childCount >= 0) {
723 key_name = numbered_keyname ? numbered_keyname : key_name;
725 id->insert(displayed, key_name);
727 free(numbered_keyname);
730 id->insert_default(
"",
"");
737 static void order_changed_cb(
AW_root *aw_root) {
738 DB_browser *browser = get_the_browser();
739 update_browser_selection_list(aw_root, browser->get_browser_list());
742 inline char *strmove(
char *dest,
char *source) {
743 return (
char*)memmove(dest, source, strlen(source)+1);
746 static void add_to_history(
AW_root *aw_root,
const char *path) {
749 if (strcmp(path, HISTORY_PSEUDO_PATH) != 0) {
751 AW_awar *awar_history = aw_root->
awar(AWAR_DBB_HISTORY);
754 int entry_len = strlen(entry);
756 char *found = strstr(old_history, entry);
758 if (found == old_history || found[-1] ==
'\n') {
759 if (found[entry_len] ==
'\n') {
760 strmove(found, found+entry_len+1);
761 found = strstr(old_history, entry);
763 else if (found[entry_len] == 0) {
764 if (found == old_history) {
768 strmove(found, found+entry_len+1);
770 found = strstr(old_history, entry);
773 found = strstr(found+1, entry);
777 found = strstr(found+1, entry);
781 if (old_history[0]) {
784 while (strlen(old_history)>HISTORY_MAX_LENGTH) {
785 char *llf = strrchr(old_history,
'\n');
802 static bool inside_path_change =
false;
805 static void selected_node_modified_cb(
GBDATA *gb_node,
GB_CB_TYPE cb_type) {
809 gb_tracked_node =
NULp;
812 if (!inside_path_change) {
813 static bool avoid_recursion =
false;
814 if (!avoid_recursion) {
821 AW_awar *awar_child = aw_root->
awar(AWAR_DBB_BROWSE);
826 const char *new_path;
828 if (!path[0] || !path[1]) {
847 static void untrack_node() {
848 if (gb_tracked_node) {
850 gb_tracked_node =
NULp;
853 static void track_node(
GBDATA *gb_node) {
860 gb_tracked_node = gb_node;
864 static string get_node_info_string(
AW_root *aw_root,
GBDATA *gb_selected_node,
const char *fullpath) {
868 if (!gb_selected_node) {
869 info +=
"Address | NULp\n";
873 add_to_history(aw_root, fullpath);
879 GB_SizeInfo sizeInfo;
880 bool collect_recursive = aw_root->
awar(AWAR_DBB_RECSIZE)->
read_int();
883 if (collect_recursive || type !=
GB_DB) {
884 sizeInfo.collect(gb_selected_node);
887 string structure_add;
892 if (collect_recursive) {
896 sizeInfo.structure = struct_size;
899 info +=
"Node type | container\n";
902 if (collect_recursive) {
903 childs = childs+
" (rec: " +
GBS_readable_size(sizeInfo.containers,
"containers");
905 childs = childs+
" = " +
GBS_readable_size(sizeInfo.terminals+sizeInfo.containers,
"nodes")+
')';
919 long overall = sizeInfo.mem+sizeInfo.structure;
923 info +=
GBS_global_string(
"Structure | %7s %5.2f%%",
GBS_readable_size(sizeInfo.structure,
"b"),
double(sizeInfo.structure)/overall*100+.0049) + structure_add +
'\n';
926 info +=
GBS_global_string(
"CompRatio | %5.2f%% (mem-only: %5.2f%%)\n",
double(overall)/sizeInfo.data*100+.0049,
double(sizeInfo.mem)/sizeInfo.data*100+.0049);
934 if (is_tmp || not_tmp_but_in_tmp) {
935 info +=
GBS_global_string(
"Temporary | yes%s\n", not_tmp_but_in_tmp ?
" (in temporary branch)" :
"");
940 char *recursed_path =
NULp;
945 info +=
"AWAR | yes\n";
947 gb_recurse_here = awar_this->
gb_var;
949 info = info +
" | mapped to '" + recursed_path +
"' (see below)\n";
964 for (
size_t i = 0; i<callbacks.
size(); ++i) {
965 const char *prefix = i ?
" " :
"Callbacks";
966 info = info + prefix +
" | " + callbacks[i] +
'\n';
969 if (gb_selected_node == gb_tracked_node) {
970 info +=
" | (Note: one callback was installed by this browser)\n";
975 MemDump dump = make_userdefined_MemDump(aw_root);
976 char *content = get_dbentry_content(gb_selected_node,
GB_read_type(gb_selected_node),
false, dump);
978 info = info+
"\nContent:\n"+content+
'\n';
981 info +=
"\nNo content.\n";
986 if (gb_recurse_here) {
989 const bool same_DB = gb_sel_main == gb_sub_main;
993 string subinfo = get_node_info_string(aw_root, gb_recurse_here, recursed_path);
999 "===========================\n"
1000 "Recursive database element:\n"
1002 "===================================================\n"
1003 "Recursive database element (in different database):\n"
1008 freenull(recursed_path);
1014 static void child_changed_cb(
AW_root *aw_root) {
1016 if (strncmp(child, BROWSE_CMD_PREFIX,
sizeof(BROWSE_CMD_PREFIX)-1) == 0) {
1017 execute_DB_browser_command(get_the_browser()->get_window(aw_root), child);
1022 if (strcmp(path, HISTORY_PSEUDO_PATH) == 0) {
1029 static bool avoid_recursion =
false;
1030 if (!avoid_recursion) {
1034 if (strcmp(path,
"/") == 0) {
1037 else if (child[0] == 0) {
1044 DB_browser *browser = get_the_browser();
1045 GBDATA *gb_main = browser->get_db();
1049 GBDATA *gb_selected_node = GB_search_numbered(gb_main, fullpath,
GB_FIND);
1051 string info = get_node_info_string(aw_root, gb_selected_node, fullpath);
1065 static void path_changed_cb(
AW_root *aw_root) {
1066 static bool avoid_recursion =
false;
1067 if (!avoid_recursion) {
1071 DB_browser *browser = get_the_browser();
1072 char *goto_child =
NULp;
1074 GBDATA *gb_main = browser->get_db();
1077 AW_awar *awar_path = aw_root->
awar(AWAR_DBB_PATH);
1082 char *lslash = strrchr(path,
'/');
1085 lslash[lslash == path] = 0;
1092 add_to_history(aw_root, goto_child ?
GBS_global_string(
"%s/%s", path, goto_child) : path);
1094 track_node(father ? father : found);
1096 else if (is_dbbrowser_pseudo_path(path)) {
1102 browser->set_path(path);
1106 update_browser_selection_list(aw_root, browser->get_browser_list());
1113 static void db_changed_cb(
AW_root *aw_root) {
1115 DB_browser *browser = get_the_browser();
1118 browser->set_selected_db(selected);
1122 void DB_browser::update_DB_selector() {
1127 for (KnownDBiterator i = known_databases.begin(); i != known_databases.end(); ++i, ++idx) {
1128 const KnownDB& db = *i;
1140 int wanted_db = aw_root->
awar(AWAR_DBB_DB)->
read_int();
1141 int known = known_databases.size();
1142 if (wanted_db >= known) {
1147 set_selected_db(wanted_db);
1150 known_databases[wanted_db].set_path(wanted_path);
1154 AW_window_simple *aws =
new AW_window_simple;
1156 aws->init(aw_root,
"DB_BROWSER",
"ARB database browser");
1160 aws->create_button(
"CLOSE",
"CLOSE",
"C");
1163 update_DB_selector();
1166 aws->create_option_menu(AWAR_DBB_ORDER);
1167 for (
int idx = 0; idx<SORT_COUNT; ++idx) {
1168 aws->insert_option(sort_order_name[idx],
"", idx);
1170 aws->update_option_menu();
1173 aws->create_input_field(AWAR_DBB_PATH, 10);
1175 aws->auto_space(10, 10);
1176 aws->button_length(8);
1178 aws->at(
"navigation");
1179 aws->callback(go_up_cb); aws->create_button(
"go_up",
"Up");
1180 aws->callback(goto_root_cb); aws->create_button(
"goto_root",
"Top");
1181 aws->callback(show_history_cb); aws->create_button(
"history",
"History");
1182 aws->callback(toggle_tmp_cb); aws->create_button(
"toggle_tmp",
"/tmp");
1184 aws->label(
"Rec.size"); aws->create_toggle(AWAR_DBB_RECSIZE);
1187 browse_list = aws->create_selection_list(AWAR_DBB_BROWSE);
1188 update_browser_selection_list(aw_root, browse_list);
1191 aws->label(
"ASCII"); aws->create_toggle (AWAR_DUMP_ASCII);
1192 aws->label(
"Hex"); aws->create_toggle (AWAR_DUMP_HEX);
1193 aws->label(
"Sep?"); aws->create_toggle (AWAR_DUMP_SPACE);
1194 aws->label(
"Width"); aws->create_input_field(AWAR_DUMP_WIDTH, 3);
1195 aws->label(
"Block"); aws->create_input_field(AWAR_DUMP_BLOCK, 3);
1198 aws->create_text_field(AWAR_DBB_INFO, 40, 40);
1206 db_changed_cb(aw_root);
1211 static void callallcallbacks(
AW_window *aww,
int mode) {
1212 static bool running =
false;
1215 aww->
get_root()->callallcallbacks(mode);
1221 void AWT_create_debug_menu(
AW_window *awmm) {
1228 awmm->
insert_sub_menu(
"Callbacks (dangerous! use at your own risk)",
"C", AWM_ALL);
1229 awmm->
insert_menu_topic(
"!run_all_cbs_alph",
"Call all callbacks (alpha-order)",
"a",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 0));
1230 awmm->
insert_menu_topic(
"!run_all_cbs_nalph",
"Call all callbacks (alpha-reverse)",
"l",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 1));
1231 awmm->
insert_menu_topic(
"!run_all_cbs_loc",
"Call all callbacks (code-order)",
"c",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 2));
1232 awmm->
insert_menu_topic(
"!run_all_cbs_nloc",
"Call all callbacks (code-reverse)",
"o",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 3));
1233 awmm->
insert_menu_topic(
"!run_all_cbs_rnd",
"Call all callbacks (random)",
"r",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 4));
1235 awmm->
insert_menu_topic(
"!forget_called_cbs",
"Forget called",
"F",
"", AWM_ALL, makeWindowCallback(callallcallbacks, -1));
1236 awmm->
insert_menu_topic(
"!mark_all_called",
"Mark all called",
"M",
"", AWM_ALL, makeWindowCallback(callallcallbacks, -2));
1240 awmm->
insert_menu_topic(
"!run_all_cbs_alph_inf",
"Call all callbacks (alpha-order repeated)",
"a",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 8|0));
1241 awmm->
insert_menu_topic(
"!run_all_cbs_nalph_inf",
"Call all callbacks (alpha-reverse repeated)",
"l",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 8|1));
1242 awmm->
insert_menu_topic(
"!run_all_cbs_loc_inf",
"Call all callbacks (code-order repeated)",
"c",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 8|2));
1243 awmm->
insert_menu_topic(
"!run_all_cbs_nloc_inf",
"Call all callbacks (code-reverse repeated)",
"o",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 8|3));
1244 awmm->
insert_menu_topic(
"!run_all_cbs_rnd_inf",
"Call all callbacks (random repeated)",
"r",
"", AWM_ALL, makeWindowCallback(callallcallbacks, 8|4));
1255 void AWT_check_action_ids(
AW_root *,
const char *) {
1258 void AWT_check_action_ids(
AW_root *aw_root,
const char *suffix) {
1268 FILE *out = fopen(save,
"wt");
1271 for (
size_t i = 0; i<action_ids->
size(); ++i) {
1272 fprintf(out,
"%s\n", (*action_ids)[i]);
1280 if (IDs_have_changed) error =
GBS_global_string(
"action ids differ from expected (see console)");
1287 if (error) fprintf(stderr,
"AWT_check_action_ids: Error: %s\n", error);
1294 AW_root *aw_root =
new AW_root(properties, program,
false, user_tracker);
1312 if (appAction.
empty()) {
1313 error =
"No action found";
1316 for (
unsigned a = 0; a<appAction.
size() && !
error; ++a) {
1320 if (cmd.
size() != 2) {
1324 const char *app = cmd[0];
1325 const char *action = cmd[1];
1343 "Unhandled error was:\n"
1345 #if defined(DEVEL_RALF)
1347 #endif // DEVEL_RALF
1354 "Unhandled error was:\n"
1356 #if defined(DEVEL_RALF)
1358 #endif // DEVEL_RALF
void insert_option(AW_label choice_label, const char *mnemonic, const char *var_value, const char *name_of_color=NULp)
void GBS_restore_global_buffers(GlobalStringBuffers *saved)
NOT4PERL long GB_calc_structure_size(GBDATA *gbd)
void init_Advisor(AW_root *awr)
has to be called one time (before calling AW_advice)
void AWT_trigger_remote_action(UNFIXED, GBDATA *gb_main, const char *remote_action_spec)
bool operator<(const BoundTreeAwarCallbackPtr &bc1, const BoundTreeAwarCallbackPtr &bc2)
GBDATA * GB_child(GBDATA *father)
return string(buffer, length)
bool GB_is_temporary(GBDATA *gbd)
static void after_callback_guard()
void insert_menu_topic(const char *id, const char *name, const char *mnemonic, const char *help_text_, AW_active mask, const WindowCallback &wcb)
void load_xfig(const char *file, bool resize=true)
GB_ERROR GB_add_callback(GBDATA *gbd, GB_CB_TYPE type, const DatabaseCallback &dbcb)
void AWT_install_postcb_cb(AW_postcb_cb postcb_cb)
GBDATA * GB_nextEntry(GBDATA *entry)
int ARB_stricmp(const char *s1, const char *s2)
const char * GB_get_type_name(GBDATA *gbd)
GB_ERROR GB_IO_error(const char *action, const char *filename)
char * ARB_strdup(const char *str)
char * GB_read_as_string(GBDATA *gbd)
static void set_AW_cb_guards(AW_cb_struct_guard before, AW_cb_struct_guard after)
size_t GBS_shorten_repeated_data(char *data)
const char * GBS_global_string(const char *templat,...)
NOT4PERL GB_ERROR GBT_remote_action_with_timeout(GBDATA *gb_main, const char *application, const char *action_name, const class ARB_timeout *timeout, bool verbose)
char * GBS_string_eval(const char *insource, const char *icommand)
void AW_POPDOWN(AW_window *window)
char * ARB_strpartdup(const char *start, const char *end)
int GB_unlink(const char *path)
GBDATA * GB_get_father(GBDATA *gbd)
void update_option_menu()
AW_awar * add_callback(const RootCallback &cb)
struct Unfixed_cb_parameter * UNFIXED
void insert(const char *displayed, const AW_scalar &value)
static HelixNrInfo * start
const char * read_char_pntr() const
GB_ERROR GB_await_error()
static AW_root * SINGLETON
AliDataPtr after(AliDataPtr data, size_t pos)
long GB_read_count(GBDATA *gbd)
GB_TYPES GB_read_type(GBDATA *gbd)
GB_CSTR GB_read_key_pntr(GBDATA *gbd)
void AWT_install_cb_guards()
char * GB_get_callback_info(GBDATA *gbd)
GB_CSTR GB_read_pntr(GBDATA *gbd)
long GB_number_of_subentries(GBDATA *gbd)
int GB_read_security_write(GBDATA *gbd)
static void set_AW_postcb_cb(AW_postcb_cb postcb_cb)
size_t mem_needed_for_dump(size_t bytes) const
void create_menu(const char *name, const char *mnemonic, AW_active mask=AWM_ALL)
const char * GBS_readable_size(unsigned long long size, const char *unit_suffix)
static void error(const char *msg)
GBDATA * GB_get_root(GBDATA *gbd)
void dump_to(GBS_strstruct &buf, const char *mem, size_t size) const
GBQUARK GB_get_quark(GBDATA *gbd)
char * read_string() const
GB_CSTR GB_path_in_ARBLIB(const char *relative_path)
AW_awar * awar_no_error(const char *awar)
end timer stuff
AW_awar * awar(const char *awar)
void insert_sub_menu(const char *name, const char *mnemonic, AW_active mask=AWM_ALL)
bool ARB_textfiles_have_difflines(const char *file1, const char *file2, int expected_difflines, TextDiffMode tdmode)
void clear_option_menu(AW_option_menu_struct *oms)
int GB_read_security_read(GBDATA *gbd)
int GB_read_security_delete(GBDATA *gbd)
AW_awar * awar_int(const char *var_name, long default_value=0, AW_default default_file=AW_ROOT_DEFAULT)
AW_root * AWT_create_root(const char *properties, const char *program, UserActionTracker *user_tracker)
void nprintf(size_t maxlen, const char *templat,...) __ATTR__FORMAT_MEMBER(2)
void GB_remove_callback(GBDATA *gbd, GB_CB_TYPE type, const DatabaseCallback &dbcb)
const char * GB_get_db_path(GBDATA *gbd)
void aw_message(const char *msg)
AW_option_menu_struct * create_option_menu(const char *awar_name)
GlobalStringBuffers * GBS_store_global_buffers()
GB_ERROR write_string(const char *aw_string)
void GBT_split_string(ConstStrArray &dest, const char *namelist, const char *separator, SplitMode mode)
bool ARB_strBeginsWith(const char *str, const char *with)
const char * local_id(const char *id) const
GBDATA * GB_nextChild(GBDATA *child)
GB_transaction ta(gb_var)
AW_awar * awar_string(const char *var_name, const char *default_value="", AW_default default_file=AW_ROOT_DEFAULT)
GBDATA * GB_search(GBDATA *gbd, const char *fieldpath, GB_TYPES create)
void(* AW_postcb_cb)(AW_window *)
static int info[maxsites+1]
void GBT_splitNdestroy_string(ConstStrArray &names, char *&namelist, const char *separator, SplitMode mode)
GB_ERROR write_int(long aw_int)
GBDATA * GB_entry(GBDATA *father, const char *key)
void aw_message_if(GB_ERROR error)
char * GBS_global_string_copy(const char *templat,...)
GB_ERROR rewrite_string(const char *aw_string)
static void before_callback_guard()
void AWT_system_cb(AW_window *, const char *command)
bool GB_in_temporary_branch(GBDATA *gbd)