heraia_ui.c

Go to the documentation of this file.
00001 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
00002 /*
00003   heraia_ui.c
00004   main menus, callback and utility functions
00005  
00006   (C) Copyright 2005 - 2009 Olivier Delhomme
00007   e-mail : heraia@delhomme.org
00008   URL    : http://heraia.tuxfamily.org
00009          
00010   This program is free software; you can redistribute it and/or modify
00011   it under the terms of the GNU General Public License as published by
00012   the Free Software Foundation; either version 2, or  (at your option) 
00013   any later version.
00014                  
00015   This program is distributed in the hope that it will be useful,
00016   but WITHOUT ANY WARRANTY;  without even the implied warranty of
00017   MERCHANTABILITY  or  FITNESS FOR A PARTICULAR PURPOSE.  See the
00018   GNU General Public License for more details.
00019                  
00020   You should have received a copy of the GNU General Public License
00021   along with this program; if not, write to the Free Software
00022   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
00023 */
00024 /** @file heraia_ui.c
00025  * This file has all the functions to manage heraia's ui
00026  * - signals definitions and functions
00027  * - widgets activations
00028  * - closing / openning windows
00029  */
00030 
00031 #include <libheraia.h>
00032 
00033 static void set_a_propos_properties(GtkWidget *about_dialog);
00034 static gboolean load_heraia_glade_xml(heraia_window_t *main_window);
00035 static void heraia_ui_connect_signals(heraia_window_t *main_window);
00036 static void record_and_hide_about_box(heraia_window_t *main_window);
00037 static void close_heraia(heraia_window_t *main_window);
00038 
00039 /**
00040  * @fn void on_quit_activate(GtkWidget *widget, gpointer data)
00041  *  Quit, file menu
00042  * @param widget : the widget that issued the signal
00043  * @param data : user data MUST be heraia_window_t *main_window main structure
00044  */
00045 void on_quit_activate(GtkWidget *widget, gpointer data)
00046 {
00047         heraia_window_t *main_window = (heraia_window_t *) data;
00048         
00049         close_heraia(main_window);
00050         gtk_main_quit();
00051 }
00052 
00053 /**
00054  * @fn void on_new_activate(GtkWidget *widget, gpointer data)
00055  *  New, file menu
00056  * @param widget : the widget that issued the signal
00057  * @param data : user data MUST be heraia_window_t *main_window main structure
00058  */
00059 void on_new_activate(GtkWidget *widget, gpointer data)
00060 {
00061         heraia_window_t *main_window = (heraia_window_t *) data;
00062         
00063         log_message(main_window, G_LOG_LEVEL_WARNING, "Not implemented Yet (Please contribute !)");
00064 }
00065 
00066 /**
00067  * @fn void on_preferences_activate(GtkWidget *widget, gpointer data)
00068  *  Preferences, file menu :
00069  *  Displays the preference window (as a modal window)
00070  * @param widget : the widget that issued the signal
00071  * @param data : user data MUST be heraia_window_t *main_window main structure
00072  */
00073 void on_preferences_activate(GtkWidget *widget, gpointer data)
00074 {
00075         heraia_window_t *main_window = (heraia_window_t *) data;
00076         GtkWidget *pref_window = NULL;
00077         
00078         pref_window = heraia_get_widget(main_window->xmls->main, "main_preferences_window");
00079         
00080         if (pref_window != NULL)
00081         {
00082                 move_and_show_dialog_box(pref_window, main_window->win_prop->main_pref_window);
00083         }
00084         
00085 }
00086 
00087 /**
00088  * @fn void set_a_propos_properties(GtkWidget *about_dialog)
00089  * Sets name and version in the dialog box
00090  * @param about_dialog the widget that contain all the about box
00091  */
00092 static void set_a_propos_properties(GtkWidget *about_dialog)
00093 {
00094         
00095         if (about_dialog != NULL)
00096         {
00097                 if (GTK_MINOR_VERSION >= 12)
00098                 {
00099                     gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(about_dialog), PACKAGE_NAME);
00100                 }
00101                 if (GTK_MINOR_VERSION >= 6)
00102                 {
00103                         gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about_dialog), PACKAGE_VERSION);
00104                 }
00105         }
00106 }
00107 
00108 
00109 /**
00110  * @fn void a_propos_activate(GtkWidget *widget, gpointer data)
00111  *  Shows apropos's dialog box
00112  * @param widget : the widget that issued the signal
00113  * @param data : user data MUST be heraia_window_t *main_window main structure
00114  */
00115 void a_propos_activate(GtkWidget *widget, gpointer data)
00116 {
00117         heraia_window_t *main_window = (heraia_window_t *) data;
00118         GtkWidget *about_dialog = NULL;
00119         
00120         about_dialog = heraia_get_widget(main_window->xmls->main, "about_dialog");
00121         
00122         if (about_dialog != NULL)
00123         {
00124                 set_a_propos_properties(about_dialog);
00125         
00126                 move_and_show_dialog_box(about_dialog, main_window->win_prop->about_box);
00127         }
00128 }
00129 
00130 /** 
00131  * @fn void move_and_show_dialog_box(GtkWidget *dialog_box, window_prop_t *dialog_prop)
00132  *  Move the dialog box to the wanted position, shows it and says it in the displayed prop
00133  * @param dialog_box : the dialog box we want to move and show
00134  * @param dialog_prop : window_prop_t properties structure corresponding to the dialog box
00135  */
00136 void move_and_show_dialog_box(GtkWidget *dialog_box, window_prop_t *dialog_prop)
00137 {
00138         if (dialog_prop->displayed == FALSE)
00139         {
00140                 gtk_window_move(GTK_WINDOW(dialog_box), dialog_prop->x, dialog_prop->y);
00141                 gtk_window_resize(GTK_WINDOW(dialog_box), dialog_prop->width, dialog_prop->height);
00142                 gtk_widget_show_all(dialog_box);
00143                 dialog_prop->displayed = TRUE;
00144         }
00145 }
00146 
00147 /**
00148  * @fn void record_dialog_box_position(GtkWidget *dialog_box, window_prop_t *dialog_prop)
00149  * Records one dialog position
00150  * @param dialog_box : a dialog box from which we want to record the position
00151  * @param[in,out] dialog_prop : window_prop_t properties structure corresponding to the dialog box
00152  */
00153 void record_dialog_box_position(GtkWidget *dialog_box, window_prop_t *dialog_prop)
00154 {
00155         gint x = 0;
00156         gint y = 0;
00157         gint width = WPT_DEFAULT_WIDTH;
00158         gint height = WPT_DEFAULT_HEIGHT;
00159         
00160         if (dialog_prop != NULL && dialog_prop->displayed == TRUE)
00161         {
00162                 if (dialog_box != NULL)
00163                 {
00164                         gtk_window_get_position(GTK_WINDOW(dialog_box), &x, &y);
00165                         gtk_window_get_size(GTK_WINDOW(dialog_box), &width, &height);
00166                         dialog_prop->x = x;
00167                         dialog_prop->y = y;
00168                         dialog_prop->width = width;
00169                         dialog_prop->height = height;
00170                 }
00171         }
00172 }
00173 
00174 
00175 /**
00176  * @fn void record_all_dialog_box_positions(heraia_window_t *main_window)
00177  * Records all the positions of the displayed windows
00178  * @param[in,out] main_window : main structure
00179  */
00180 void record_all_dialog_box_positions(heraia_window_t *main_window)
00181 {
00182         GtkWidget *dialog_box = NULL;
00183 
00184         if (main_window != NULL && 
00185                 main_window->xmls != NULL && 
00186                 main_window->xmls->main != NULL &&
00187                 main_window->win_prop != NULL &&
00188                 main_window->current_DW != NULL)
00189         {
00190                 /* data interpretor */
00191                 dialog_box = main_window->current_DW->diw;
00192                 record_dialog_box_position(dialog_box, main_window->win_prop->data_interpretor);
00193         
00194                 /* About box */
00195                 dialog_box = heraia_get_widget (main_window->xmls->main, "about_dialog");
00196                 record_dialog_box_position(dialog_box, main_window->win_prop->about_box);
00197         
00198                 /* Log window */
00199                 dialog_box = heraia_get_widget (main_window->xmls->main, "log_window");
00200                 record_dialog_box_position(dialog_box, main_window->win_prop->log_box);
00201         
00202                 /* main_dialog */
00203                 dialog_box = heraia_get_widget (main_window->xmls->main, "main_window");
00204                 record_dialog_box_position(dialog_box, main_window->win_prop->main_dialog);
00205         
00206                 /* plugin_list */
00207                 dialog_box = heraia_get_widget (main_window->xmls->main, "plugin_list_window");
00208                 record_dialog_box_position(dialog_box, main_window->win_prop->plugin_list);
00209         
00210                 /* list data types */
00211                 dialog_box = heraia_get_widget (main_window->xmls->main, "list_data_types_window");
00212                 record_dialog_box_position(dialog_box, main_window->win_prop->ldt);
00213         
00214                 /* main_preferences */
00215                 dialog_box = heraia_get_widget (main_window->xmls->main, "main_preferences_window");
00216                 record_dialog_box_position(dialog_box, main_window->win_prop->main_pref_window);
00217         }
00218 }
00219         
00220         
00221 /**
00222  * @fn void record_and_hide_dialog_box(GtkWidget *dialog_box, window_prop_t *dialog_prop)
00223  *  Record position and hide a dialog box
00224  * @param dialog_box : the dialog box we want to record its position and then hide
00225  * @param dialog_prop : window_prop_t properties structure corresponding to the dialog box
00226  */
00227 void record_and_hide_dialog_box(GtkWidget *dialog_box, window_prop_t *dialog_prop)
00228 {
00229 
00230         if (dialog_prop->displayed == TRUE)
00231         {
00232                 record_dialog_box_position(dialog_box, dialog_prop);
00233                 
00234                 gtk_widget_hide(dialog_box);
00235                 dialog_prop->displayed = FALSE;
00236         }
00237 }
00238 
00239 
00240 /**
00241  * @fn static void record_and_hide_about_box(heraia_window_t *main_window)
00242  *  Record position and hide about dialog box
00243  * @param [in,out] main_window : main structure
00244  */
00245 static void record_and_hide_about_box(heraia_window_t *main_window)
00246 {
00247         GtkWidget *about_dialog = NULL; 
00248         
00249         about_dialog = heraia_get_widget(main_window->xmls->main, "about_dialog");
00250         
00251         if (about_dialog != NULL)
00252         {
00253                 record_and_hide_dialog_box(about_dialog, main_window->win_prop->about_box);
00254         }
00255 }
00256 
00257 
00258 /**
00259  * @fn void a_propos_response(GtkWidget *widget, gint response, gpointer data)
00260  *  To close the A propos dialog box (with the "close" button)
00261  * @param widget : calling widget (may be NULL as we don't use this)
00262  * @param response : may be whatever you want as we neither use this !
00263  * @param data : MUST be heraia_window_t *main_window main structure
00264  */
00265 static void a_propos_response(GtkWidget *widget, gint response, gpointer data)
00266 {
00267         heraia_window_t *main_window = (heraia_window_t *) data;
00268         record_and_hide_about_box(main_window);
00269 }
00270 
00271 /**
00272  * @fn void a_propos_close(GtkWidget *widget, gpointer data)
00273  *  To close the A propos dialog box
00274  * @param widget : calling widget (may be NULL as we don't use this)
00275  * @param data : MUST be heraia_window_t *main_window main structure
00276  */
00277 static void a_propos_close(GtkWidget *widget, gpointer data)
00278 {
00279         heraia_window_t *main_window = (heraia_window_t *) data;
00280         record_and_hide_about_box(main_window);
00281 }
00282 
00283 
00284 /**
00285  * @fn gboolean a_propos_delete(GtkWidget *widget, GdkEvent  *event, gpointer data)
00286  *  To close the A propos dialog box
00287  * @param widget : calling widget (may be NULL as we don't use this)
00288  * @param event : event associated (may be NULL as we don't use this)
00289  * @param data : MUST be heraia_window_t *main_window main structure
00290  * @return returns TRUE in order to allow other functions to do something with
00291  *         that event.
00292  */
00293 static gboolean a_propos_delete(GtkWidget *widget, GdkEvent  *event, gpointer data)
00294 {
00295         heraia_window_t *main_window = (heraia_window_t *) data;
00296         record_and_hide_about_box(main_window);
00297         
00298         return TRUE;
00299 }
00300 
00301 
00302 /**
00303  * @fn void on_delete_activate(GtkWidget *widget, gpointer data)
00304  *  Delete, edit menu
00305  * @warning Not yet implemented
00306  * @todo Write a usefull function here :)
00307  * @param widget : the widget that issued the signal
00308  * @param data : user data MUST be heraia_window_t *main_window main structure
00309  */
00310 void on_delete_activate(GtkWidget *widget, gpointer data)
00311 {
00312         heraia_window_t *main_window = (heraia_window_t *) data;
00313         
00314         log_message(main_window, G_LOG_LEVEL_WARNING, "Not implemented Yet (Please contribute !)");
00315 }
00316 
00317 /**
00318  * @fn void on_cut_activate(GtkWidget *widget, gpointer data)
00319  *  Cut, edit menu
00320  * @warning Not yet implemented
00321  * @todo Write a usefull function here :)
00322  * @param widget : the widget that issued the signal
00323  * @param data : user data MUST be heraia_window_t *main_window main structure
00324  */
00325 void on_cut_activate(GtkWidget *widget, gpointer data)
00326 {
00327         heraia_window_t *main_window = (heraia_window_t *) data;
00328         
00329         log_message(main_window, G_LOG_LEVEL_WARNING, "Not implemented Yet (Please contribute !)");
00330 }
00331 
00332 /**
00333  * @fn void on_copy_activate( GtkWidget *widget, gpointer data )
00334  *  Copy, edit menu
00335  * @warning Not yet implemented
00336  * @todo Write a usefull function here :)
00337  * @param widget : the widget that issued the signal
00338  * @param data : user data MUST be heraia_window_t *main_window main structure
00339  */
00340 void on_copy_activate(GtkWidget *widget, gpointer data)
00341 {
00342         heraia_window_t *main_window = (heraia_window_t *) data;
00343         
00344         log_message(main_window, G_LOG_LEVEL_WARNING, "Not implemented Yet (Please contribute !)");
00345 }
00346 
00347 
00348 /**
00349  * @fn void on_paste_activate( GtkWidget *widget, gpointer data )
00350  *  Paste, edit menu
00351  * @warning Not yet implemented
00352  * @todo Write a usefull function here :)
00353  * @param widget : the widget that issued the signal
00354  * @param data : user data MUST be heraia_window_t *main_window main structure
00355  */
00356 void on_paste_activate(GtkWidget *widget, gpointer data)
00357 {
00358         heraia_window_t *main_window = (heraia_window_t *) data;
00359         
00360         log_message(main_window, G_LOG_LEVEL_WARNING, "Not implemented Yet (Please contribute !)");
00361 }
00362 
00363 
00364 /**
00365  * @fn void refresh_file_labels(heraia_window_t *main_window)
00366  *  This function is refreshing the labels on the main
00367  *  window in order to reflect cursor position, selected
00368  *  positions and total selected size
00369  * @param main_window : main structure
00370  */
00371 void refresh_file_labels(heraia_window_t *main_window)
00372 {
00373         GtkWidget *label = NULL;
00374         guint64 position = 0;
00375         gchar *text = NULL;
00376         
00377         if (main_window != NULL)
00378                 {
00379                         if (main_window->current_DW != NULL && main_window->current_DW->current_hexwidget != NULL)
00380                                 {
00381                                         label = heraia_get_widget(main_window->xmls->main, "file_position_label");
00382                                         position = ghex_get_cursor_position(main_window->current_DW);
00383                                         /* position begins at 0 and this is not really human readable */
00384                                         /* it's more confusing than anything so we do + 1             */
00385                                         /* To translators : do not translate <small> and such         */
00386                                         
00387                                         if (is_toggle_button_activated(main_window->xmls->main, "mp_thousand_bt") == TRUE)
00388                                         {
00389                                                 text = g_strdup_printf("<small>%'lld</small>", position + 1);
00390                                         }
00391                                         else
00392                                         {
00393                                                 text = g_strdup_printf("<small>%lld</small>", position + 1);
00394                                         }
00395                                         gtk_label_set_markup(GTK_LABEL(label), text);
00396                                         g_free(text);
00397                                 }
00398                         else
00399                                 {
00400                                         label = heraia_get_widget(main_window->xmls->main, "file_position_label");
00401                                         gtk_label_set_text(GTK_LABEL(label), "");
00402                                 }
00403                 }
00404 }
00405 
00406 
00407 /** 
00408  * @fn void refresh_event_handler(GtkWidget *widget, gpointer data)
00409  *  This function is here to ensure that everything will be
00410  *  refreshed upon a signal event.
00411  * @warning This function is not thread safe (do not use in a thread)
00412  * @todo try to put some mutexes on main_window->event to make this
00413  *       thread safe some way
00414  * @param widget : the widget that issued the signal
00415  * @param data : user data MUST be heraia_window_t *main_window main structure
00416  */
00417 void refresh_event_handler(GtkWidget *widget, gpointer data)
00418 {
00419         heraia_window_t *main_window = (heraia_window_t *) data;
00420         
00421         if (main_window != NULL)
00422         {
00423                 /* Beware, this mechanism is not thread safe ! */
00424                 if (main_window->event == HERAIA_REFRESH_NOTHING)
00425                 {
00426                         main_window->event = HERAIA_REFRESH_CURSOR_MOVE;
00427                 }
00428                 
00429                 refresh_data_interpretor_window(widget, main_window);
00430                 refresh_all_plugins(main_window);
00431                 refresh_file_labels(main_window);
00432                 
00433                 main_window->event = HERAIA_REFRESH_NOTHING;
00434         }
00435 }
00436 
00437 
00438 /**
00439  * @fn void on_open_activate(GtkWidget *widget, gpointer data)
00440  *  This handles the menuitem "Ouvrir" to open a file
00441  * @warning This function is not thread safe (do not use in a thread)
00442  * @todo try to put some mutexes on main_window->event to make this
00443  *       thread safe some way
00444  * @param widget : the widget that issued the signal
00445  * @param data : user data MUST be heraia_window_t *main_window main structure
00446  */
00447 void on_open_activate(GtkWidget *widget, gpointer data)
00448 {
00449         heraia_window_t *main_window = (heraia_window_t *) data;
00450         
00451         if (select_file_to_load(main_window) == TRUE)
00452         {
00453                 load_file_to_analyse(main_window, main_window->filename);
00454         
00455             /* Not thread safe here ? */
00456             main_window->event = HERAIA_REFRESH_NEW_FILE;
00457             refresh_event_handler(main_window->current_DW->current_hexwidget, main_window);
00458         }
00459 }
00460 
00461 
00462 /**
00463  * @fn void on_save_activate(GtkWidget *widget, gpointer data)
00464  *  Here we attemp to save the edited file
00465  *  @todo be more accurate on error (error type, message and filename) returns
00466  *        we should return something at least ...
00467  * @param widget : the widget that issued the signal
00468  * @param data : user data MUST be heraia_window_t *main_window main structure
00469  */
00470 void on_save_activate(GtkWidget *widget, gpointer data)
00471 {
00472         heraia_window_t *main_window = (heraia_window_t *) data;        
00473         HERAIA_ERROR erreur = HERAIA_NOERR;
00474         gchar *filename = NULL;
00475         
00476         if (main_window != NULL && main_window->current_doc != NULL)
00477         {
00478                 erreur = heraia_hex_document_save(main_window); 
00479 
00480                 if (erreur != HERAIA_NOERR)
00481                 {
00482                         filename = heraia_hex_document_get_filename(main_window->current_doc);
00483                         log_message(main_window, G_LOG_LEVEL_ERROR, "Error while saving file %s !", filename);
00484                 }
00485         }
00486 }
00487 
00488 /**
00489  * @fn void on_save_as_activate(GtkWidget *widget, gpointer data)
00490  *  This handle the save_as menu entry (here the filename changes)
00491  * @param widget : the widget that issued the signal
00492  * @param data : user data MUST be heraia_window_t *main_window main structure
00493  */
00494 void on_save_as_activate(GtkWidget *widget, gpointer data)
00495 {
00496         heraia_window_t *main_window = (heraia_window_t *) data;
00497         HERAIA_ERROR erreur = HERAIA_NOERR;
00498         gchar *filename = NULL;  /* Auto malloc'ed, do not free */
00499 
00500         if (main_window != NULL && main_window->current_doc != NULL)
00501         {
00502                 filename = select_a_file_to_save(main_window);
00503                 
00504                 if (filename != NULL)
00505                 {
00506                         erreur = heraia_hex_document_save_as(main_window, filename);
00507                 }
00508                 else
00509                 {
00510                         erreur = HERAIA_CANCELLED;
00511                 }
00512                 
00513                 if (erreur != HERAIA_NOERR)
00514                 {
00515                         if (erreur == HERAIA_CANCELLED)
00516                         {
00517                                 log_message(main_window, G_LOG_LEVEL_DEBUG, "Saving file as... : operation cancelled.");
00518                         }
00519                         else
00520                         {
00521                                 log_message(main_window, G_LOG_LEVEL_ERROR, "Error while saving file as %s", main_window->current_doc->file_name);
00522                         }
00523                 }
00524                 else
00525                 {
00526                         /* updating the window name and tab's name */
00527                         update_main_window_name(main_window);
00528                         set_notebook_tab_name(main_window);
00529                         log_message(main_window, G_LOG_LEVEL_DEBUG, "File %s saved and now edited.", main_window->current_doc->file_name);
00530                 }
00531         }
00532 }
00533 
00534 
00535 /**
00536  * @fn void on_DIMenu_activate(GtkWidget *widget, gpointer data)
00537  *  This handles the menuitem "Data Interpretor" that
00538  *  shows or hides the data interpretor window     
00539  * @param widget : the widget that issued the signal
00540  * @param data : user data MUST be heraia_window_t *main_window main structure
00541  */
00542 void on_DIMenu_activate(GtkWidget *widget, gpointer data)
00543 {
00544         
00545         heraia_window_t *main_window = (heraia_window_t *) data;
00546         data_window_t *dw = NULL;      /* program structure           */
00547         GtkNotebook *notebook = NULL;  /* data interpretor's notebook */
00548         
00549         if (main_window != NULL)
00550         {
00551                 dw = main_window->current_DW;
00552                 
00553                 if (dw != NULL)
00554                 {
00555                         if (dw->diw == NULL)
00556                         {
00557                                 dw->diw = heraia_get_widget(main_window->xmls->main, "data_interpretor_window");
00558                         }
00559                         
00560                         if (dw->diw != NULL)
00561                         {
00562                                 /* dw->window_displayed = !(dw->window_displayed); */
00563                                 notebook = GTK_NOTEBOOK(heraia_get_widget(main_window->xmls->main, "diw_notebook"));
00564                                 
00565                         if (main_window->win_prop->data_interpretor->displayed == FALSE)
00566                                 {
00567                                         /* Setting the first page of the notebook as default (Numbers) */                                       
00568                                         gtk_notebook_set_current_page(notebook, dw->tab_displayed);
00569                                         
00570                                         /* moving to the right position */
00571                                         move_and_show_dialog_box(dw->diw, main_window->win_prop->data_interpretor);
00572                                         
00573                                         refresh_data_interpretor_window(widget, data);
00574                                 }
00575                                 else
00576                                 {
00577                                         /* recording some prefs from the dialog : position + opened tab */
00578                                         dw->tab_displayed = gtk_notebook_get_current_page(notebook);
00579                                         record_and_hide_dialog_box(dw->diw, main_window->win_prop->data_interpretor);
00580                                 }
00581                         }
00582                 }
00583         }
00584 }
00585 
00586 
00587 /**
00588  * @fn delete_main_window_event(GtkWidget *widget, GdkEvent  *event, gpointer data)
00589  *  When the user destroys or delete the main window
00590  * @param widget : calling widget 
00591  * @param event : event associated (may be NULL as we don't use this here)
00592  * @param data : MUST be heraia_window_t *main_window main structure
00593  */
00594 gboolean delete_main_window_event(GtkWidget *widget, GdkEvent  *event, gpointer data)
00595 {
00596                 
00597         on_quit_activate(widget, data);
00598         
00599         return FALSE;
00600 }
00601 
00602 
00603 /**
00604  * @fn gboolean delete_dt_window_event(GtkWidget *widget, GdkEvent  *event, gpointer data)
00605  *  call back function for the data interpretor window destruction
00606  * @param widget : calling widget (may be NULL as we don't use this here)
00607  * @param event : event associated (may be NULL as we don't use this here)
00608  * @param data : MUST be heraia_window_t *main_window main structure and not NULL
00609  */
00610 gboolean delete_dt_window_event(GtkWidget *widget, GdkEvent  *event, gpointer data)
00611 {       
00612         heraia_window_t *main_window = (heraia_window_t *) data;
00613         
00614         g_signal_emit_by_name(heraia_get_widget(main_window->xmls->main, "DIMenu"), "activate");
00615         
00616         return TRUE;
00617 }
00618 
00619 /**
00620  * @fn void destroy_dt_window(GtkWidget *widget, GdkEvent  *event, gpointer data)
00621  *  call back function for the data interpretor window destruction
00622  * @param widget : calling widget (may be NULL as we don't use this here)
00623  * @param event : event associated (may be NULL as we don't use this here)
00624  * @param data : MUST be heraia_window_t *main_window main structure and not NULL
00625  */
00626 void destroy_dt_window(GtkWidget *widget, GdkEvent  *event, gpointer data)
00627 {
00628         heraia_window_t *main_window = (heraia_window_t *) data;
00629         
00630         g_signal_emit_by_name(heraia_get_widget(main_window->xmls->main, "DIMenu"), "activate");
00631 }
00632 /* End of call back functions that handle the data interpretor window */
00633 
00634 
00635 /**
00636  * @fn static gchar *make_absolute_path(gchar *filename)
00637  *  Returns an absolute path to the filename
00638  *  the string should be freed when no longer needed
00639  *  very UGLy !
00640  * @todo do something without any system calls !!! 
00641  * @param filename : relative notation filename from which to extract an
00642  *        absolute path
00643  * @return returns a string with the absolute path which should be freed when
00644  *         no longer needed
00645  */
00646 static gchar *make_absolute_path(gchar *filename)
00647 {
00648         gchar *current_dir = NULL;
00649         gchar *new_dir = NULL;
00650         
00651         if (g_path_is_absolute(filename) == TRUE)
00652         {
00653                 /* if the filename is already in an absolute format */
00654                 return  g_path_get_dirname(filename);
00655         }
00656         else
00657         {
00658                 current_dir = g_get_current_dir();
00659                 new_dir = g_path_get_dirname(filename);
00660                 
00661                 if (g_chdir(new_dir) == 0)
00662                 {
00663                         g_free(new_dir);
00664                         new_dir = g_get_current_dir();
00665                         g_chdir(current_dir);
00666                         g_free(current_dir);
00667                         
00668                         return new_dir;
00669                 }
00670                 else
00671                 {
00672                         g_free(current_dir);
00673                         
00674                         return NULL;
00675                 }
00676         }
00677 }
00678 
00679 
00680 /**
00681  * @fn void set_the_working_directory(GtkFileChooser *file_chooser, gchar *filename)
00682  *  Sets the working directory for the file chooser to the directory of the
00683  *  filename (even if filename is a relative filename such as ../docs/test_file)
00684  * @param file_chooser : An initialized GtkFileChooser
00685  * @param filename : a filename (one previously openned)
00686  */
00687 static void set_the_working_directory(GtkFileChooser *file_chooser, gchar *filename)
00688 {
00689         gchar *dirname = NULL;    /* directory where we want to be, at first, in the file chooser */
00690         
00691         dirname = make_absolute_path(filename);
00692         
00693         if (dirname != NULL)
00694         {
00695                 gtk_file_chooser_set_current_folder(file_chooser, dirname);
00696                 g_free(dirname);
00697         }
00698 }
00699 
00700 
00701 /**
00702  * @fn gboolean select_file_to_load(heraia_window_t *main_window)
00703  *  This function does open a file selector dialog box and returns the selected 
00704  *  filename. 
00705  *  We do fill the main_window->filename parameter here !
00706  * @param main_window : main structure
00707  * @return returns TRUE if everything went ok, FALSE otherwise
00708  */
00709 gboolean select_file_to_load(heraia_window_t *main_window)
00710 {
00711         GtkWidget *parent = NULL; /* A parent window (we use main_window)      */
00712         GtkFileChooser *file_chooser = NULL;
00713         gboolean success = FALSE;
00714         gchar *filename = NULL;   /* filename selected (if any) to be openned  */
00715         
00716         parent = heraia_get_widget(main_window->xmls->main, "main_window");
00717         
00718         file_chooser = GTK_FILE_CHOOSER(gtk_file_chooser_dialog_new("Select a file to analyse",
00719                                                                                                                                 GTK_WINDOW(parent),
00720                                                                                                                                 GTK_FILE_CHOOSER_ACTION_OPEN, 
00721                                                                                                                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
00722                                                                                                                                 GTK_STOCK_OPEN, GTK_RESPONSE_OK, 
00723                                                                                                                                 NULL));
00724         
00725         /**
00726          *  for the moment we do not want to retrieve multiples selections 
00727          *  but this could be a valuable thing in the future
00728          */
00729         gtk_window_set_modal(GTK_WINDOW(file_chooser), TRUE);
00730         gtk_file_chooser_set_select_multiple(file_chooser, FALSE);
00731         
00732         /**
00733          *  We want the file selection path to be the one of the previous
00734          *  openned file if any !
00735          */
00736         if (main_window->filename != NULL)
00737            {
00738                         set_the_working_directory(file_chooser, main_window->filename);
00739            }
00740         
00741         switch (gtk_dialog_run(GTK_DIALOG(file_chooser))) 
00742           {
00743                 case GTK_RESPONSE_OK:
00744                         filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
00745                         log_message(main_window, G_LOG_LEVEL_DEBUG, "filename selected : %s", filename);
00746                         
00747                         /* this should be managed with lists and not here !! */         
00748                         if (main_window->filename != NULL)
00749                        {
00750                                         g_free(main_window->filename);
00751                        }
00752                         
00753                         main_window->filename = g_strdup_printf("%s", filename);
00754                         success = TRUE;
00755                  break;
00756                 case GTK_RESPONSE_CANCEL:
00757                 default:
00758                         success = FALSE;
00759                  break;
00760            }
00761         
00762         g_free(filename);
00763         gtk_widget_destroy(GTK_WIDGET(file_chooser));
00764         
00765         return success;
00766 }
00767 
00768 /**
00769  * @fn gchar *select_a_file_to_save(heraia_window_t *main_window)
00770  *  This function opens a dialog box that allow one to choose a 
00771  *  file name to the file which is about to be saved
00772  * @param main_window : main structure
00773  * @return returns complete filename (path and filename)
00774  */
00775 gchar *select_a_file_to_save(heraia_window_t *main_window)
00776 {
00777         GtkWidget *parent = NULL;     /* A parent window (we use main_window) */
00778         GtkFileChooser *fcd = NULL;
00779         gchar *filename = NULL; 
00780 
00781         parent = heraia_get_widget(main_window->xmls->main, "main_window");
00782         
00783         /* Selection a name to the file to save */
00784         fcd = GTK_FILE_CHOOSER(gtk_file_chooser_dialog_new("Save As...",
00785                                                                                                            GTK_WINDOW(parent),
00786                                                                                                            GTK_FILE_CHOOSER_ACTION_SAVE, 
00787                                                                                                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
00788                                                                                                            GTK_STOCK_SAVE, GTK_RESPONSE_OK, 
00789                                                                                                            NULL));
00790 
00791         /* window properties : modal, without multi-selection and with confirmation */
00792         gtk_window_set_modal(GTK_WINDOW(fcd), TRUE);
00793         gtk_file_chooser_set_select_multiple(fcd, FALSE);
00794         gtk_file_chooser_set_do_overwrite_confirmation(fcd, TRUE);
00795 
00796         /* we do want to have the file's directory where to save the new file */
00797         if (main_window->filename != NULL)
00798            {
00799                         set_the_working_directory(fcd, main_window->filename);
00800            }
00801         
00802         switch(gtk_dialog_run(GTK_DIALOG(fcd)))
00803                 {
00804                 case GTK_RESPONSE_OK:
00805                         /* retrieving the filename */
00806                         filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fcd));
00807                         break;
00808                 default:
00809                         filename = NULL;
00810                         break;
00811                 }
00812 
00813         gtk_widget_destroy(GTK_WIDGET(fcd));
00814 
00815         return filename;
00816 }
00817 
00818 
00819 /**
00820  * @fn void update_main_window_name(heraia_window_t *main_window)
00821  *  Update main window heraia's name to reflect the current edited file
00822  * @param main_window : main structure
00823  */
00824 void update_main_window_name(heraia_window_t *main_window)
00825 {
00826         GtkWidget *widget = NULL;
00827         gchar *filename = NULL;
00828         
00829         if (main_window != NULL && main_window->current_doc != NULL)
00830            {
00831                         widget = heraia_get_widget(main_window->xmls->main, "main_window");
00832                     filename = g_filename_display_basename(main_window->current_doc->file_name);
00833                    
00834                         gtk_window_set_title(GTK_WINDOW(widget), filename);
00835            }
00836 }
00837 
00838 /**
00839  * @fn void set_notebook_tab_name(heraia_window_t *main_window)
00840  *  Sets notebook's tab's name. This function should only be called
00841  *  when a new filename was set (open and save as functions)
00842  * @param main_window : main structure
00843  */
00844 void set_notebook_tab_name(heraia_window_t *main_window)
00845 {
00846         GtkWidget *notebook = NULL; /* file notebook in main window       */
00847         GtkWidget *page = NULL;     /* Current page for the file notebook */
00848         GtkWidget *label = NULL;    /* tab's label                        */
00849         gchar *filename = NULL;
00850         gint current = 0;
00851         
00852         if (main_window != NULL && main_window->current_doc != NULL)
00853            {
00854                    notebook = heraia_get_widget(main_window->xmls->main, "file_notebook");
00855                    current = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
00856                    page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), current);
00857                    label = gtk_notebook_get_tab_label(GTK_NOTEBOOK(notebook), page);
00858                    filename = g_filename_display_basename(main_window->current_doc->file_name);
00859                    gtk_label_set_text(GTK_LABEL(label), filename);
00860                    
00861                    /* gtk_widget_set_tooltip_text is available since gtk 2.12 */
00862                    if (GTK_MINOR_VERSION >= 12) 
00863                         { 
00864                                 gtk_widget_set_tooltip_text(label, g_filename_display_name(main_window->current_doc->file_name));
00865                         }
00866            }
00867 }
00868 
00869 
00870 /**
00871  * @fn init_heraia_interface(heraia_window_t *main_window)
00872  *  Here we might init some call backs and menu options
00873  *  and display the interface (main && sub-windows)
00874  *  This function should be called only once at main program's 
00875  *  init time
00876  * @param main_window : main structure
00877  */
00878 void init_heraia_interface(heraia_window_t *main_window)
00879 {
00880         GtkWidget *notebook = NULL;  /* file notebook in main window */
00881         
00882         if (main_window != NULL)
00883         {
00884                 /* inits window states (shows or hide windows) */
00885                 init_window_states(main_window);
00886                 
00887                 /* Notebook selection */
00888                 notebook = heraia_get_widget(main_window->xmls->main, "file_notebook");
00889                 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
00890                 
00891                 if (main_window->current_doc != NULL)
00892                 {
00893                         gtk_widget_show(notebook);
00894                 }
00895                 else
00896                 {
00897                         /** Hide notebook and menus @todo put these lines in a specific function */
00898                         gtk_widget_set_sensitive(heraia_get_widget(main_window->xmls->main, "save"), FALSE);
00899                         gtk_widget_set_sensitive(heraia_get_widget(main_window->xmls->main, "save_as"), FALSE);                          
00900                         gtk_widget_hide(notebook); 
00901                 }
00902                 
00903                 refresh_file_labels(main_window);
00904         }
00905 }
00906 
00907 
00908 /**
00909  * @fn gboolean load_heraia_glade_xml(heraia_window_t *main_window)
00910  *  Loads the glade xml files that describes the heraia project
00911  *  tries the following paths in that order :                 
00912  *  - /etc/heraia/heraia.glade
00913  *  - /home/[user]/.heraia/heraia.glade
00914  *  - PWD/heraia.glade
00915  * @param main_window : main structure
00916  * @return TRUE if everything went ok, FALSE otherwise
00917  */
00918 static gboolean load_heraia_glade_xml(heraia_window_t *main_window)
00919 {
00920         gchar *filename = NULL;
00921         
00922         if (main_window != NULL && main_window->xmls != NULL)
00923         {
00924                 filename = g_strdup_printf("heraia.glade"); 
00925                 main_window->xmls->main = load_glade_xml_file(main_window->location_list, filename);
00926                 g_free(filename);
00927                 
00928                 if (main_window->xmls->main == NULL)
00929                 {
00930                         return FALSE;
00931                 }
00932                 else
00933                 {
00934                         return TRUE;
00935                 }
00936         }
00937         else
00938         {
00939                 return FALSE;
00940         }
00941 }
00942 
00943 /**
00944  * @fn connect_cursor_moved_signal(heraia_window_t *main_window)
00945  *  Connects the signal that the cursor has moved to
00946  *  the refreshing function
00947  * @param main_window : main structure 
00948  */
00949 void connect_cursor_moved_signal(heraia_window_t *main_window)
00950 {
00951         g_signal_connect(G_OBJECT(main_window->current_DW->current_hexwidget), "cursor_moved",   
00952                                          G_CALLBACK(refresh_event_handler), main_window);
00953 }
00954 
00955 
00956 /**
00957  * @fn void heraia_ui_connect_signals(heraia_window_t *main_window)
00958  *  Connect the signals at the interface
00959  * @param main_window : main structure
00960  */
00961 static void heraia_ui_connect_signals(heraia_window_t *main_window)
00962 {
00963         
00964         /* the data interpretor menu */
00965         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "DIMenu")), "activate", 
00966                                           G_CALLBACK (on_DIMenu_activate), main_window);
00967         
00968         /* Quit, file menu */
00969         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "quit")), "activate", 
00970                                           G_CALLBACK (on_quit_activate), main_window);
00971         
00972         /* New, file menu */
00973         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "new")), "activate",  
00974                                           G_CALLBACK (on_new_activate), main_window);
00975         
00976         /* Open, file menu */
00977         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "open")), "activate",  
00978                                           G_CALLBACK (on_open_activate), main_window);
00979         
00980         /* Save, file menu */
00981         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "save")), "activate",  
00982                                           G_CALLBACK (on_save_activate), main_window);
00983         
00984         /* Save As, file menu */
00985         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "save_as")), "activate",  
00986                                           G_CALLBACK (on_save_as_activate), main_window); 
00987         
00988         /* Preferences, file menu ; See main_pref_window.c for main_pref_window's signals */
00989         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "preferences")), "activate",  
00990                                           G_CALLBACK (on_preferences_activate), main_window);
00991         
00992         /* Cut, edit menu */
00993         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "cut")), "activate",  
00994                                           G_CALLBACK (on_cut_activate), main_window); 
00995         
00996         /* Copy, edit menu */
00997         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "copy")), "activate",  
00998                                           G_CALLBACK (on_copy_activate), main_window); 
00999         
01000         /* Paste, edit menu */
01001         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "paste")), "activate",  
01002                                           G_CALLBACK (on_paste_activate), main_window); 
01003         
01004         /* Delete, edit menu */
01005         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "delete")), "activate",  
01006                                           G_CALLBACK (on_delete_activate), main_window); 
01007         
01008         
01009         /* about dialog box */          
01010         g_signal_connect (G_OBJECT(heraia_get_widget(main_window->xmls->main, "a_propos")), "activate",  
01011                                           G_CALLBACK(a_propos_activate), main_window); 
01012         
01013         g_signal_connect(G_OBJECT(heraia_get_widget(main_window->xmls->main, "about_dialog")), "close",
01014                                          G_CALLBACK(a_propos_close), main_window);
01015         
01016         g_signal_connect(G_OBJECT(heraia_get_widget(main_window->xmls->main, "about_dialog")), "response",
01017                                          G_CALLBACK(a_propos_response), main_window);
01018         
01019         g_signal_connect(G_OBJECT(heraia_get_widget(main_window->xmls->main, "about_dialog")), "delete-event",
01020                                          G_CALLBACK(a_propos_delete), main_window);
01021         
01022         
01023         /* main window killed or destroyed */
01024         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "main_window")), "delete-event", 
01025                                           G_CALLBACK (delete_main_window_event), main_window);
01026         
01027         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "main_window")), "response", 
01028                                           G_CALLBACK (delete_main_window_event), main_window);
01029         
01030         g_signal_connect (G_OBJECT (heraia_get_widget(main_window->xmls->main, "main_window")), "close", 
01031                                           G_CALLBACK (on_quit_activate), main_window);
01032 }
01033 
01034 /** @fn int load_heraia_ui(heraia_window_t *main_window)
01035  *  Loads, if possible, the glade xml file and then connects the
01036  *  signals and inits the following windows :
01037  *  - log window
01038  *  - data_interpretor window
01039  *  - list data types
01040  * @param main_window : main structure
01041  * @return TRUE if load_heraia_glade suceeded, FALSE otherwise
01042  * @todo add more return values to init functions to detect any error while
01043  *       initializing the ui
01044  */
01045 int load_heraia_ui(heraia_window_t *main_window)
01046 {
01047         gboolean success = FALSE;
01048         
01049         /* load the XML interfaces (main & treatment) */
01050         success = load_heraia_glade_xml(main_window);
01051         
01052         if (success == TRUE)
01053         {
01054                 /* Heraia UI signals */
01055                 if (main_window->debug == TRUE)
01056                 {
01057                         fprintf(stdout, "Connecting heraia_ui signals     ");
01058                 }
01059                 
01060                 heraia_ui_connect_signals(main_window);
01061                 
01062                 if (main_window->debug == TRUE)
01063                 {
01064                         fprintf(stdout, " [Done]\n");
01065                 }
01066                 
01067                 /* The Log window */
01068                 if (main_window->debug == TRUE)
01069                 {
01070                         fprintf(stdout, "log window init interface        ");
01071                 }
01072                 
01073                 log_window_init_interface(main_window);
01074                 
01075                 if (main_window->debug == TRUE)
01076                 {
01077                         fprintf(stdout, " [Done]\n");
01078                 }
01079                 
01080                 /* Preferences window */
01081                 if (main_window->debug == TRUE)
01082                 {
01083                         fprintf(stdout, "preferences window init interface");
01084                 }
01085                 
01086                 main_pref_window_init_interface(main_window);
01087                 
01088                 if (main_window->debug == TRUE)
01089                 {
01090                         fprintf(stdout, " [Done]\n");
01091                 }
01092                 
01093                 
01094                 /* The data interpretor window */
01095                 if (main_window->debug == TRUE)
01096                 {
01097                         fprintf(stdout, "data interpretor init interface  ");
01098                 }
01099                 
01100                 data_interpretor_init_interface(main_window);
01101                 
01102                 if (main_window->debug == TRUE)
01103                 {
01104                         fprintf(stdout, " [Done]\n");
01105                 }
01106                 
01107                 
01108                 /* The list data types window */
01109                 if (main_window->debug == TRUE)
01110                 {
01111                         fprintf(stdout, "list data types init interface   ");
01112                 }
01113                 
01114                 list_data_types_init_interface(main_window);
01115                 
01116                 if (main_window->debug == TRUE)
01117                 {
01118                         fprintf(stdout, " [Done]\n");
01119                 }
01120                 
01121                 
01122                 /* The data type window (create or edit one type) */
01123                 if (main_window->debug == TRUE)
01124                 {
01125                         fprintf(stdout, "data type init interface         ");
01126                 }
01127                 
01128                 data_type_init_interface(main_window);
01129                 
01130                 if (main_window->debug == TRUE)
01131                 {
01132                         fprintf(stdout, " [Done]\n");
01133                 }
01134                 
01135                 fprintf(stdout, "Loading heraia preference file   ");
01136                 
01137                 if (load_preference_file(main_window) != TRUE)
01138                 {
01139                         fprintf(stdout, " [FAILED]\n");
01140                 }
01141                 else /* Setting up preferences */
01142                 {
01143                         fprintf(stdout, " [Done]\n");
01144                         fprintf(stdout, "Setting up preferences           ");
01145                         load_preferences(main_window);
01146                         fprintf(stdout, " [Done]\n");
01147                 }
01148         }
01149         return success;
01150 }
01151 
01152 
01153 /**
01154  * @fn void add_text_to_textview(GtkTextView *textview, const char *format, ...)
01155  *  adds a text to a textview
01156  * @param textview : the textview where to add text
01157  * @param format : printf style format
01158  * @param ... : a va_list arguments to fit format (as with printf)
01159  */
01160 void add_text_to_textview(GtkTextView *textview, const char *format, ...)
01161 {       
01162         va_list args;
01163         GtkTextBuffer *tb = NULL;
01164         GtkTextIter iEnd;
01165         gchar *display = NULL;
01166         GError *err = NULL;
01167         
01168         va_start(args, format);
01169         display = g_locale_to_utf8(g_strdup_vprintf(format, args), -1, NULL, NULL, &err);
01170         va_end(args);
01171         
01172         tb = GTK_TEXT_BUFFER(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)));
01173         gtk_text_buffer_get_end_iter(tb, &iEnd);
01174         gtk_text_buffer_insert(tb, &iEnd, display, -1);
01175         g_free(display);
01176 }
01177 
01178 
01179 /**
01180  * @fn kill_text_from_textview(GtkTextView *textview)
01181  *  Kills the text from a textview
01182  * @param textview : the textview to kill the text from
01183  */
01184 void kill_text_from_textview(GtkTextView *textview)
01185 {
01186         GtkTextBuffer *tb = NULL;
01187         GtkTextIter iStart;
01188         GtkTextIter iEnd;
01189         
01190         tb = GTK_TEXT_BUFFER(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)));
01191         gtk_text_buffer_get_start_iter(tb, &iStart);
01192         gtk_text_buffer_get_end_iter(tb, &iEnd);
01193         gtk_text_buffer_delete (tb, &iStart, &iEnd);
01194 }
01195 
01196 
01197 /**
01198  * @fn GtkWidget *gtk_radio_button_get_active(GSList *group)
01199  *  Try to find the active radio button widget in a group
01200  *  This does not take into account inconsistant states
01201  *  returns the first active radio button otherwise NULL
01202  * @param group : A group of GtkRadioButtons
01203  * @return returns the active widget if any (NULL if none)
01204  */
01205 GtkWidget *gtk_radio_button_get_active(GSList *group)
01206 {
01207         GSList *tmp_slist = group;
01208         
01209         while (tmp_slist)
01210         {
01211                 if (GTK_TOGGLE_BUTTON (tmp_slist->data)->active)
01212                 {
01213                         return GTK_WIDGET (tmp_slist->data);
01214                 }
01215                 tmp_slist = tmp_slist->next;
01216         }
01217         
01218         return NULL;
01219 }
01220 
01221 
01222 /**
01223  * @fn GtkWidget *gtk_radio_button_get_active_from_widget(GtkRadioButton *radio_group_member)
01224  * gets the active radio button from a radio group
01225  * @param radio_group_member : widget to get radio group from
01226  * @returns the active GtkRadioButton within the group from
01227  *          radio_group_member
01228  **/
01229 GtkWidget *gtk_radio_button_get_active_from_widget(GtkRadioButton *radio_group_member)
01230 { 
01231         if (radio_group_member)
01232         {
01233                 return gtk_radio_button_get_active(radio_group_member->group);
01234         }
01235         else
01236         {
01237                 return NULL;
01238         }
01239 }
01240 
01241 
01242 /**
01243  * @fn gboolean is_cmi_checked(GtkWidget *check_menu_item)
01244  *  Tells whether a GtkCheckMenuItem is Checked or not
01245  * @param check_menu_item : a GtkCheckMenuItem to verify
01246  * @return returns TRUE if the Check Manu Item is checked, FALSE otherwise
01247  */
01248 gboolean is_cmi_checked(GtkWidget *check_menu_item)
01249 {
01250         return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(check_menu_item));
01251 }
01252 
01253 
01254 /**
01255  * @fn gboolean is_toggle_button_activated(GladeXML *main_xml, gchar *check_button)
01256  *  returns the state of a named check button contained 
01257  *  in the Glade XML description
01258  * @param main_xml : a GladeXML definition
01259  * @param check_button : the name of an existing check_button within the glade 
01260  *        definition
01261  * @return TRUE if the button is activated / toggled , FALSE otherwise
01262  */
01263 gboolean is_toggle_button_activated(GladeXML *main_xml, gchar *check_button)
01264 {
01265         gboolean activated = FALSE;
01266         
01267         if (main_xml != NULL)
01268         {
01269                 activated = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(heraia_get_widget(main_xml, check_button)));
01270         }
01271         
01272         return activated;
01273 }
01274 
01275 
01276 /**
01277  * @fn GtkWidget *heraia_get_widget(GladeXML *xml, gchar *widget_name)
01278  *  This is a wrapper to the glade xml get widget. It is intended
01279  *  to simplify the developpers lives if they have to choose or
01280  *  propose other means to do the same thing than libglade (say,
01281  *  for example, GtkBuilder :)
01282  * @param xml : A glade XML definition 
01283  * @param widget_name : an existing widget name in the glade definition
01284  * @return returns the widget itself if it exists in the definition file (NULL
01285  *         otherwise)
01286  */
01287 GtkWidget *heraia_get_widget(GladeXML *xml, gchar *widget_name)
01288 {
01289    /** 
01290         * For debug purposes only (very verbose as this function is the main used)
01291         * fprintf(stdout, "Getting Widget named %s\n", widget_name); 
01292         */
01293         
01294         if (xml != NULL && widget_name != NULL)
01295         {
01296                 return glade_xml_get_widget(xml, widget_name);
01297         }
01298         else
01299         {
01300                 return NULL;
01301         }
01302 }
01303 
01304 
01305 /**
01306  * @fn void destroy_a_single_widget(GtkWidget *widget)
01307  *  Destroys a single widget if it exists
01308  * @param widget : the widget to destroy
01309  */
01310 void destroy_a_single_widget(GtkWidget *widget)
01311 {
01312         if (widget != NULL)
01313         {
01314                 gtk_widget_destroy(widget);
01315         }
01316 }
01317 
01318 /**
01319  * @fn void close_heraia(heraia_window_t *main_window)
01320  * Before closing heraia we need to do few things
01321  * @param main_window : main_struct
01322  */
01323 static void close_heraia(heraia_window_t *main_window)
01324 {
01325 
01326         /* recording window's position */
01327         record_all_dialog_box_positions(main_window);
01328         
01329         /* . Saving preferences */
01330         save_preferences(main_window);
01331 }
01332 
01333 /**
01334  * @fn void init_one_cmi_window_state(GtkWidget *dialog_box, GtkWidget *cmi, window_prop_t *dialog_prop)
01335  * init one cmi window based state
01336  * @param dialog_box : the window or dialog box we want to init its state
01337  * @param cmi : corresponding check menu item 
01338  * @param dialog_prop : corresponding window properties (should be initialized and not NULL)
01339  */
01340 static void init_one_cmi_window_state(GtkWidget *dialog_box, GtkWidget *cmi, window_prop_t *dialog_prop)
01341 {
01342         gboolean activated = FALSE;
01343         
01344         if (dialog_box != NULL && cmi != NULL && dialog_prop != NULL)
01345         {
01346                 activated = dialog_prop->displayed;
01347                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(cmi), activated);
01348                 if (activated == TRUE)
01349                 {
01350                         gtk_window_move(GTK_WINDOW(dialog_box), dialog_prop->x, dialog_prop->y);
01351                         gtk_window_resize(GTK_WINDOW(dialog_box), dialog_prop->width, dialog_prop->height);
01352                         gtk_widget_show_all(dialog_box);
01353                 }
01354         }
01355 }
01356 
01357 
01358 /**
01359  * @fn init_window_states(heraia_window_t *main_window)
01360  *  Inits all windows states (positions, displayed, and so on...)
01361  * @param main_window : main structure
01362  */
01363 void init_window_states(heraia_window_t *main_window)
01364 {
01365         GtkWidget *cmi = NULL;
01366         GtkWidget *dialog_box = NULL;
01367         
01368         if (main_window != NULL && main_window->xmls != NULL  && main_window->xmls->main != NULL)
01369         {
01370                 if (main_window->win_prop)
01371                 {
01372                         /* Main window (always the first one) */
01373                         dialog_box = heraia_get_widget(main_window->xmls->main, "main_window");
01374                         if (main_window->win_prop->main_dialog->displayed == TRUE)
01375                         {
01376                                 gtk_window_move(GTK_WINDOW(dialog_box), main_window->win_prop->main_dialog->x, main_window->win_prop->main_dialog->y);
01377                                 gtk_window_resize(GTK_WINDOW(dialog_box), main_window->win_prop->main_dialog->width, main_window->win_prop->main_dialog->height);
01378                                 gtk_widget_show(dialog_box);
01379                         }
01380                         
01381                         /* Log Window Interface */
01382                         cmi = heraia_get_widget(main_window->xmls->main, "mw_cmi_show_logw");
01383                         dialog_box = heraia_get_widget(main_window->xmls->main, "log_window");
01384                         init_one_cmi_window_state(dialog_box, cmi, main_window->win_prop->log_box);
01385                         
01386                         /* Data Interpretor Interface */
01387                         cmi = heraia_get_widget(main_window->xmls->main, "DIMenu");
01388                         /* Emit the specific signal to activate the check_menu_item */
01389                         if (main_window->win_prop->data_interpretor->displayed == TRUE)
01390                         {
01391                                 main_window->win_prop->data_interpretor->displayed = FALSE; /* dirty trick */
01392                                 g_signal_emit_by_name(heraia_get_widget(main_window->xmls->main, "DIMenu"), "activate");
01393                         }
01394                 
01395                         /* List Data type Interface */
01396                         cmi = heraia_get_widget(main_window->xmls->main, "ldt_menu");
01397                         dialog_box = heraia_get_widget(main_window->xmls->main, "list_data_types_window");
01398                         init_one_cmi_window_state(dialog_box, cmi, main_window->win_prop->ldt);
01399                         
01400                         /* Plugin List Interface */
01401                         cmi = heraia_get_widget(main_window->xmls->main, "mw_cmi_plugin_list");
01402                         dialog_box = heraia_get_widget(main_window->xmls->main, "plugin_list_window");
01403                         init_one_cmi_window_state(dialog_box, cmi, main_window->win_prop->plugin_list);         
01404                         
01405                         /* Preferences window */
01406                         dialog_box = heraia_get_widget(main_window->xmls->main, "main_preferences_window");
01407                         if (main_window->win_prop->main_pref_window->displayed == TRUE)
01408                         {
01409                                 /* main_window->win_prop->main_pref_window->displayed = FALSE; dirty trick */
01410                                 gtk_window_move(GTK_WINDOW(dialog_box), main_window->win_prop->main_pref_window->x, main_window->win_prop->main_pref_window->y);
01411                                 gtk_window_resize(GTK_WINDOW(dialog_box), main_window->win_prop->main_pref_window->width, main_window->win_prop->main_pref_window->height);
01412                                 gtk_widget_show_all(dialog_box);
01413                         }
01414                         
01415                         /* About Box */
01416                         dialog_box = heraia_get_widget(main_window->xmls->main, "about_dialog");
01417                         if (main_window->win_prop->about_box->displayed == TRUE)
01418                         {
01419                                 /* main_window->win_prop->main_pref_window->displayed = FALSE; dirty trick */
01420                                 gtk_window_move(GTK_WINDOW(dialog_box), main_window->win_prop->about_box->x, main_window->win_prop->about_box->y); 
01421                                 gtk_window_resize(GTK_WINDOW(dialog_box), main_window->win_prop->about_box->width, main_window->win_prop->about_box->height);
01422                                 set_a_propos_properties(dialog_box);
01423                                 gtk_widget_show_all(dialog_box);
01424                         }
01425                 }
01426         }
01427 }

Generated on Sat Mar 14 13:44:29 2009 for Heraia by  doxygen 1.5.6