edit gtkspell.c so it complies a little bit more with main branch coding style
authorAlfons Hoogervorst <alfons@proteus.demon.nl>
Sun, 23 Sep 2001 12:31:49 +0000 (12:31 +0000)
committerAlfons Hoogervorst <alfons@proteus.demon.nl>
Sun, 23 Sep 2001 12:31:49 +0000 (12:31 +0000)
ChangeLog.claws
src/gtkspell.c

index c22f08b..276f4d0 100644 (file)
@@ -1,3 +1,8 @@
+2001-09-23 [alfons]
+       
+       * src/gtkspell.c
+               edit a little bit so it complies more with main coding style
+
 2001-09-23 [alfons]
 
        * src/folder.[ch], prefs_folder_item.c, compose.c
 2001-09-23 [alfons]
 
        * src/folder.[ch], prefs_folder_item.c, compose.c
index 109ea23..ddceea9 100644 (file)
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  */
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  */
-/*
-    Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
- */
 
 /*
 
 /*
+ * Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
  * Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto & 
  * The Sylpheed Claws Team.
  * Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto & 
  * The Sylpheed Claws Team.
+ * Adapted for pspell (c) 2001 Melvin Hadasht
  */
  */
-
-/*
- *  Adapted for pspell (c) 2001 Melvin Hadasht
- *
- */
 #if defined(HAVE_CONFIG_H)
 #include "config.h"
 #endif
 #if defined(HAVE_CONFIG_H)
 #include "config.h"
 #endif
 /* number of suggestions to display on each menu. */
 #define MENUCOUNT 15
 
 /* number of suggestions to display on each menu. */
 #define MENUCOUNT 15
 
-
-/* Only one config per session */
-
-GtkPspellConfig * gtkpspellconfig;
+/******************************************************************************/
 
 /* Function called from menus */
 
 
 /* Function called from menus */
 
-static void add_word_to_session(GtkWidget *w, GtkPspell * d);
-static void add_word_to_personal(GtkWidget *w, GtkPspell * d);
-static void set_sug_mode(GtkWidget *w, GtkPspell * gtkpspell);
-static void check_all(GtkWidget *w, GtkPspell * gtkpspell);
-static void menu_change_dict(GtkWidget *w, GtkPspell * gtkpspell);
+static void add_word_to_session                (GtkWidget *w, GtkPspell *d);
+static void add_word_to_personal       (GtkWidget *w, GtkPspell *d);
+static void set_sug_mode               (GtkWidget *w, GtkPspell *gtkpspell);
+static void check_all                  (GtkWidget *w, GtkPspell *gtkpspell);
+static void menu_change_dict           (GtkWidget *w, GtkPspell *gtkpspell);
+static void entry_insert_cb            (GtkXText *gtktext, gchar *newtext, 
+                                        guint len, guint *ppos, 
+                                        GtkPspell *gtkpspell);
 
 
-static GdkColor highlight = { 0, 255 * 256, 0, 0 };
+/* gtkspellconfig - only one config per session */
+GtkPspellConfig * gtkpspellconfig;
 
 
-static void entry_insert_cb(GtkXText *gtktext,
-                            gchar *newtext, guint len, guint *ppos, 
-                            GtkPspell *gtkpspell);
+/* TODO: configurable */
+static GdkColor highlight = { 0, 255 * 256, 0, 0 };
 
 
-/*  Run the first pspell_config from which every new config is */
-/*    cloned  */
+/******************************************************************************/
 
 
-GtkPspellConfig * gtkpspell_init(){
-  return new_pspell_config();
+/* gtkspell_init() - run the first pspell_config from which every
+ * new config is cloned 
+ */
+GtkPspellConfig * gtkpspell_init()
+{
+       return new_pspell_config();
 }
 
 }
 
-/* Finish all. No more spelling. Called when the program ends */
-
-void gtkpspell_finished(GtkPspellConfig * gtkpspellconfig){
-  if(gtkpspellconfig){
-    delete_pspell_config( gtkpspellconfig );
-    gtkpspellconfig = NULL;
-  }
+/* gtkspell_finished() - Finish all. No more spelling. Called when the 
+ * program ends 
+ */
+void gtkpspell_finished(GtkPspellConfig *gtkpspellconfig)
+{
+       if (gtkpspellconfig) {
+               delete_pspell_config(gtkpspellconfig);
+               gtkpspellconfig = NULL;
+       }
 }
 
 }
 
-
-/* Test if there is a manager running */
-
+/* gtkspell_running - Test if there is a manager running 
+ */
 int gtkpspell_running(GtkPspell * gtkpspell) 
 {
        return (gtkpspell->config!=NULL);
 }
 
 int gtkpspell_running(GtkPspell * gtkpspell) 
 {
        return (gtkpspell->config!=NULL);
 }
 
-/* Creates a new session if a gtkpspellconfig exists */
-/* The settings are defaults.  If no path/dict is set afterwards, the default one is used  */
+/* gtkspell_new() - creates a new session if a gtkpspellconfig exists. The 
+ * settings are defaults.  If no path/dict is set afterwards, the default 
+ * one is used  
+ */
+GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig)
+{
+       GtkPspell *gtkpspell;
+
+       if (gtkpspellconfig == NULL) {
+               gtkpspellconfig = gtkpspell_init();
+               if (gtkpspellconfig == NULL) {
+                       debug_print(_("Pspell could not be started."));
+                       prefs_common.enable_pspell=FALSE;
+                       return NULL;
+               }
+       }
 
 
-GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig){
-  GtkPspell *gtkpspell;
+       gtkpspell               = g_new(GtkPspell ,1);
+       gtkpspell->config       = gtkpspellconfig;
+       gtkpspell->possible_err = new_pspell_manager(gtkpspell->config);
+       gtkpspell->checker      = NULL;
 
 
-  if( gtkpspellconfig == NULL ){
-    gtkpspellconfig=gtkpspell_init();
-    if(gtkpspellconfig==NULL){
-      debug_print(_("Pspell could not be started."));
-      prefs_common.enable_pspell=FALSE;
-      return NULL;
-    }
-  }
-
-  gtkpspell               = g_new( GtkPspell ,1);
-  gtkpspell->config       = gtkpspellconfig;
-  gtkpspell->possible_err = new_pspell_manager( gtkpspell->config );
-  gtkpspell->checker      = NULL;
-
-  if( pspell_error_number( gtkpspell->possible_err ) != 0){
-    debug_print(_("Pspell error : %s\n"), pspell_error_message( gtkpspell->possible_err ));
-    delete_pspell_can_have_error( gtkpspell->possible_err );
-  }
-  else{
-    gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
-  }
+       if (pspell_error_number(gtkpspell->possible_err) != 0) {
+               debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err));
+               delete_pspell_can_have_error( gtkpspell->possible_err );
+       }
+       else {
+               gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err);
+       }
  
  
-  gtkpspell->dictionary_list = NULL;
-  gtkpspell->path            = NULL;
-  gtkpspell->dict            = NULL;
-  gtkpspell->mode            = PSPELL_FASTMODE;
-  gtkpspell->gtktext         = NULL;
-  return gtkpspell;
+       gtkpspell->dictionary_list = NULL;
+       gtkpspell->path            = NULL;
+       gtkpspell->dict            = NULL;
+       gtkpspell->mode            = PSPELL_FASTMODE;
+       gtkpspell->gtktext         = NULL;
+       return gtkpspell;
 }
 
 }
 
-/* Creates a new session and set path/dic */
-
+/* gtkspell_new_with_config() - Creates a new session and set path/dic 
+ */
 GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig, 
 GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig, 
-                                     guchar *path, 
-                                     guchar *dict, 
-                                     guint mode, 
-                                     guchar *encoding){
-  GtkPspell *gtkpspell;
-
-  if( gtkpspellconfig == NULL) {
-    gtkpspellconfig=gtkpspell_init();
-    if(gtkpspellconfig==NULL){
-      debug_print(_("Pspell could not be started."));
-      prefs_common.enable_pspell=FALSE;
-      return NULL;
-    }
-  }
+                                     guchar *path, guchar *dict, 
+                                     guint mode, guchar *encoding)
+{
+       GtkPspell *gtkpspell;
+
+       if (gtkpspellconfig == NULL) {
+               gtkpspellconfig=gtkpspell_init();
+               if (gtkpspellconfig == NULL) {
+                       debug_print(_("Pspell could not be started."));
+                       prefs_common.enable_pspell = FALSE;
+                       return NULL;
+               }
+       }
 
 
-  gtkpspell                  = g_new( GtkPspell ,1);
-  gtkpspell->path            = NULL;
-  gtkpspell->dict            = NULL;
-  gtkpspell->dictionary_list = NULL;
-  gtkpspell->gtktext         = NULL;
+       gtkpspell                  = g_new( GtkPspell ,1);
+       gtkpspell->path            = NULL;
+       gtkpspell->dict            = NULL;
+       gtkpspell->dictionary_list = NULL;
+       gtkpspell->gtktext         = NULL;
   
   
-  gtkpspell->config       = pspell_config_clone(gtkpspellconfig);
-  gtkpspell->mode = PSPELL_FASTMODE;
-  if(!set_path_and_dict(gtkpspell, gtkpspell->config, path, dict)){
-    debug_print(_("Pspell could not be configured."));
-    gtkpspell=gtkpspell_delete(gtkpspell);
-    return gtkpspell;
-  }
-  if(encoding)
-    pspell_config_replace(gtkpspell->config,"encoding",encoding);
-
-  gtkpspell->possible_err = new_pspell_manager( gtkpspell->config );
-  gtkpspell->checker      = NULL;
-
-  if( pspell_error_number( gtkpspell->possible_err ) != 0){
-    debug_print(_("Pspell error : %s\n"), pspell_error_message( gtkpspell->possible_err ));
-    delete_pspell_can_have_error( gtkpspell->possible_err );
-    gtkpspell=gtkpspell_delete(gtkpspell);
-  }
-  else{
-    gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
-  }
-  return gtkpspell;
-}
-
+       gtkpspell->config          = pspell_config_clone(gtkpspellconfig);
+       gtkpspell->mode            = PSPELL_FASTMODE;
+       
+       if (!set_path_and_dict(gtkpspell, gtkpspell->config, path, dict)) {
+               debug_print(_("Pspell could not be configured."));
+               gtkpspell = gtkpspell_delete(gtkpspell);
+               return gtkpspell;
+       }
+       
+       if (encoding)
+               pspell_config_replace(gtkpspell->config,"encoding",encoding);
 
 
-/* Finishes a session */
+       gtkpspell->possible_err = new_pspell_manager(gtkpspell->config);
+       gtkpspell->checker      = NULL;
 
 
-GtkPspell *  gtkpspell_delete( GtkPspell *gtkpspell ){
+       if (pspell_error_number(gtkpspell->possible_err) != 0) {
+               debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err));
+               delete_pspell_can_have_error(gtkpspell->possible_err);
+               gtkpspell = gtkpspell_delete(gtkpspell);
+       }
+       else {
+               gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
+       }
+       return gtkpspell;
+}
 
 
-  if( gtkpspell->checker ){
-    delete_pspell_manager( gtkpspell->checker );
-    gtkpspell->checker      = NULL;
-    gtkpspell->possible_err = NULL; /* checker is a cast from
-                                      possible_err */
-  }
+/* gtkspell_delete() - Finishes a session 
+ */
+GtkPspell *gtkpspell_delete( GtkPspell *gtkpspell )
+{
+       if ( gtkpspell->checker ) {
+               delete_pspell_manager(gtkpspell->checker);
+               gtkpspell->checker      = NULL;
+               gtkpspell->possible_err = NULL; /* checker is a cast from possible_err */
+       }
 
 
-  if( gtkpspell->dictionary_list )
-    gtkpspell_free_dictionary_list( gtkpspell->dictionary_list );
+       if (gtkpspell->dictionary_list)
+               gtkpspell_free_dictionary_list(gtkpspell->dictionary_list);
 
 
-  g_free( gtkpspell->path );
-  g_free( gtkpspell->dict );
-  gtkpspell->path = NULL;
-  gtkpspell->dict = NULL;
+       g_free(gtkpspell->path);
+       g_free(gtkpspell->dict);
+       gtkpspell->path = NULL;
+       gtkpspell->dict = NULL;
 
 
-  g_free( gtkpspell );
-  return NULL;
+       g_free(gtkpspell);
+       return NULL;
 }
   
 }
   
-  
-int set_path_and_dict( GtkPspell *gtkpspell, 
-                      PspellConfig *config,
-                      guchar *path, 
-                      guchar * dict )
+int set_path_and_dict(GtkPspell *gtkpspell, PspellConfig *config,
+                     guchar *path, guchar * dict)
 {
 {
-  guchar *module   = NULL;
-  guchar *language = NULL;
-  guchar *spelling = NULL;
-  guchar *jargon   = NULL;
-
-  guchar buf[BUFSIZE];
-  guchar *end;
-  guchar *temppath;
-  guchar *tempdict;
-
-  /* Change nothing if any of path/dict/config is NULL */
-  if( path==NULL || dict==NULL || config==NULL)
-    return 0;
-
-  /* This is done, so we can free gtkpspell->path, even if it was
-     given as an argument of the function */
-  temppath = g_strdup( path );
-  g_free( gtkpspell->path );
+       guchar *module   = NULL;
+       guchar *language = NULL;
+       guchar *spelling = NULL;
+       guchar *jargon   = NULL;
+       guchar  buf[BUFSIZE];
+       guchar *end;
+       guchar *temppath;
+       guchar *tempdict;
+
+       /* Change nothing if any of path/dict/config is NULL */
+       g_return_val_if_fail(path, 0);
+       g_return_val_if_fail(dict, 0);
+       g_return_val_if_fail(config, 0);
+       
+       /* This is done, so we can free gtkpspell->path, even if it was
+        * given as an argument of the function */
+       temppath = g_strdup(path);
+       g_free(gtkpspell->path);
   
   
-  /* pspell dict name format :                         */
-  /*   <lang>[[-<spelling>[-<jargon>]]-<module>.pwli   */
-  /* Strip off path                                    */
-
-  if(!strrchr(dict,G_DIR_SEPARATOR)){ /* plain dict name */
-    strncpy(buf,dict,BUFSIZE-1);
-  }
-  else{ /* strip path */
-    strncpy(buf,strrchr(dict,G_DIR_SEPARATOR)+1,BUFSIZE-1);
-  }
-  g_free(gtkpspell->dict);
-
-  /* Ensure no buffers overflows if the dict is to long */
-  buf[BUFSIZE-1] = 0x00;
+       /* pspell dict name format :                         */
+       /*   <lang>[[-<spelling>[-<jargon>]]-<module>.pwli   */
+       /* Strip off path                                    */
+
+       if (!strrchr(dict, G_DIR_SEPARATOR)) { /* plain dict name */
+               strncpy(buf, dict, BUFSIZE - 1);
+       }
+       else { /* strip path */
+               strncpy(buf, strrchr(dict, G_DIR_SEPARATOR) + 1, BUFSIZE - 1);
+       }
+       g_free(gtkpspell->dict);
+
+       /* Ensure no buffers overflows if the dict is to long */
+       buf[BUFSIZE - 1] = 0x00;
   
   
-  language = buf;
-  if(( module=strrchr(buf,'-'))!=NULL){
-    module++;
-    if(( end=strrchr(module,'.'))!=NULL)
-      end[0]=0x00;
-    }
+       language = buf;
+       if ((module = strrchr(buf,'-')) != NULL) {
+               module++;
+               if ((end = strrchr(module,'.')) != NULL)
+                       *end = 0;
+       }
 
 
-  /* In tempdict, we have only the dict name, without path nor
-     extension. Useful in the popup menus */
-
-  tempdict=g_strdup(buf);
-
-  /* Probably I am too paranoied... */
-  if(!( language[0]!=0x00 && language[1]!=0x00))
-    language = NULL;
-  else{
-     spelling = strchr(language,'-');
-     if( spelling!=NULL ){
-       spelling[0] = 0x00;
-       spelling++;
-     }
-    if( spelling!=module ){
-      if( ( end=strchr( spelling,'-' ) )!=NULL ){
-        end[0] = 0x00;
-        jargon = end+1;
-        if( jargon!=module )
-          if( ( end=strchr(jargon,'-') )!=NULL )
-            end[0] = 0x00;
-          else
-            jargon = NULL;
-        else
-        jargon = NULL;
-      }
-      else
-      spelling = NULL;
-    }
-    else 
-      spelling = NULL;
-  }
-
-  debug_print( _("Language : %s\nSpelling: %s\nJargon: %s\nModule: %s\n"),language,spelling,jargon,module);
-
-  if(language) 
-    pspell_config_replace(config,"language-tag",language);
-  if(spelling) 
-    pspell_config_replace(config,"spelling",spelling);
-  if(jargon)
-    pspell_config_replace(config,"jargon",jargon);
-  if(module)
-    pspell_config_replace(config,"module",module);
-  if(temppath)
-    pspell_config_replace(config,"word-list-path",temppath);
-
-  switch(gtkpspell->mode){
-  case PSPELL_FASTMODE: pspell_config_replace(config,"sug_mode","fast");
-    break;
-  case PSPELL_NORMALMODE: pspell_config_replace(config,"sug_mode","normal");
-    break;
-  case PSPELL_BADSPELLERMODE: pspell_config_replace(config,"sug_mode","bad-spellers");
-    break;
-  }
+       /* In tempdict, we have only the dict name, without path nor
+         * extension. Useful in the popup menus */
+
+       tempdict = g_strdup(buf);
+
+       /* Probably I am too paranoied... */
+       if (!( language[0] != 0x00 && language[1] != 0x00))
+               language = NULL;
+       else {
+               spelling = strchr(language,'-');
+               if (spelling!=NULL) {
+                       *spelling = 0;
+                       spelling++;
+               }
+               if (spelling != module) {
+                       if ((end = strchr(spelling, '-' )) != NULL) {
+                               *end = 0;
+                               jargon = end + 1;
+                               if (jargon != module)
+                                       if ((end = strchr(jargon, '-')) != NULL)
+                                               *end = 0;
+                                       else
+                                               jargon = NULL;
+                               else
+                                       jargon = NULL;
+                       }
+                       else
+                               spelling = NULL;
+               }
+               else 
+                       spelling = NULL;
+       }
+
+       debug_print(_("Language : %s\nSpelling: %s\nJargon: %s\nModule: %s\n"),
+                   language, spelling, jargon, module);
+
+       if (language) 
+               pspell_config_replace(config, "language-tag", language);
+       if (spelling) 
+               pspell_config_replace(config, "spelling", spelling);
+       if (jargon)
+               pspell_config_replace(config, "jargon", jargon);
+       if (module)
+               pspell_config_replace(config, "module", module);
+       if (temppath)
+               pspell_config_replace(config, "word-list-path", temppath);
+
+       switch(gtkpspell->mode) {
+       case PSPELL_FASTMODE: 
+               pspell_config_replace(config, "sug_mode", "fast");
+               break;
+       case PSPELL_NORMALMODE: 
+               pspell_config_replace(config, "sug_mode", "normal");
+               break;
+       case PSPELL_BADSPELLERMODE: 
+               pspell_config_replace(config, "sug_mode", "bad-spellers");
+               break;
+       }
   
   
-  gtkpspell->path = g_strdup(temppath);
-  gtkpspell->dict = g_strdup(tempdict);
-  g_free(temppath);
-  g_free(tempdict);
+       gtkpspell->path = g_strdup(temppath);
+       gtkpspell->dict = g_strdup(tempdict);
+       g_free(temppath);
+       g_free(tempdict);
 
 
-  return -1;
+       return -1;
 }
 
 }
 
-/* Set path and dict. The session is resetted. */
-/* 0 on error, -1 on success */
-int gtkpspell_set_path_and_dict(GtkPspell * gtkpspell, guchar * path, guchar * dict){
-
-  PspellConfig * config2;
+/* gtkpspell_set_path_and_dict() - Set path and dict. The session is 
+ * resetted. 
+ * 0 on error, -1 on success */
+int gtkpspell_set_path_and_dict(GtkPspell * gtkpspell, guchar * path, 
+                               guchar * dict)
+{
+       PspellConfig * config2;
 
 
-  /* It seems changing an already running config is not the way to go
-     */
+       /* It seems changing an already running config is not the way to go
+         */
 
 
-  config2 = pspell_config_clone( gtkpspell->config );
+       config2 = pspell_config_clone(gtkpspell->config);
 
 
-  if(gtkpspell->checker){
-    delete_pspell_manager(gtkpspell->checker);
-  }
-  gtkpspell->checker      = NULL;
-  gtkpspell->possible_err = NULL;
+       if (gtkpspell->checker) 
+               delete_pspell_manager(gtkpspell->checker);
+       
+       gtkpspell->checker      = NULL;
+       gtkpspell->possible_err = NULL;
 
 
-  if(set_path_and_dict(gtkpspell,config2,path,dict)==0){
-    debug_print("Pspell set_path_and_dict error.");
-    return 0;
-  }
+       if (set_path_and_dict(gtkpspell,config2,path,dict) == 0) {
+               debug_print(_("Pspell set_path_and_dict error."));
+               return 0;
+       }
   
   
-  gtkpspell->possible_err = new_pspell_manager( config2 );
+       gtkpspell->possible_err = new_pspell_manager(config2);
 
 
-  delete_pspell_config(config2);
-  config2 = NULL;
+       delete_pspell_config(config2);
+       config2 = NULL;
 
 
-  if(pspell_error_number(gtkpspell->possible_err)!=0){
-    debug_print("Pspell set path&dict error %s\n",
-               pspell_error_message(gtkpspell->possible_err));
-    delete_pspell_can_have_error(gtkpspell->possible_err);
-    gtkpspell->possible_err = NULL;
-    return 0;
-  }
+       if (pspell_error_number(gtkpspell->possible_err) != 0) {
+               debug_print(_("Pspell path & dict. error %s\n"),
+                           pspell_error_message(gtkpspell->possible_err));
+               delete_pspell_can_have_error(gtkpspell->possible_err);
+               gtkpspell->possible_err = NULL;
+               return 0;
+       }
 
 
-  gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err);
+       gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err);
 
 
-  return -1;
+       return -1;
 }
   
 }
   
-/* What dict are we using ? language-spelling-jargon-module format */
+/* gtkpspell_get_dict() - What dict are we using ? language-spelling-jargon-module format */
 /* Actually, this function is not used and hence not tested. */
 /* Returns an allocated string */  
 /* Actually, this function is not used and hence not tested. */
 /* Returns an allocated string */  
-guchar * gtkpspell_get_dict( GtkPspell *gtkpspell ){
-
-  guchar * dict;
-  guchar * language;
-  guchar * spelling;
-  guchar * jargon;
-  guint len;
+guchar *gtkpspell_get_dict(GtkPspell *gtkpspell)
+{
+       guchar *dict;
+       guchar *language;
+       guchar *spelling;
+       guchar *jargon;
+       guint   len;
 
 
-  if(gtkpspell->config==NULL)
-    return NULL;
+       g_return_val_if_fail(gtkpspell->config, NULL);
   
   
-  language = g_strdup(pspell_config_retrieve(gtkpspell->config,"language"));
-  spelling = g_strdup(pspell_config_retrieve(gtkpspell->config,"spelling"));
-  jargon   = g_strdup(pspell_config_retrieve(gtkpspell->config,"jargon"  ));
-  len      = strlen(language) + strlen(spelling) + strlen(jargon);
-
-  if( len<BUFSIZE ){
-    dict = g_new(char,len+4);
-    strcpy(dict,language);
-    if(spelling){
-      strcat(dict,"-");
-      strcat(dict,spelling);
-      if(jargon){
-        strcat(dict,"-");
-        strcat(dict,jargon);
-      }
-    }
-  }
-  g_free(language);
-  g_free(spelling);
-  g_free(jargon);
+       language = g_strdup(pspell_config_retrieve(gtkpspell->config, "language"));
+       spelling = g_strdup(pspell_config_retrieve(gtkpspell->config, "spelling"));
+       jargon   = g_strdup(pspell_config_retrieve(gtkpspell->config, "jargon"  ));
+       len      = strlen(language) + strlen(spelling) + strlen(jargon);
+
+       if (len < BUFSIZE) {
+               dict = g_new(char,len + 4);
+               strcpy(dict, language);
+               if (spelling) {
+                       strcat(dict, "-");
+                       strcat(dict, spelling);
+                       if (jargon) {
+                               strcat(dict, "-");
+                               strcat(dict,jargon);
+                       }
+               }
+       }
+       g_free(language);
+       g_free(spelling);
+       g_free(jargon);
   
   
-  return dict;
+       return dict;
 }
   
 }
   
-/* Return the dict path as an allocated string */
+/* gtkpspell_get_path() - Return the dict path as an allocated string */
 /* Not used = not tested */
 /* Not used = not tested */
+guchar *gtkpspell_get_path(GtkPspell *gtkpspell)
+{
+       guchar * path;
 
 
-guchar * gtkpspell_get_path(GtkPspell * gtkpspell){
-
-  guchar * path;
 
 
-  if( gtkpspell->config=NULL )
-    return NULL;
+       g_return_val_if_fail(gtkpspell->config, NULL);
 
 
-  path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path"));
+       path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path"));
 
 
-  return path;
+       return path;
 }
 
 }
 
-/* Menu callback : change dict */
-  
-static void menu_change_dict(GtkWidget *w, GtkPspell * gtkpspell){
-
-  guchar *thedict,*thelabel;
+/* menu_change_dict() - Menu callback : change dict */
+static void menu_change_dict(GtkWidget *w, GtkPspell *gtkpspell)
+{
+       guchar *thedict,
+              *thelabel;
   
   
-  /* Dict is simply the menu label */
+       /* Dict is simply the menu label */
 
 
-  gtk_label_get( GTK_LABEL(GTK_BIN(w)->child),(gchar **) &thelabel );
-  thedict=g_strdup(thelabel);
+       gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &thelabel);
+       thedict = g_strdup(thelabel);
 
 
-  /* Set path, dict, (and sug_mode ?) */
-  gtkpspell_set_path_and_dict(gtkpspell,gtkpspell->path,thedict);
-  g_free(thedict);
+       /* Set path, dict, (and sug_mode ?) */
+       gtkpspell_set_path_and_dict(gtkpspell, gtkpspell->path, thedict);
+       g_free(thedict);
 }
 
 }
 
-  
-/* Menu callback : Set the suggestion mode */
-
-static void set_sug_mode(GtkWidget *w, GtkPspell * gtkpspell){
-
-  unsigned char * themode;
-
-  gtk_label_get(GTK_LABEL(GTK_BIN(w)->child),(gchar **) &themode);
-
-  if( !strcmp(themode,_("Fast Mode")) ){
-      gtkpspell_set_sug_mode( gtkpspell,"fast" );
-      gtkpspell->mode = PSPELL_FASTMODE;
-  }
-  if( !strcmp(themode,_("Normal Mode")) ){
-      gtkpspell_set_sug_mode( gtkpspell,"normal" );
-      gtkpspell->mode = PSPELL_NORMALMODE;
-  }
-  if(!strcmp( themode,_("Bad Spellers Mode")) ){
-      gtkpspell_set_sug_mode( gtkpspell,"bad-spellers" );
-      gtkpspell->mode = PSPELL_BADSPELLERMODE;
-  }
+/* set_sug_mode() - Menu callback : Set the suggestion mode */
+static void set_sug_mode(GtkWidget *w, GtkPspell *gtkpspell)
+{
+       unsigned char *themode;
+
+       gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode);
+
+       if (!strcmp(themode, _("Fast Mode"))) {
+               gtkpspell_set_sug_mode(gtkpspell, "fast");
+               gtkpspell->mode = PSPELL_FASTMODE;
+       }
+       if (!strcmp(themode,_("Normal Mode"))) {
+               gtkpspell_set_sug_mode(gtkpspell, "normal");
+               gtkpspell->mode = PSPELL_NORMALMODE;
+       }
+       if (!strcmp( themode,_("Bad Spellers Mode"))) {
+               gtkpspell_set_sug_mode(gtkpspell, "bad-spellers");
+               gtkpspell->mode = PSPELL_BADSPELLERMODE;
+       }
 }
   
 }
   
-/* Set the suggestion mode */
+/* gtkpspell_set_sug_mode() - Set the suggestion mode */
 /* Actually, the session is resetted and everything is reset. */
 /* Actually, the session is resetted and everything is reset. */
-/* We take the used path/dict pair and create a new config with them
-   */
-
-int gtkpspell_set_sug_mode( GtkPspell * gtkpspell, gchar * themode ){
-  PspellConfig *config2;
-  guchar       *path;
-  guchar       *dict;
-
-  delete_pspell_manager( gtkpspell->checker );
-  gtkpspell->checker = NULL;
-
-  config2 = pspell_config_clone(gtkpspell->config);
-
-  if(!set_path_and_dict( gtkpspell, config2, gtkpspell->path, gtkpspell->dict )){
-    debug_print(_("Pspell set_sug_mod could not reset path & dict\n"));
-    return 0;
-  }
-
-  pspell_config_replace( config2, "sug-mode", themode );
-
-  gtkpspell->possible_err = new_pspell_manager( config2 );
-  delete_pspell_config( config2 );
-  config2 = NULL;
-
-  if( pspell_error_number( gtkpspell->possible_err )!=0 ){
-    debug_print( _("Pspell set sug-mode error %s\n"),
-        pspell_error_message( gtkpspell->possible_err ) );
-    delete_pspell_can_have_error( gtkpspell->possible_err );
-    gtkpspell->possible_err = NULL;
-    return 0;
-  }
-  gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
-  return -1;
+/* We take the used path/dict pair and create a new config with them */
+int gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gchar *themode)
+{
+       PspellConfig *config2;
+       guchar       *path;
+       guchar       *dict;
+
+       delete_pspell_manager(gtkpspell->checker);
+       gtkpspell->checker = NULL;
+
+       config2 = pspell_config_clone(gtkpspell->config);
+
+       if (!set_path_and_dict(gtkpspell, config2, gtkpspell->path, gtkpspell->dict)) {
+               debug_print(_("Pspell set_sug_mod could not reset path & dict\n"));
+               return 0;
+       }
+
+       pspell_config_replace(config2, "sug-mode", themode);
+
+       gtkpspell->possible_err = new_pspell_manager(config2);
+       delete_pspell_config(config2);
+       config2 = NULL;
+
+       if (pspell_error_number(gtkpspell->possible_err) != 0) {
+               debug_print(_("Pspell set sug-mode error %s\n"),
+                           pspell_error_message(gtkpspell->possible_err));
+               delete_pspell_can_have_error(gtkpspell->possible_err);
+               gtkpspell->possible_err = NULL;
+               return 0;
+       }
+       gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err);
+       return -1;
 }
   
 }
   
-  
-/* Create a suggestion list for  word  */
-
-static GList* misspelled_suggest( GtkPspell * gtkpspell, guchar *word ) 
+/* misspelled_suggest() - Create a suggestion list for  word  */
+static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word) 
 {
 {
-  const guchar          *newword;
-  GList                 *l = NULL;
-  int                    count;
-  const PspellWordList  *suggestions ;
-  PspellStringEmulation *elements ;
-
-  if( word==NULL ) return NULL;
-
-  if( !pspell_manager_check( gtkpspell->checker,word,-1 ) ){
-       suggestions =  pspell_manager_suggest( gtkpspell->checker,(const char *) word,-1 );
-       elements    = pspell_word_list_elements( suggestions );
-       /* First one must be the misspelled (why this ?) */
-       l           = g_list_append( l,g_strdup(word) ); 
-       while( ( newword=pspell_string_emulation_next( elements ) )!=NULL )
-        l = g_list_append( l, g_strdup( newword ) );
-       return l;
-  }
-  return NULL;
+       const guchar          *newword;
+       GList                 *list = NULL;
+       int                    count;
+       const PspellWordList  *suggestions;
+       PspellStringEmulation *elements;
+
+       g_return_val_if_fail(word, NULL);
+
+       if (!pspell_manager_check(gtkpspell->checker, word, -1)) {
+               suggestions = pspell_manager_suggest(gtkpspell->checker, (const char *)word, -1);
+               elements    = pspell_word_list_elements(suggestions);
+               /* First one must be the misspelled (why this ?) */
+               list        = g_list_append(list, g_strdup(word)); 
+               
+               while ((newword = pspell_string_emulation_next(elements)) != NULL)
+                       list = g_list_append(list, g_strdup(newword));
+               return list;
+       }
+       return NULL;
 }
 
 }
 
-
-/* Just test if word is correctly spelled */  
-
-static int misspelled_test(GtkPspell * gtkpspell, unsigned char *word) 
+/* misspelled_test() - Just test if word is correctly spelled */  
+static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word) 
 {
 {
-    if( pspell_manager_check( gtkpspell->checker, word, -1) ) 
-      return 0;
-    return 1;
+       return pspell_manager_check(gtkpspell->checker, word, -1) ? 0 : 1; 
 }
 
 
 static gboolean iswordsep(unsigned char c) 
 {
 }
 
 
 static gboolean iswordsep(unsigned char c) 
 {
-    return !isalpha(c) && c != '\'';
+       return !isalpha(c) && c != '\'';
 }
 
 }
 
-static guchar get_text_index_whar(GtkPspell * gtkpspell, int pos) 
+static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos) 
 {
 {
-    guchar a;
-    gchar *text;
-    text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1);
-    if (text == NULL) return 0;
-    a = (guchar) * text;
-    g_free(text);
-    return a;
+       guchar a;
+       gchar *text;
+       
+       text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1);
+       if (text == NULL) 
+               return 0;
+       a = (guchar) *text;
+       g_free(text);
+       return a;
 }
 
 }
 
-static gboolean get_word_from_pos(GtkPspell * gtkpspell, int pos, 
+static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos, 
                                   unsigned char* buf,
                                   int *pstart, int *pend) 
 {
                                   unsigned char* buf,
                                   int *pstart, int *pend) 
 {
-    gint start, end;
-    GtkXText * gtktext;
-    gtktext=gtkpspell->gtktext;
-    if (iswordsep(get_text_index_whar(gtkpspell, pos))) return FALSE;
+       gint start, end;
+       GtkXText *gtktext;
+       
+       gtktext = gtkpspell->gtktext;
+       if (iswordsep(get_text_index_whar(gtkpspell, pos))) 
+               return FALSE;
 
 
-    for (start = pos; start >= 0; --start) {
-        if (iswordsep(get_text_index_whar(gtkpspell, start))) break;
-    }
-    start++;
+       for (start = pos; start >= 0; --start) {
+               if (iswordsep(get_text_index_whar(gtkpspell, start))) 
+                       break;
+       }
+       start++;
 
 
-    for (end = pos; end < gtk_xtext_get_length(gtktext); end++) {
-        if (iswordsep(get_text_index_whar(gtkpspell, end))) break;
-    }
+       for (end = pos; end < gtk_xtext_get_length(gtktext); end++) {
+               if (iswordsep(get_text_index_whar(gtkpspell, end))) 
+                       break;
+       }
 
 
-    if (buf) {
-        for (pos = start; pos < end; pos++) buf[pos - start] = get_text_index_whar(gtkpspell, pos);
-        buf[pos - start] = 0;
-    }
+       if (buf) {
+               for (pos = start; pos < end; pos++) 
+                       buf[pos - start] = get_text_index_whar(gtkpspell, pos);
+               buf[pos - start] = 0;
+       }
 
 
-    if (pstart) *pstart = start;
-    if (pend) *pend = end;
+       if (pstart) 
+               *pstart = start;
+       if (pend) 
+               *pend = end;
 
 
-    return TRUE;
+       return TRUE;
 }
 
 }
 
-static gboolean get_curword(GtkPspell * gtkpspell, unsigned char* buf,
+static gboolean get_curword(GtkPspell *gtkpspell, unsigned char* buf,
                             int *pstart, int *pend) 
 {
                             int *pstart, int *pend) 
 {
-    int pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
-    return get_word_from_pos(gtkpspell, pos, buf, pstart, pend);
+       int pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
+       return get_word_from_pos(gtkpspell, pos, buf, pstart, pend);
 }
 
 }
 
-static void change_color(GtkPspell * gtkpspell, int start, int end, 
+static void change_color(GtkPspell * gtkpspell, 
+                        int start, int end, 
                          GdkColor *color) 
 {
                          GdkColor *color) 
 {
-    char *newtext;
-    GtkXText *gtktext;
-    gtktext=gtkpspell->gtktext;
-    if (start >= end) {
-        return ;
-    };
-    gtk_xtext_freeze(gtktext);
-    newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end);
-    if(newtext){
-        gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
-                                         GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
-        gtk_xtext_set_point(gtktext, start);
-        gtk_xtext_forward_delete(gtktext, end - start);
-
-        gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start);
-        gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
-                                           GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
-   }
-   gtk_xtext_thaw(gtktext);
+       char     *newtext;
+       GtkXText *gtktext;
+
+       g_return_if_fail(start < end);
+    
+       gtktext = gtkpspell->gtktext;
+    
+       gtk_xtext_freeze(gtktext);
+       newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end);
+       if (newtext) {
+               gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
+                                                GTK_SIGNAL_FUNC(entry_insert_cb), 
+                                                gtkpspell);
+               gtk_xtext_set_point(gtktext, start);
+               gtk_xtext_forward_delete(gtktext, end - start);
+
+               gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start);
+               gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
+                                                  GTK_SIGNAL_FUNC(entry_insert_cb), 
+                                                  gtkpspell);
+       }
+       gtk_xtext_thaw(gtktext);
 }
 
 }
 
-static gboolean check_at(GtkPspell * gtkpspell, int from_pos) 
+static gboolean check_at(GtkPspell *gtkpspell, int from_pos) 
 {
 {
-    int start, end;
-    unsigned char buf[BUFSIZE];
-    GtkXText * gtktext;
-    gtktext=gtkpspell->gtktext;
-    if (from_pos < 0) return FALSE;
-    if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end)) {
-        return FALSE;
-    };
-    strncpy(gtkpspell->theword,buf,BUFSIZE-1);
-    gtkpspell->theword[BUFSIZE-1]=0x00;
-
-    if (misspelled_test(gtkpspell, buf)) {
-        if (highlight.pixel == 0) {
-            /* add an entry for the highlight in the color map. */
-            GdkColormap *gc = gtk_widget_get_colormap(GTK_WIDGET(gtktext));
-            gdk_colormap_alloc_color(gc, &highlight, FALSE, TRUE);
-            ;
-        }
-        change_color(gtkpspell, start, end, &highlight);
-        return TRUE;
-    } else {
-        change_color(gtkpspell, start, end,
-                     &(GTK_WIDGET(gtktext)->style->fg[0]));
-        return FALSE;
-    }
+       int           start, end;
+       unsigned char buf[BUFSIZE];
+       GtkXText     *gtktext;
+
+       g_return_val_if_fail(from_pos >= 0, FALSE);
+    
+       gtktext = gtkpspell->gtktext;
+       if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end))
+               return FALSE;
+       strncpy(gtkpspell->theword, buf, BUFSIZE - 1);
+       gtkpspell->theword[BUFSIZE - 1] = 0;
+
+       if (misspelled_test(gtkpspell, buf)) {
+               if (highlight.pixel == 0) {
+                       /* add an entry for the highlight in the color map. */
+                       GdkColormap *gc = gtk_widget_get_colormap(GTK_WIDGET(gtktext));
+                       gdk_colormap_alloc_color(gc, &highlight, FALSE, TRUE);
+               }
+               change_color(gtkpspell, start, end, &highlight);
+               return TRUE;
+       } else {
+               change_color(gtkpspell, start, end,
+                            &(GTK_WIDGET(gtktext)->style->fg[0]));
+               return FALSE;
+       }
 }
 
 
 }
 
 
-static void check_all(GtkWidget *w, GtkPspell * gtkpspell){
-  gtkpspell_check_all(gtkpspell);
+static void check_all(GtkWidget *w, GtkPspell *gtkpspell)
+{
+       gtkpspell_check_all(gtkpspell);
 }
 
 
 }
 
 
-void gtkpspell_check_all(GtkPspell * gtkpspell) 
+void gtkpspell_check_all(GtkPspell *gtkpspell) 
 {
 {
-    guint origpos;
-    guint pos = 0;
-    guint len;
-    float adj_value;
-    GtkXText * gtktext;
-    gtktext=gtkpspell->gtktext;
-
-    if (!gtkpspell_running(gtkpspell)) return ;
-
-    len = gtk_xtext_get_length(gtktext);
-
-    adj_value = gtktext->vadj->value;
-    gtk_xtext_freeze(gtktext);
-    origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
-    gtk_editable_set_position(GTK_EDITABLE(gtktext),0);
-    while (pos < len) {
-        while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos)))
-            pos++;
-        while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos)))
-            pos++;
-        if (pos > 0)
-            check_at(gtkpspell, pos - 1);
-    }
-    gtk_xtext_thaw(gtktext);
-    gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
-    gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
+       guint origpos;
+       guint pos = 0;
+       guint len;
+       float adj_value;
+       GtkXText *gtktext;
 
 
+       
+       if (!gtkpspell_running(gtkpspell)) return ;
+       gtktext = gtkpspell->gtktext;
+
+       len = gtk_xtext_get_length(gtktext);
+
+       adj_value = gtktext->vadj->value;
+       gtk_xtext_freeze(gtktext);
+       origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
+       gtk_editable_set_position(GTK_EDITABLE(gtktext),0);
+       while (pos < len) {
+               while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos)))
+                       pos++;
+               while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos)))
+                       pos++;
+               if (pos > 0)
+                       check_at(gtkpspell, pos - 1);
+       }
+       gtk_xtext_thaw(gtktext);
+       gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
+       gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
 }
 
 }
 
-static void entry_insert_cb(GtkXText *gtktext, 
-                            gchar *newtext, guint len, guint *ppos, 
+static void entry_insert_cb(GtkXText *gtktext, gchar *newtext, 
+                           guint len, guint *ppos, 
                             GtkPspell * gtkpspell) 
 {
                             GtkPspell * gtkpspell) 
 {
-    if (!gtkpspell_running(gtkpspell)) return ;
-
-    if (iswordsep(newtext[0])) {
-        /* did we just end a word? */
-        if (*ppos >= 2) check_at(gtkpspell, *ppos - 2);
-
-        /* did we just split a word? */
-        if (*ppos < gtk_xtext_get_length(gtktext))
-            check_at(gtkpspell, *ppos + 1);
-    } else {
-        /* check as they type, *except* if they're typing at the end (the most
-         * common case.
-         */
-        if (*ppos < gtk_xtext_get_length(gtktext) &&
-                !iswordsep(get_text_index_whar(gtkpspell, *ppos)))
-            check_at(gtkpspell, *ppos - 1);
-    }
+       if (!gtkpspell_running(gtkpspell)) 
+               return;
+
+       if (iswordsep(newtext[0])) {
+               /* did we just end a word? */
+               if (*ppos >= 2) 
+                       check_at(gtkpspell, *ppos - 2);
+
+               /* did we just split a word? */
+               if (*ppos < gtk_xtext_get_length(gtktext))
+                       check_at(gtkpspell, *ppos + 1);
+       } else {
+               /* check as they type, *except* if they're typing at the end (the most
+                 * common case.
+                 */
+               if (*ppos < gtk_xtext_get_length(gtktext) 
+               &&  !iswordsep(get_text_index_whar(gtkpspell, *ppos)))
+                       check_at(gtkpspell, *ppos - 1);
+               }
 
 }
 
 
 }
 
-static void entry_delete_cb(GtkXText *gtktext,
-                            gint start, gint end, GtkPspell *gtkpspell) 
+static void entry_delete_cb(GtkXText *gtktext, gint start, gint end, 
+                           GtkPspell *gtkpspell) 
 {
 {
-    int origpos;
-    if (!gtkpspell_running(gtkpspell)) return ;
-
-    origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
-    check_at(gtkpspell, start - 1);
-    gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
-    gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
-    /* this is to *UNDO* the selection, in case they were holding shift
-     * while hitting backspace. */
+       int origpos;
+    
+       if (!gtkpspell_running(gtkpspell)) 
+               return;
+
+       origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
+       check_at(gtkpspell, start - 1);
+       gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
+       gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
+       /* this is to *UNDO* the selection, in case they were holding shift
+         * while hitting backspace. */
 }
 
 }
 
-static void replace_word(GtkWidget *w, GtkPspell * gtkpspell) 
+static void replace_word(GtkWidget *w, GtkPspell *gtkpspell) 
 {
 {
-    int start, end,oldlen, newlen;
-    guint origpos;
-    unsigned char *newword;
-    unsigned char buf[BUFSIZE];
-    guint pos;
-    GtkXText * gtktext;
-    gtktext=gtkpspell->gtktext;
-
-    gtk_xtext_freeze(GTK_XTEXT(gtktext));
-    origpos = gtkpspell->orig_pos;
-    pos     = origpos;
-
-    gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
-    newlen = strlen(newword);
-
-    get_curword(gtkpspell, buf, &start, &end);
-    oldlen=end-start;
-
-    gtk_xtext_set_point(GTK_XTEXT(gtktext), end);
-    gtk_xtext_backward_delete(GTK_XTEXT(gtktext), end - start);
-    gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newword, strlen(newword));
+       int             start, end,oldlen, newlen;
+       guint           origpos;
+       unsigned char  *newword;
+       unsigned char   buf[BUFSIZE];
+       guint           pos;
+       GtkXText       *gtktext;
+    
+       gtktext = gtkpspell->gtktext;
+
+       gtk_xtext_freeze(GTK_XTEXT(gtktext));
+       origpos = gtkpspell->orig_pos;
+       pos     = origpos;
+
+       gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
+       newlen = strlen(newword);
+
+       get_curword(gtkpspell, buf, &start, &end);
+       oldlen = end - start;
+
+       gtk_xtext_set_point(GTK_XTEXT(gtktext), end);
+       gtk_xtext_backward_delete(GTK_XTEXT(gtktext), end - start);
+       gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newword, strlen(newword));
     
 #if 0
     if(end-start>0 /*&& gtkpspell->learn*/){ 
     
 #if 0
     if(end-start>0 /*&& gtkpspell->learn*/){ 
@@ -748,282 +760,291 @@ static void replace_word(GtkWidget *w, GtkPspell * gtkpspell)
                                       newword,strlen(newword));
     }
 #endif
                                       newword,strlen(newword));
     }
 #endif
-    /* Put the point and the position where we clicked with the mouse */
-    /* It seems to be a hack, as I must thaw,freeze,thaw the widget   */
-    /* to let it update correctly the word insertion and then the     */
-    /* point & position position. If not, SEGV after the first replacement */
-    /* If the new word ends before point, put the point at its end*/
+
+       /* Put the point and the position where we clicked with the mouse */
+       /* It seems to be a hack, as I must thaw,freeze,thaw the widget   */
+       /* to let it update correctly the word insertion and then the     */
+       /* point & position position. If not, SEGV after the first replacement */
+       /* If the new word ends before point, put the point at its end*/
     
     
-    if(origpos-start<=oldlen && origpos-start>=0) {
-      /* Original point was in the word. */
-      /* Put the insertion point in the same location */
-      /* with respect to the new length */
-      /* If the original position is still within the word, */
-      /* then keep the original position. If not, move to the */
-      /* end of the word */
-      if(origpos-start>newlen)
-       pos=start+newlen;
-    }
-    else
-      if (origpos>end) {
-       /* move the position according to the change of length */
-      pos=origpos+newlen-oldlen;
-      }
-    gtk_xtext_thaw(GTK_XTEXT(gtktext));
-    gtk_xtext_freeze(GTK_XTEXT(gtktext));
-    if(GTK_XTEXT(gtktext)->text_len<pos)
-      pos=gtk_xtext_get_length(GTK_XTEXT(gtktext));
-    gtkpspell->orig_pos=pos;
-    gtk_editable_set_position(GTK_EDITABLE(gtktext),gtkpspell->orig_pos);
-    gtk_xtext_set_point(GTK_XTEXT(gtktext), 
-                       gtk_editable_get_position(GTK_EDITABLE(gtktext)));
-    gtk_xtext_thaw(GTK_XTEXT(gtktext));
+       if (origpos-start <= oldlen && origpos-start >= 0) {
+               /* Original point was in the word. */
+               /* Put the insertion point in the same location */
+               /* with respect to the new length */
+               /* If the original position is still within the word, */
+               /* then keep the original position. If not, move to the */
+               /* end of the word */
+               if (origpos-start > newlen)
+                       pos = start + newlen;
+       }
+       else if (origpos > end) {
+               /* move the position according to the change of length */
+               pos = origpos + newlen - oldlen;
+       }
+       gtk_xtext_thaw(GTK_XTEXT(gtktext));
+       gtk_xtext_freeze(GTK_XTEXT(gtktext));
+       if (GTK_XTEXT(gtktext)->text_len < pos)
+               pos = gtk_xtext_get_length(GTK_XTEXT(gtktext));
+       gtkpspell->orig_pos = pos;
+       gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkpspell->orig_pos);
+       gtk_xtext_set_point(GTK_XTEXT(gtktext), 
+                           gtk_editable_get_position(GTK_EDITABLE(gtktext)));
+       gtk_xtext_thaw(GTK_XTEXT(gtktext));
 }
 
 /* Accept this word for this session */
 
 }
 
 /* Accept this word for this session */
 
-static void add_word_to_session(GtkWidget *w, GtkPspell * gtkpspell){
-    guint pos;
-    GtkXText * gtkxtext;
-    gtkxtext=gtkpspell->gtktext;
-
-    gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
-    pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
+static void add_word_to_session(GtkWidget *w, GtkPspell *gtkpspell)
+{
+       guint     pos;
+       GtkXText *gtkxtext;
+    
+       gtkxtext = gtkpspell->gtktext;
+       gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
+       pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
     
     
-    pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword));
+       pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword, strlen(gtkpspell->theword));
 
 
-    check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
+       check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
 
 
-    gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
-    gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
-    gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
-    gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
-    gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
+       gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
+       gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
+       gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
+       gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
+       gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
 }
 
 }
 
-/* Add word to personal dict. Save the list at every addition (may be
-   not efficient...) */
+/* add_word_to_personal() - add word to personal dict. Save the list at every addition (may be
*  not efficient...) */
 
 
-static void add_word_to_personal(GtkWidget *w, GtkPspell * gtkpspell){
-    guint pos;
-    GtkXText * gtkxtext;
-    gtkxtext=gtkpspell->gtktext;
+static void add_word_to_personal(GtkWidget *w, GtkPspell *gtkpspell)
+{
+       guint     pos;
+       GtkXText *gtkxtext;
+    
+       gtkxtext = gtkpspell->gtktext;
 
 
-    gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
-    pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
+       gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
+       pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
     
     
-    pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword));
-    pspell_manager_save_all_word_lists(gtkpspell->checker);
+       pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword));
+       pspell_manager_save_all_word_lists(gtkpspell->checker);
     
     
-    check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
-    gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
-    gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
-    gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
-    gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
+       check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
+       gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
+       gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
+       gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
+       gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
        gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
 }
 
        
        gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
 }
 
        
-static GtkMenu *make_menu_config(GtkPspell *gtkpspell){
-  GtkWidget *menu, *item, *submenu;
+static GtkMenu *make_menu_config(GtkPspell *gtkpspell)
+{
+       GtkWidget *menu, *item, *submenu;
 
   
 
   
-  menu = gtk_menu_new();
+       menu = gtk_menu_new();
 
         item = gtk_menu_item_new_with_label(_("Spell check all"));
 
         item = gtk_menu_item_new_with_label(_("Spell check all"));
-                gtk_widget_show(item);
-                gtk_menu_append(GTK_MENU(menu), item);
+        gtk_widget_show(item);
+        gtk_menu_append(GTK_MENU(menu), item);
         gtk_signal_connect(GTK_OBJECT(item),"activate",
         gtk_signal_connect(GTK_OBJECT(item),"activate",
-                GTK_SIGNAL_FUNC(check_all),gtkpspell);
+                          GTK_SIGNAL_FUNC(check_all), 
+                          gtkpspell);
 
 
         item = gtk_menu_item_new();
 
 
         item = gtk_menu_item_new();
-                gtk_widget_show(item);
-                gtk_menu_append(GTK_MENU(menu),item);
+        gtk_widget_show(item);
+        gtk_menu_append(GTK_MENU(menu),item);
 
        submenu = gtk_menu_new();
 
        submenu = gtk_menu_new();
-                item = gtk_menu_item_new_with_label(_("Change dictionary"));
-                gtk_widget_show(item);
-                gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
-                gtk_menu_append(GTK_MENU(menu), item);
-                /* Dict list */
-                if(gtkpspell->dictionary_list==NULL)
-                  gtkpspell->dictionary_list=gtkpspell_get_dictionary_list(gtkpspell->path);
+        item = gtk_menu_item_new_with_label(_("Change dictionary"));
+        gtk_widget_show(item);
+        gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
+        gtk_menu_append(GTK_MENU(menu), item);
+
+       /* Dict list */
+        if (gtkpspell->dictionary_list==NULL)
+               gtkpspell->dictionary_list = gtkpspell_get_dictionary_list(gtkpspell->path);
        
        
-                
         {
         {
-          GtkWidget * curmenu=submenu;
-          int count = 0;
-          Dictionary *dict;
-          GSList *tmp;
-          tmp = gtkpspell->dictionary_list;
-          for (tmp =  gtkpspell->dictionary_list;tmp!=NULL;tmp=g_slist_next(tmp)){
-            dict= (Dictionary *) tmp->data;
-            item = gtk_check_menu_item_new_with_label(dict->name);
-           if(strcmp2(dict->name,gtkpspell->dict))
-             gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),FALSE);
-           else{
-             gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
-             gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
-           }
-            gtk_menu_append(GTK_MENU(curmenu),item);
-            gtk_signal_connect(GTK_OBJECT(item),"activate",
-                GTK_SIGNAL_FUNC(menu_change_dict),gtkpspell);
-            gtk_widget_show(item);
-            count++;
-            if(count==MENUCOUNT){
-              GtkWidget *newmenu;
-              newmenu=gtk_menu_new();
-              item=gtk_menu_item_new_with_label(_("More..."));
-              gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),newmenu);
-              gtk_menu_append(GTK_MENU(curmenu),item);
-              gtk_widget_show(item);
-              curmenu=newmenu;
-              count=0;
-            }
-          }
+               GtkWidget * curmenu = submenu;
+               int count = 0;
+               Dictionary *dict;
+               GSList *tmp;
+               
+               tmp = gtkpspell->dictionary_list;
+               for (tmp = gtkpspell->dictionary_list; tmp != NULL; tmp =g_slist_next(tmp)) {
+                       dict = (Dictionary *) tmp->data;
+                       item = gtk_check_menu_item_new_with_label(dict->name);
+                       if (strcmp2(dict->name, gtkpspell->dict))
+                               gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
+                       else {
+                               gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+                               gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
+                       }
+                       gtk_menu_append(GTK_MENU(curmenu), item);
+                       gtk_signal_connect(GTK_OBJECT(item), "activate",
+                                          GTK_SIGNAL_FUNC(menu_change_dict),
+                                          gtkpspell);
+                       gtk_widget_show(item);
+                       count++;
+                       if (count == MENUCOUNT) {
+                               GtkWidget *newmenu;
+                               newmenu = gtk_menu_new();
+                               item = gtk_menu_item_new_with_label(_("More..."));
+                               gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), newmenu);
+                               gtk_menu_append(GTK_MENU(curmenu), item);
+                               gtk_widget_show(item);
+                               curmenu = newmenu;
+                               count = 0;
+                       }
+               }
         }  
 
         item = gtk_menu_item_new();
         }  
 
         item = gtk_menu_item_new();
-                gtk_widget_show(item);
-                gtk_menu_append(GTK_MENU(menu),item);
+        gtk_widget_show(item);
+        gtk_menu_append(GTK_MENU(menu), item);
 
         item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
 
         item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
-                gtk_widget_show(item);
-                gtk_menu_append(GTK_MENU(menu),item);
-                if(gtkpspell->mode==PSPELL_FASTMODE){
-                  gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
-                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
-               }
-                else
-                  gtk_signal_connect(GTK_OBJECT(item),"activate",
-                        GTK_SIGNAL_FUNC(set_sug_mode),gtkpspell);
-
-
+        gtk_widget_show(item);
+        gtk_menu_append(GTK_MENU(menu), item);
+        if (gtkpspell->mode == PSPELL_FASTMODE) {
+               gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
+               gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
+       }
+        else
+               gtk_signal_connect(GTK_OBJECT(item),"activate",
+                                  GTK_SIGNAL_FUNC(set_sug_mode),
+                                  gtkpspell);
 
         item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
 
         item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
-                gtk_widget_show(item);
-                gtk_menu_append(GTK_MENU(menu),item);
-                if(gtkpspell->mode==PSPELL_NORMALMODE){
-                  gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
-                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
-               }
-                else
-                  gtk_signal_connect(GTK_OBJECT(item),"activate",
-                        GTK_SIGNAL_FUNC(set_sug_mode),gtkpspell);
+        gtk_widget_show(item);
+        gtk_menu_append(GTK_MENU(menu),item);
+        if (gtkpspell->mode == PSPELL_NORMALMODE) {
+               gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
+               gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+       }
+        else
+               gtk_signal_connect(GTK_OBJECT(item), "activate",
+                                  GTK_SIGNAL_FUNC(set_sug_mode),
+                                  gtkpspell);
         
         item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
         
         item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
-                gtk_widget_show(item);
-                gtk_menu_append(GTK_MENU(menu),item);
-                if(gtkpspell->mode==PSPELL_BADSPELLERMODE){
-                  gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
-                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
-               }
-                else
-                  gtk_signal_connect(GTK_OBJECT(item),"activate",
-                        GTK_SIGNAL_FUNC(set_sug_mode),gtkpspell);
-
-
+       gtk_widget_show(item);
+        gtk_menu_append(GTK_MENU(menu),item);
+        if (gtkpspell->mode==PSPELL_BADSPELLERMODE) {
+               gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
+               gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+       }
+        else
+               gtk_signal_connect(GTK_OBJECT(item),"activate",
+                                  GTK_SIGNAL_FUNC(set_sug_mode),
+                                  gtkpspell);
 
         return GTK_MENU(menu);
 }
   
 
         return GTK_MENU(menu);
 }
   
-/* Add menus to accept this word for this session and to add it to personal
  dictionary */
-static GtkMenu *make_menu(GList *l, GtkPspell * gtkpspell) 
+/* make_menu() - Add menus to accept this word for this session and to add it to 
* personal dictionary */
+static GtkMenu *make_menu(GList *l, GtkPspell *gtkpspell) 
 {
 {
-    GtkWidget *menu, *item;
-    unsigned char *caption;
-    GtkXText * gtktext;
-    gtktext=gtkpspell->gtktext;
+       GtkWidget *menu, *item;
+       unsigned char *caption;
+       GtkXText * gtktext;
+       
+       gtktext = gtkpspell->gtktext;
 
 
-    menu = gtk_menu_new(); 
+       menu = gtk_menu_new(); 
         caption = g_strdup_printf(_("Accept `%s' for this session"), (unsigned char*)l->data);
         caption = g_strdup_printf(_("Accept `%s' for this session"), (unsigned char*)l->data);
-               item = gtk_menu_item_new_with_label(caption);
-               g_free(caption);
-               gtk_widget_show(item);
-               gtk_menu_append(GTK_MENU(menu), item);
+       item = gtk_menu_item_new_with_label(caption);
+       g_free(caption);
+       gtk_widget_show(item);
+       gtk_menu_append(GTK_MENU(menu), item);
 
         gtk_signal_connect(GTK_OBJECT(item), "activate",
 
         gtk_signal_connect(GTK_OBJECT(item), "activate",
-                GTK_SIGNAL_FUNC(add_word_to_session), gtkpspell);
+                          GTK_SIGNAL_FUNC(add_word_to_session), 
+                          gtkpspell);
 
                caption = g_strdup_printf(_("Add `%s' to personal dictionary"), (char*)l->data);
 
                caption = g_strdup_printf(_("Add `%s' to personal dictionary"), (char*)l->data);
-               item = gtk_menu_item_new_with_label(caption);
-               g_free(caption);
-               gtk_widget_show(item);
-               gtk_menu_append(GTK_MENU(menu), item);
+       item = gtk_menu_item_new_with_label(caption);
+       g_free(caption);
+       gtk_widget_show(item);
+       gtk_menu_append(GTK_MENU(menu), item);
 
         gtk_signal_connect(GTK_OBJECT(item), "activate",
 
         gtk_signal_connect(GTK_OBJECT(item), "activate",
-                GTK_SIGNAL_FUNC(add_word_to_personal), gtkpspell);
+                          GTK_SIGNAL_FUNC(add_word_to_personal), 
+                          gtkpspell);
          
          
-
         item = gtk_menu_item_new();
         gtk_widget_show(item);
         gtk_menu_append(GTK_MENU(menu), item);
 
         l = l->next;
         if (l == NULL) {
         item = gtk_menu_item_new();
         gtk_widget_show(item);
         gtk_menu_append(GTK_MENU(menu), item);
 
         l = l->next;
         if (l == NULL) {
-            item = gtk_menu_item_new_with_label(_("(no suggestions)"));
-            gtk_widget_show(item);
-            gtk_menu_append(GTK_MENU(menu), item);
+               item = gtk_menu_item_new_with_label(_("(no suggestions)"));
+               gtk_widget_show(item);
+               gtk_menu_append(GTK_MENU(menu), item);
         } else {
         } else {
-            GtkWidget *curmenu = menu;
-            int count = 0;
-            do {
-                if (l->data == NULL && l->next != NULL) {
-                    count = 0;
-                    curmenu = gtk_menu_new();
-                    item = gtk_menu_item_new_with_label(_("Others..."));
-                    gtk_widget_show(item);
-                    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
-                    gtk_menu_append(GTK_MENU(curmenu), item);
-                    l = l->next;
-                } else if (count > MENUCOUNT) {
-                    count -= MENUCOUNT;
-                    item = gtk_menu_item_new_with_label(_("More..."));
-                    gtk_widget_show(item);
-                    gtk_menu_append(GTK_MENU(curmenu), item);
-                    curmenu = gtk_menu_new();
-                    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
-                }
-                item = gtk_menu_item_new_with_label((unsigned char*)l->data);
-                gtk_signal_connect(GTK_OBJECT(item), "activate",
-                                   GTK_SIGNAL_FUNC(replace_word), gtkpspell);
-                gtk_widget_show(item);
-                gtk_menu_append(GTK_MENU(curmenu), item);
-                count++;
-            } while ((l = l->next) != NULL);
-        }
-    return GTK_MENU(menu);
+               GtkWidget *curmenu = menu;
+               int count = 0;
+               
+               do {
+                       if (l->data == NULL && l->next != NULL) {
+                               count = 0;
+                               curmenu = gtk_menu_new();
+                               item = gtk_menu_item_new_with_label(_("Others..."));
+                               gtk_widget_show(item);
+                               gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
+                               gtk_menu_append(GTK_MENU(curmenu), item);
+                               l = l->next;
+                       } else if (count > MENUCOUNT) {
+                               count -= MENUCOUNT;
+                               item = gtk_menu_item_new_with_label(_("More..."));
+                               gtk_widget_show(item);
+                               gtk_menu_append(GTK_MENU(curmenu), item);
+                               curmenu = gtk_menu_new();
+                               gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
+                       }
+                       item = gtk_menu_item_new_with_label((unsigned char*)l->data);
+                       gtk_signal_connect(GTK_OBJECT(item), "activate",
+                                          GTK_SIGNAL_FUNC(replace_word), gtkpspell);
+                       gtk_widget_show(item);
+                       gtk_menu_append(GTK_MENU(curmenu), item);
+                       count++;
+               } while ((l = l->next) != NULL);
+       }
+       return GTK_MENU(menu);
 }
 
 }
 
-static void popup_menu(GtkPspell * gtkpspell, GdkEventButton *eb) 
+static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb) 
 {
 {
-    unsigned char buf[BUFSIZE];
-    GList *list, *l;
-    GtkXText * gtktext;
-    gtktext=gtkpspell->gtktext;
-    gtkpspell->orig_pos=gtk_editable_get_position(GTK_EDITABLE(gtktext));
-
-    if( !(eb->state & GDK_SHIFT_MASK) )
-      if (get_curword(gtkpspell, buf, NULL, NULL)){
-       if (buf != NULL) {
-         strncpy(gtkpspell->theword,buf,BUFSIZE-1);
-         gtkpspell->theword[BUFSIZE-1]=0x00;
-         list = misspelled_suggest(gtkpspell, buf);
-         if (list != NULL) {
-            gtk_menu_popup(make_menu(list, gtkpspell), NULL, NULL, NULL, NULL,
-                           eb->button, eb->time);
-            for (l = list; l != NULL; l = l->next)
-             g_free(l->data);
-            g_list_free(list);
-            return;
-         }
-       }
-      }
-    gtk_menu_popup(make_menu_config(gtkpspell),NULL,NULL,NULL,NULL,
-          eb->button,eb->time);
-
+       unsigned char buf[BUFSIZE];
+       GList *list, *l;
+       GtkXText * gtktext;
+       
+       gtktext = gtkpspell->gtktext;
+       gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
+
+       if (!(eb->state & GDK_SHIFT_MASK))
+               if (get_curword(gtkpspell, buf, NULL, NULL)) {
+                       if (buf != NULL) {
+                               strncpy(gtkpspell->theword, buf, BUFSIZE - 1);
+                               gtkpspell->theword[BUFSIZE - 1] = 0;
+                               list = misspelled_suggest(gtkpspell, buf);
+                               if (list != NULL) {
+                                       gtk_menu_popup(make_menu(list, gtkpspell), NULL, NULL, NULL, NULL,
+                                                      eb->button, eb->time);
+                                       for (l = list; l != NULL; l = l->next)
+                                               g_free(l->data);
+                                       g_list_free(list);
+                                       return;
+                               }
+                       }
+               }
+       gtk_menu_popup(make_menu_config(gtkpspell),NULL,NULL,NULL,NULL,
+       eb->button,eb->time);
 }
 
 /* ok, this is pretty wacky:
 }
 
 /* ok, this is pretty wacky:
@@ -1034,85 +1055,91 @@ static void popup_menu(GtkPspell * gtkpspell, GdkEventButton *eb)
  * so what do we do?  forge rightclicks as leftclicks, then popup the menu.
  * HACK HACK HACK.
  */
  * so what do we do?  forge rightclicks as leftclicks, then popup the menu.
  * HACK HACK HACK.
  */
-static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell * gtkpspell) 
-
+static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell *gtkpspell) 
 {
 {
-    GdkEventButton *eb;
-    gboolean retval;
+       GdkEventButton *eb;
+       gboolean retval;
 
 
-    if (!gtkpspell_running(gtkpspell)) return FALSE;
+       if (!gtkpspell_running(gtkpspell)) 
+               return FALSE;
 
 
-    if (e->type != GDK_BUTTON_PRESS) return FALSE;
-    eb = (GdkEventButton*) e;
+       if (e->type != GDK_BUTTON_PRESS) 
+               return FALSE;
+       eb = (GdkEventButton*) e;
 
 
-    if (eb->button != 3) return FALSE;
+       if (eb->button != 3) 
+               return FALSE;
 
 
-    /* forge the leftclick */
-    eb->button = 1;
+       /* forge the leftclick */
+       eb->button = 1;
 
         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
 
         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
-                                     GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
-    gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
-                            e, &retval);
-    gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
-                                       GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
-    gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
+                                        GTK_SIGNAL_FUNC(button_press_intercept_cb), 
+                                        gtkpspell);
+       gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
+                               e, &retval);
+       gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
+                                          GTK_SIGNAL_FUNC(button_press_intercept_cb), 
+                                          gtkpspell);
+       gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
     
     
-    /* now do the menu wackiness */
-    popup_menu(gtkpspell, eb);
-    gtk_grab_remove(GTK_WIDGET(gtktext));
-    return TRUE;
+       /* now do the menu wackiness */
+       popup_menu(gtkpspell, eb);
+       gtk_grab_remove(GTK_WIDGET(gtktext));
+       return TRUE;
 }
 
 void gtkpspell_uncheck_all(GtkPspell * gtkpspell) 
 {
 }
 
 void gtkpspell_uncheck_all(GtkPspell * gtkpspell) 
 {
-    int origpos;
-    unsigned char *text;
-    float adj_value;
-    GtkXText * gtktext;
-    gtktext=gtkpspell->gtktext;
-
-    adj_value = gtktext->vadj->value;
-    gtk_xtext_freeze(gtktext);
-    origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
-    text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
-    gtk_xtext_set_point(gtktext, 0);
-    gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext));
-    gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
-    gtk_xtext_thaw(gtktext);
-
-    gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
-    gtk_adjustment_set_value(gtktext->vadj, adj_value);
+       int origpos;
+       unsigned char *text;
+       float adj_value;
+       GtkXText *gtktext;
+       
+       gtktext=gtkpspell->gtktext;
+
+       adj_value = gtktext->vadj->value;
+       gtk_xtext_freeze(gtktext);
+       origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
+       text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
+       gtk_xtext_set_point(gtktext, 0);
+       gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext));
+       gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
+       gtk_xtext_thaw(gtktext);
+
+       gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
+       gtk_adjustment_set_value(gtktext->vadj, adj_value);
 }
 
 }
 
-void gtkpspell_attach(GtkPspell * gtkpspell, GtkXText *gtktext) 
+void gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *gtktext) 
 {
 {
-    gtkpspell->gtktext=gtktext;
-//    if (prefs_common.auto_makepspell) {
-        gtk_signal_connect(GTK_OBJECT(gtktext), "insert-text",
-                           GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
-        gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
-                                 GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
-//    };
-    gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
-                       GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
+       gtkpspell->gtktext=gtktext;
+/*    if (prefs_common.auto_makepspell) { */
+       gtk_signal_connect(GTK_OBJECT(gtktext), "insert-text",
+                          GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
+       gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
+                                GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
+/*    }; */
+       gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
+                          GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
 
 }
 
 void gtkpspell_detach(GtkPspell * gtkpspell) 
 {
 
 }
 
 void gtkpspell_detach(GtkPspell * gtkpspell) 
 {
-    GtkXText * gtktext;
-    gtktext=gtkpspell->gtktext;
-//    if (prefs_common.auto_makepspell) {
+       GtkXText * gtktext;
+       
+       gtktext =gtkpspell->gtktext;
+/*    if (prefs_common.auto_makepspell) { */
         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
                                       GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
                                       GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
                                       GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
                                       GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
-//    };
-    gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
-                                  GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
+/*    }; */
+       gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
+                                      GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
 
 
-    gtkpspell_uncheck_all(gtkpspell);
+       gtkpspell_uncheck_all(gtkpspell);
 }
 
 /*** Sylpheed (Claws) ***/
 }
 
 /*** Sylpheed (Claws) ***/