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(void);
00046 static HERAIA_ERROR init_heraia_plugin_system(heraia_struct_t *main_struct);
00047 static GList *init_heraia_location_list(void);
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 static heraia_struct_t *heraia_init_main_struct(void)
00191 {
00192 heraia_struct_t *herwin = NULL;
00193 xml_t *xmls = NULL;
00194
00195 herwin = (heraia_struct_t *) g_malloc0(sizeof(heraia_struct_t));
00196
00197 if (!herwin)
00198 {
00199 fprintf(stderr, Q_("Main structure could not be initialiazed !"));
00200 fprintf(stderr, Q_("Do you have a memory problem ?\n"));
00201 return NULL;
00202 }
00203
00204
00205 herwin->prefs = NULL;
00206 init_preference_struct(herwin);
00207 verify_preference_file(herwin->prefs->pathname, herwin->prefs->filename);
00208
00209
00210
00211
00212
00213 herwin->debug = ENABLE_DEBUG;
00214
00215
00216 herwin->current_doc = NULL;
00217 herwin->plugins_list = NULL;
00218 herwin->location_list = init_heraia_location_list();
00219
00220
00221 xmls = (xml_t *) g_malloc0(sizeof(xml_t));
00222 xmls->main = NULL;
00223 herwin->xmls = xmls;
00224
00225
00226 herwin->current_DW = (data_window_t *) g_malloc0 (sizeof(data_window_t));
00227 herwin->current_DW->diw = NULL;
00228 herwin->current_DW->tab_displayed = 0;
00229
00230
00231 herwin = init_window_property_struct(herwin);
00232
00233
00234 herwin->documents = g_ptr_array_new();
00235
00236
00237 libheraia_main_struct = herwin;
00238
00239 return herwin;
00240 }
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251 static HERAIA_ERROR init_heraia_plugin_system(heraia_struct_t *main_struct)
00252 {
00253
00254
00255 if (plugin_capable() == TRUE)
00256 {
00257 log_message(main_struct, G_LOG_LEVEL_INFO, "Enabling plugins");
00258 load_plugins(main_struct);
00259
00260
00261 log_message(main_struct, G_LOG_LEVEL_DEBUG, "Inits the plugin list window");
00262 plugin_list_window_init_interface(main_struct);
00263
00264 return HERAIA_NOERR;
00265 }
00266 else
00267 {
00268 log_message(main_struct, G_LOG_LEVEL_WARNING, "Plugins will be disabled");
00269 return HERAIA_NO_PLUGINS;
00270 }
00271 }
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281 static GList *init_heraia_location_list(void)
00282 {
00283 gchar *path = NULL;
00284 const gchar* const *system_dirs;
00285 guint i = 0;
00286 GList *location_list = NULL;
00287
00288
00289 path = g_get_current_dir();
00290 location_list = g_list_prepend(location_list, path);
00291
00292
00293 system_dirs = g_get_system_data_dirs();
00294 i = 0;
00295 while(system_dirs[i] != NULL)
00296 {
00297 path = g_build_path(G_DIR_SEPARATOR_S, system_dirs[i], "heraia", NULL);
00298 location_list = g_list_prepend(location_list, path);
00299 i++;
00300 }
00301
00302
00303 system_dirs = g_get_system_config_dirs();
00304 i = 0;
00305 while(system_dirs[i] != NULL)
00306 {
00307 path = g_build_path(G_DIR_SEPARATOR_S, system_dirs[i], "heraia", NULL);
00308 location_list = g_list_prepend(location_list, path);
00309 i++;
00310 }
00311
00312
00313 path = g_build_path(G_DIR_SEPARATOR_S, g_get_home_dir(), "heraia", NULL);
00314 location_list = g_list_prepend(location_list, path);
00315
00316
00317 path = g_build_path(G_DIR_SEPARATOR_S, g_get_user_data_dir(), "heraia", NULL);
00318 location_list = g_list_prepend(location_list, path);
00319
00320
00321 path = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), "heraia", NULL);
00322 location_list = g_list_prepend(location_list, path);
00323
00324 return location_list;
00325 }
00326
00327
00328
00329
00330
00331 static void init_international_languages(void)
00332 {
00333 gchar *result = NULL;
00334
00335 setlocale(LC_ALL, "");
00336 result = bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
00337
00338 if (ENABLE_DEBUG == TRUE)
00339 {
00340 fprintf(stdout, "Gettext package : %s\n", GETTEXT_PACKAGE);
00341 fprintf(stdout, "Locale dir : %s\n", LOCALEDIR);
00342 fprintf(stdout, "Bindtextdomain : %s\n", result);
00343 }
00344 bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
00345 textdomain(GETTEXT_PACKAGE);
00346 }
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358 static gboolean do_heraia_coverage_tests(heraia_struct_t *main_struct)
00359 {
00360 heraia_struct_t *tmp_struct;
00361 gboolean exit_value = FALSE;
00362
00363 exit_value = version();
00364 exit_value = usage(0);
00365 exit_value = usage(1);
00366
00367 tmp_struct = get_main_struct();
00368 if (tmp_struct != main_struct)
00369 {
00370 fprintf(stderr, "WARNING : tmp_struct is not equal to main_struct!\n");
00371 }
00372
00373 exit_value = test_decode_functions();
00374 if (exit_value != TRUE)
00375 {
00376 fprintf(stderr, "WARNING : Error while testing decode functions\n");
00377 }
00378
00379 return TRUE;
00380 }
00381
00382
00383
00384
00385
00386
00387
00388 static gboolean do_heraia_loading_tests(heraia_struct_t *main_struct)
00389 {
00390 return TRUE;
00391 }
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402 static gboolean manage_command_line_options(Options *opt, int argc, char **argv)
00403 {
00404 int exit_value = TRUE;
00405 int c = 0;
00406 gchar *filename = NULL;
00407 int tests = 0;
00408
00409 while ((c = getopt_long(argc, argv, "vht", long_options, NULL)) != -1)
00410 {
00411 switch (c)
00412 {
00413 case 0:
00414 break;
00415
00416 case 'v':
00417 exit_value = version();
00418 opt->usage = TRUE;
00419 break;
00420
00421 case 'h':
00422 exit_value = usage(1);
00423 opt->usage = TRUE;
00424 break;
00425
00426 case 't':
00427 if (optarg)
00428 {
00429 if (sscanf(optarg, "%d", &tests) < 1)
00430 {
00431
00432 opt->tests = COVERAGE_TESTS;
00433 }
00434 else
00435 {
00436 opt->tests = tests;
00437 }
00438 }
00439 else
00440 {
00441 opt->tests = COVERAGE_TESTS;
00442 }
00443 exit_value = TRUE;
00444 break;
00445
00446 default:
00447 exit_value = usage(0);
00448 opt->usage = TRUE;
00449 }
00450 }
00451
00452 while (optind < argc)
00453 {
00454 filename = (char *) malloc (sizeof(char) * strlen(argv[optind]) + 1);
00455 strcpy(filename, argv[optind]);
00456 opt->filenames = g_list_prepend(opt->filenames, filename);
00457 optind++;
00458 }
00459
00460 return exit_value;
00461 }
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471 static Options *init_options_struct(void)
00472 {
00473 Options *opt = NULL;
00474
00475 opt = (Options *) g_malloc0(sizeof(Options));
00476
00477 opt->filenames = NULL;
00478 opt->usage = FALSE;
00479 opt->tests = NO_TESTS;
00480
00481 return opt;
00482 }
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492 int main(int argc, char **argv)
00493 {
00494 Options *opt;
00495 gboolean exit_value = TRUE;
00496 heraia_struct_t *main_struct = NULL;
00497 GList *list = NULL;
00498
00499
00500 init_international_languages();
00501
00502 opt = init_options_struct();
00503
00504 main_struct = heraia_init_main_struct();
00505
00506 libheraia_initialize();
00507
00508 if (main_struct->debug == TRUE)
00509 {
00510 fprintf(stdout, "Main struct initialized !\n");
00511 }
00512
00513
00514 exit_value = manage_command_line_options(opt, argc, argv);
00515
00516 if (opt->usage != TRUE)
00517 {
00518 if (main_struct->debug == TRUE)
00519 {
00520 fprintf(stderr, "Beginning things\n");
00521 libheraia_test();
00522 }
00523
00524
00525 exit_value = gtk_init_check(&argc, &argv);
00526
00527 if (load_heraia_ui(main_struct) == TRUE)
00528 {
00529
00530 log_message(main_struct, G_LOG_LEVEL_INFO, "Main interface loaded");
00531 log_message(main_struct, G_LOG_LEVEL_DEBUG, "Preference file is %s", main_struct->prefs->filename);
00532 log_message(main_struct, G_LOG_LEVEL_DEBUG, "data interpretor's tab is %d", main_struct->current_DW->tab_displayed);
00533
00534 init_heraia_plugin_system(main_struct);
00535
00536 if (opt->filenames != NULL)
00537 {
00538 list = g_list_first(opt->filenames);
00539 while (list != NULL)
00540 {
00541 load_file_to_analyse(main_struct, list->data);
00542 list = g_list_next(list);
00543 }
00544 }
00545
00546 log_message(main_struct, G_LOG_LEVEL_DEBUG, "main_struct : %p", main_struct);
00547
00548 init_heraia_interface(main_struct);
00549
00550
00551 switch (opt->tests)
00552 {
00553 case COVERAGE_TESTS:
00554 exit_value = do_heraia_coverage_tests(main_struct);
00555 break;
00556
00557 case LOADING_TESTS:
00558 exit_value = do_heraia_loading_tests(main_struct);
00559 break;
00560
00561 default:
00562
00563 gtk_main();
00564 exit_value = TRUE;
00565 }
00566 }
00567 else
00568 {
00569 fprintf(stderr, "File heraia.gtkbuilder not found !\n");
00570 }
00571 }
00572
00573 libheraia_finalize();
00574
00575 return !exit_value;
00576 }