00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038 #include "heraia_types.h"
00039
00040
00041 static gboolean version(void);
00042 static gboolean usage(int status);
00043 static window_prop_t *init_window_properties(gint x, gint y, guint height, guint width, gboolean displayed);
00044 static heraia_struct_t *init_window_property_struct(heraia_struct_t *main_struct);
00045 static heraia_struct_t *heraia_init_main_struct(gchar *heraia_path);
00046 static HERAIA_ERROR init_heraia_plugin_system(heraia_struct_t *main_struct);
00047 static GList *init_heraia_location_list(gchar *heraia_path);
00048 static gboolean manage_command_line_options(Options *opt, int argc, char **argv);
00049
00050
00051
00052
00053
00054
00055 static heraia_struct_t *libheraia_main_struct = NULL;
00056
00057
00058
00059
00060
00061
00062
00063 heraia_struct_t *get_main_struct(void)
00064 {
00065 return libheraia_main_struct;
00066 }
00067
00068
00069
00070
00071
00072
00073 static gboolean version(void)
00074 {
00075 fprintf (stdout, Q_("heraia written by %s\n %s - Version %s\n License %s\n"), HERAIA_AUTHORS, HERAIA_DATE, HERAIA_VERSION, HERAIA_LICENSE);
00076 return TRUE;
00077 }
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089 static gboolean usage(int status)
00090 {
00091 if (status == 0)
00092 {
00093 fprintf (stderr, Q_("Try `heraia --help' for more information.\n"));
00094
00095 return FALSE;
00096 }
00097 else
00098 {
00099 version();
00100 fprintf(stdout, Q_("\nheraia is a simple hexadecimal file editor and file analyser"));
00101 fprintf(stdout, Q_("\nUsage :\n heraia [options] filename(s)\n"));
00102 fprintf(stdout, Q_("\nOptions :\n"));
00103 fprintf(stdout, Q_(" -h, --help\tThis help.\n"));
00104 fprintf(stdout, Q_(" -v, --version\tProgram version information.\n"));
00105 fprintf(stdout, Q_(" -t, --tests=TESTS\tRuns some tests.\n"));
00106 fprintf(stdout, Q_(" TESTS might be :\n"));
00107 fprintf(stdout, Q_(" %d for coverage tests\n"), COVERAGE_TESTS);
00108 fprintf(stdout, Q_(" %d for loading files tests\n"), LOADING_TESTS);
00109
00110 return TRUE;
00111 }
00112 }
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124 static window_prop_t *init_window_properties(gint x, gint y, guint height, guint width, gboolean displayed)
00125 {
00126 window_prop_t *window_p;
00127
00128
00129 window_p = (window_prop_t *) g_malloc0(sizeof(window_prop_t));
00130
00131
00132 window_p->x = x;
00133 window_p->y = y;
00134 window_p->height = height;
00135 window_p->width = width;
00136 window_p->displayed = displayed;
00137
00138 return window_p;
00139 }
00140
00141
00142
00143
00144
00145
00146
00147 static heraia_struct_t *init_window_property_struct(heraia_struct_t *main_struct)
00148 {
00149 all_window_prop_t *win_prop = NULL;
00150 window_prop_t *about_box = NULL;
00151 window_prop_t *data_interpretor = NULL;
00152 window_prop_t *log_box = NULL;
00153 window_prop_t *main_dialog = NULL;
00154 window_prop_t *plugin_list = NULL;
00155 window_prop_t *ldt = NULL;
00156 window_prop_t *main_pref_window = NULL;
00157
00158
00159 win_prop = (all_window_prop_t *) g_malloc0(sizeof(all_window_prop_t));
00160
00161
00162 about_box = init_window_properties(0, 0, WPT_DEFAULT_HEIGHT, WPT_DEFAULT_WIDTH, FALSE);
00163 data_interpretor = init_window_properties(0, 0, WPT_DEFAULT_HEIGHT, WPT_DEFAULT_WIDTH, H_DI_DISPLAYED);
00164 log_box = init_window_properties(0, 0, WPT_DEFAULT_HEIGHT, WPT_DEFAULT_WIDTH, FALSE);
00165 main_dialog = init_window_properties(0, 0, WPT_DEFAULT_HEIGHT, WPT_DEFAULT_WIDTH, TRUE);
00166 plugin_list = init_window_properties(0, 0, WPT_DEFAULT_HEIGHT, WPT_DEFAULT_WIDTH, FALSE);
00167 ldt = init_window_properties(0, 0, WPT_DEFAULT_HEIGHT, WPT_DEFAULT_WIDTH, FALSE);
00168 main_pref_window = init_window_properties(0, 0, WPT_DEFAULT_HEIGHT, WPT_DEFAULT_WIDTH, FALSE);
00169
00170
00171 win_prop->about_box = about_box;
00172 win_prop->data_interpretor = data_interpretor;
00173 win_prop->log_box = log_box;
00174 win_prop->main_dialog = main_dialog;
00175 win_prop->plugin_list = plugin_list;
00176 win_prop->ldt = ldt;
00177 win_prop->main_pref_window = main_pref_window;
00178
00179
00180 main_struct->win_prop = win_prop;
00181
00182 return main_struct;
00183 }
00184
00185
00186
00187
00188
00189
00190
00191
00192 static heraia_struct_t *heraia_init_main_struct(gchar *heraia_path)
00193 {
00194 heraia_struct_t *main_struct = NULL;
00195 xml_t *xmls = NULL;
00196
00197 main_struct = (heraia_struct_t *) g_malloc0(sizeof(heraia_struct_t));
00198
00199 if (main_struct == NULL)
00200 {
00201 fprintf(stderr, Q_("Main structure could not be initialiazed !"));
00202 fprintf(stderr, Q_("Do you have a memory problem ?\n"));
00203 return NULL;
00204 }
00205
00206
00207 main_struct->prefs = NULL;
00208 init_preference_struct(main_struct);
00209 verify_preference_file(main_struct->prefs->pathname, main_struct->prefs->filename);
00210
00211
00212
00213
00214
00215 main_struct->debug = ENABLE_DEBUG;
00216
00217 main_struct->current_doc = NULL;
00218 main_struct->plugins_list = NULL;
00219 main_struct->location_list = init_heraia_location_list(heraia_path);
00220
00221
00222 xmls = (xml_t *) g_malloc0(sizeof(xml_t));
00223 xmls->main = NULL;
00224 main_struct->xmls = xmls;
00225
00226
00227 main_struct->current_DW = (data_window_t *) g_malloc0 (sizeof(data_window_t));
00228 main_struct->current_DW->diw = NULL;
00229 main_struct->current_DW->tab_displayed = 0;
00230
00231
00232 main_struct = init_window_property_struct(main_struct);
00233
00234
00235 main_struct->documents = g_ptr_array_new();
00236
00237
00238 libheraia_main_struct = main_struct;
00239
00240 return main_struct;
00241 }
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252 static HERAIA_ERROR init_heraia_plugin_system(heraia_struct_t *main_struct)
00253 {
00254
00255
00256 if (plugin_capable() == TRUE)
00257 {
00258 log_message(main_struct, G_LOG_LEVEL_INFO, Q_("Enabling plugins"));
00259 load_plugins(main_struct);
00260
00261
00262 log_message(main_struct, G_LOG_LEVEL_DEBUG, Q_("Inits the plugin list window"));
00263 plugin_list_window_init_interface(main_struct);
00264
00265 return HERAIA_NOERR;
00266 }
00267 else
00268 {
00269 log_message(main_struct, G_LOG_LEVEL_WARNING, Q_("Plugins will be disabled"));
00270 return HERAIA_NO_PLUGINS;
00271 }
00272 }
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282 static GList *init_heraia_location_list(gchar *heraia_path)
00283 {
00284 gchar *path = NULL;
00285 const gchar* const *system_dirs;
00286 guint i = 0;
00287 GList *location_list = NULL;
00288
00289
00290 path = g_get_current_dir();
00291 location_list = g_list_prepend(location_list, path);
00292
00293
00294 system_dirs = g_get_system_data_dirs();
00295 i = 0;
00296 while(system_dirs[i] != NULL)
00297 {
00298 path = g_build_path(G_DIR_SEPARATOR_S, system_dirs[i], "heraia", NULL);
00299 location_list = g_list_prepend(location_list, path);
00300 i++;
00301 }
00302
00303
00304 system_dirs = g_get_system_config_dirs();
00305 i = 0;
00306 while(system_dirs[i] != NULL)
00307 {
00308 path = g_build_path(G_DIR_SEPARATOR_S, system_dirs[i], "heraia", NULL);
00309 location_list = g_list_prepend(location_list, path);
00310 i++;
00311 }
00312
00313
00314 path = g_build_path(G_DIR_SEPARATOR_S, g_get_home_dir(), "heraia", NULL);
00315 location_list = g_list_prepend(location_list, path);
00316
00317
00318 path = g_build_path(G_DIR_SEPARATOR_S, g_get_user_data_dir(), "heraia", NULL);
00319 location_list = g_list_prepend(location_list, path);
00320
00321
00322 path = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), "heraia", NULL);
00323 location_list = g_list_prepend(location_list, path);
00324
00325
00326 path = g_build_path(G_DIR_SEPARATOR_S, heraia_path, "..", "share", "heraia", NULL);
00327 location_list = g_list_prepend(location_list, path);
00328
00329 return location_list;
00330 }
00331
00332
00333
00334
00335
00336 static void init_international_languages(void)
00337 {
00338 gchar *result = NULL;
00339
00340 setlocale(LC_ALL, "");
00341 result = bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
00342
00343 if (ENABLE_DEBUG == TRUE)
00344 {
00345 fprintf(stdout, Q_("Gettext package : %s\n"), GETTEXT_PACKAGE);
00346 fprintf(stdout, Q_("Locale dir : %s\n"), LOCALEDIR);
00347 fprintf(stdout, Q_("Bindtextdomain : %s\n"), result);
00348 }
00349 bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
00350 textdomain(GETTEXT_PACKAGE);
00351 }
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363 static gboolean do_heraia_coverage_tests(heraia_struct_t *main_struct)
00364 {
00365 heraia_struct_t *tmp_struct;
00366 gboolean exit_value = FALSE;
00367
00368 exit_value = version();
00369 exit_value = usage(0);
00370 exit_value = usage(1);
00371
00372 tmp_struct = get_main_struct();
00373 if (tmp_struct != main_struct)
00374 {
00375 fprintf(stderr, Q_("WARNING : tmp_struct is not equal to main_struct!\n"));
00376 }
00377
00378 exit_value = test_decode_functions();
00379 if (exit_value != TRUE)
00380 {
00381 fprintf(stderr, Q_("WARNING : Error while testing decode functions\n"));
00382 }
00383
00384 return TRUE;
00385 }
00386
00387
00388
00389
00390
00391
00392
00393 static gboolean do_heraia_loading_tests(heraia_struct_t *main_struct)
00394 {
00395 return TRUE;
00396 }
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407 static gboolean manage_command_line_options(Options *opt, int argc, char **argv)
00408 {
00409 int exit_value = TRUE;
00410 int c = 0;
00411 gchar *filename = NULL;
00412 int tests = 0;
00413
00414 while ((c = getopt_long(argc, argv, "vht", long_options, NULL)) != -1)
00415 {
00416 switch (c)
00417 {
00418 case 0:
00419 break;
00420
00421 case 'v':
00422 exit_value = version();
00423 opt->usage = TRUE;
00424 break;
00425
00426 case 'h':
00427 exit_value = usage(1);
00428 opt->usage = TRUE;
00429 break;
00430
00431 case 't':
00432 if (optarg)
00433 {
00434 if (sscanf(optarg, "%d", &tests) < 1)
00435 {
00436
00437 opt->tests = COVERAGE_TESTS;
00438 }
00439 else
00440 {
00441 opt->tests = tests;
00442 }
00443 }
00444 else
00445 {
00446 opt->tests = COVERAGE_TESTS;
00447 }
00448 exit_value = TRUE;
00449 break;
00450
00451 default:
00452 exit_value = usage(0);
00453 opt->usage = TRUE;
00454 }
00455 }
00456
00457 while (optind < argc)
00458 {
00459 filename = (char *) malloc (sizeof(char) * strlen(argv[optind]) + 1);
00460 strcpy(filename, argv[optind]);
00461 opt->filenames = g_list_prepend(opt->filenames, filename);
00462 optind++;
00463 }
00464
00465 return exit_value;
00466 }
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476 static Options *init_options_struct(void)
00477 {
00478 Options *opt = NULL;
00479
00480 opt = (Options *) g_malloc0(sizeof(Options));
00481
00482 opt->filenames = NULL;
00483 opt->usage = FALSE;
00484 opt->tests = NO_TESTS;
00485
00486 return opt;
00487 }
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497 int main(int argc, char **argv)
00498 {
00499 Options *opt;
00500 gboolean exit_value = TRUE;
00501 heraia_struct_t *main_struct = NULL;
00502 GList *list = NULL;
00503 gchar *heraia_path = NULL;
00504
00505 if (argv != NULL && argv[0] != NULL)
00506 {
00507 heraia_path = g_path_get_dirname(argv[0]);
00508 }
00509 else
00510 {
00511 return -1;
00512 }
00513
00514 init_international_languages();
00515
00516 opt = init_options_struct();
00517
00518
00519
00520 main_struct = heraia_init_main_struct(heraia_path);
00521
00522 libheraia_initialize();
00523
00524 if (main_struct->debug == TRUE)
00525 {
00526 fprintf(stdout, Q_("Main struct initialized !\n"));
00527 }
00528
00529
00530 exit_value = manage_command_line_options(opt, argc, argv);
00531
00532 if (opt->usage != TRUE)
00533 {
00534 if (main_struct->debug == TRUE)
00535 {
00536 fprintf(stderr, Q_("Beginning things\n"));
00537 libheraia_test();
00538 }
00539
00540
00541 exit_value = gtk_init_check(&argc, &argv);
00542
00543 if (load_heraia_ui(main_struct) == TRUE)
00544 {
00545
00546 log_message(main_struct, G_LOG_LEVEL_INFO, Q_("Main interface loaded"));
00547 log_message(main_struct, G_LOG_LEVEL_DEBUG, Q_("Preference file is %s"), main_struct->prefs->filename);
00548 log_message(main_struct, G_LOG_LEVEL_DEBUG, Q_("data interpretor's tab is %d"), main_struct->current_DW->tab_displayed);
00549
00550 init_heraia_plugin_system(main_struct);
00551
00552 if (opt->filenames != NULL)
00553 {
00554 list = g_list_first(opt->filenames);
00555 while (list != NULL)
00556 {
00557 load_file_to_analyse(main_struct, list->data);
00558 list = g_list_next(list);
00559 }
00560 }
00561
00562 log_message(main_struct, G_LOG_LEVEL_DEBUG, Q_("main_struct : %p"), main_struct);
00563
00564 init_heraia_interface(main_struct);
00565
00566
00567 switch (opt->tests)
00568 {
00569 case COVERAGE_TESTS:
00570 exit_value = do_heraia_coverage_tests(main_struct);
00571 break;
00572
00573 case LOADING_TESTS:
00574 exit_value = do_heraia_loading_tests(main_struct);
00575 break;
00576
00577 default:
00578
00579 gtk_main();
00580 exit_value = TRUE;
00581 }
00582 }
00583 else
00584 {
00585 fprintf(stderr, Q_("File heraia.gtkbuilder not found !\n"));
00586 if (main_struct->debug == TRUE)
00587 {
00588 list = main_struct->location_list;
00589 while (list)
00590 {
00591
00592 heraia_path = (gchar *) list->data;
00593 fprintf(stdout, "\t%s\n", heraia_path);
00594 list = g_list_next(list);
00595 }
00596 }
00597 }
00598 }
00599
00600 libheraia_finalize();
00601
00602 return !exit_value;
00603 }