gfgit/claws-mail
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
claws-mail/src/gtkspell.c

1442 lines
40 KiB
C
Raw Blame History

/* gtkpspell - a spell-checking addon for GtkText
* Copyright (c) 2000 Evan Martin.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* 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
* Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto &
* The Sylpheed Claws Team.
* Adapted for pspell (c) 2001 Melvin Hadasht
*/
#if defined(HAVE_CONFIG_H)
#include "config.h"
#endif
#if USE_PSPELL
#include "intl.h"
#include <gtk/gtk.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <sys/time.h>
#include <fcntl.h>
#include <time.h>
#include <prefs_common.h>
#include <utils.h>
#include <dirent.h>
#include <gtk/gtkoptionmenu.h>
#include <gtk/gtkmenu.h>
#include <gtk/gtkmenuitem.h>
#include "gtkxtext.h"
#include "gtkspell.h"
#include <pspell/pspell.h>
/* size of the text buffer used in various word-processing routines. */
#define BUFSIZE 1024
/* number of suggestions to display on each menu. */
#define MENUCOUNT 15
/******************************************************************************/
/* 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 set_learn_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 gint compare_dict (Dictionary *a, Dictionary *b);
guchar *convert_to_pspell_encoding (const guchar *encoding);
/* gtkspellconfig - only one config per session */
GtkPspellConfig * gtkpspellconfig;
/* TODO: configurable */
static GdkColor highlight = { 0, 255 * 256, 0, 0 };
/******************************************************************************/
/* gtkspell_init() - run the first pspell_config from which every
* new config is cloned
*/
GtkPspellConfig * gtkpspell_init()
{
return new_pspell_config();
}
/* 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;
}
}
/* gtkspell_running - Test if there is a manager running
*/
int gtkpspell_running(GtkPspell * gtkpspell)
{
return (gtkpspell->config!=NULL);
}
/* 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 = 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);
}
gtkpspell->dictionary_list = NULL;
gtkpspell->path = NULL;
gtkpspell->dict = NULL;
gtkpspell->mode = PSPELL_FASTMODE;
gtkpspell->learn = TRUE;
gtkpspell->gtktext = NULL;
return gtkpspell;
}
/* gtkspell_new_with_config() - Creates a new session and set path/dic
*/
GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig,
guchar *path, guchar *dict,
guint mode, const 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->config = pspell_config_clone(gtkpspellconfig);
gtkpspell->mode = PSPELL_FASTMODE;
gtkpspell->learn = TRUE;
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) {
char *pspell_encoding;
pspell_encoding = convert_to_pspell_encoding (encoding);
debug_print(_("Pspell encoding: asked: %s changed to: %s\n"), encoding, pspell_encoding);
pspell_config_replace(gtkpspell->config, "encoding", (const char *)pspell_encoding);
if (pspell_config_error_number(gtkpspell->config) !=0 ) {
debug_print(_("Pspell encoding error: %s\nSwitching to iso8859-1 (sorry)\n"),
pspell_config_error_message(gtkpspell->config));
pspell_config_replace(gtkpspell->config, "encoding", "iso8859-1");
}
g_free(pspell_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;
}
/* gtkspell_delete() - Finishes a session
*/
GtkPspell *gtkpspell_delete( GtkPspell *gtkpspell )
{
if ( gtkpspell->checker ) {
/* First save all word lists */
pspell_manager_save_all_word_lists(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);
g_free(gtkpspell->path);
g_free(gtkpspell->dict);
gtkpspell->path = NULL;
gtkpspell->dict = NULL;
g_free(gtkpspell);
return NULL;
}
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 */
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;
language = buf;
if ((module = strrchr(buf, '-')) != NULL) {
module++;
if ((end = strrchr(module, '.')) != NULL)
end[0] = 0x00;
}
/* 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 (temppath[strlen(temppath)-1] == G_DIR_SEPARATOR)
temppath[strlen(temppath)-1]= 0;
if (temppath) {
pspell_config_replace(config, "add-word-list-path", temppath);
debug_print(_("Pspell config: added path %s\n"), pspell_config_retrieve(config, "word-list-path"));
if (pspell_config_error_number(config))
debug_print(_("Pspell config: %s\n"), pspell_config_error_message(config));
}
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);
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);
return TRUE;
}
/* gtkpspell_set_path_and_dict() - Set path and dict. The session is
* resetted.
* FALSE on error, TRUE 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
*/
config2 = pspell_config_clone(gtkpspell->config);
if (gtkpspell->checker) {
pspell_manager_save_all_word_lists(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 FALSE;
}
gtkpspell->possible_err = new_pspell_manager(config2);
delete_pspell_config(config2);
config2 = NULL;
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 FALSE;
}
gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err);
return TRUE;
}
/* 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 */
guchar *gtkpspell_get_dict(GtkPspell *gtkpspell)
{
/* Number of dashes in a dictionary name + 1 (for trailing null)
* needed when rebuilding dictionary name
*/
#define DASHES_IN_DICTNAME 3+1
guchar *dict;
guchar *language;
guchar *spelling;
guchar *jargon;
guint len;
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 + DASHES_IN_DICTNAME < BUFSIZE) {
dict = g_new(char,len + DASHES_IN_DICTNAME);
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;
}
/* gtkpspell_get_path() - Return the dict path as an allocated string */
/* Not used = not tested */
guchar *gtkpspell_get_path(GtkPspell *gtkpspell)
{
guchar * path;
g_return_val_if_fail(gtkpspell->config, NULL);
path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path"));
return path;
}
/* 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 */
gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &thelabel);
if (!strcmp2(thelabel, _("None")))
return;
thedict = g_strdup(thelabel);
/* Set path, dict, (and sug_mode ?) */
if(!gtkpspell_set_path_and_dict(gtkpspell, gtkpspell->path, thedict)) {
/* FIXME : try to handle this very special case */
debug_print("Pspell: Attempt to change to a non existant dict. I will crash after closing compose window.\n");
gtkpspell_detach(gtkpspell);
gtkpspell = gtkpspell_delete(gtkpspell);
}
g_free(thedict);
}
/* 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;
}
}
/* gtkpspell_set_sug_mode() - Set the suggestion mode */
/* 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;
pspell_manager_save_all_word_lists(gtkpspell->checker);
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 FALSE;
}
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 FALSE;
}
gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err);
return TRUE;
}
/* set_learn_mode() - menu callback to toggle learn mode */
static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell)
{
gtkpspell->learn = gtkpspell->learn == FALSE ;
}
/* misspelled_suggest() - Create a suggestion list for word */
static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word)
{
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;
}
/* misspelled_test() - Just test if word is correctly spelled */
static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word)
{
return pspell_manager_check(gtkpspell->checker, word, -1) ? 0 : 1;
}
static gboolean iswordsep(unsigned char c)
{
return !isalpha(c) && c != '\'';
}
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;
}
/* get_word_from_pos () - return the word pointed to. */
/* Handles correctly the quotes. */
static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos,
unsigned char* buf,
int *pstart, int *pend)
{
/* TODO : when correcting a word into quotes, change the color of */
/* the quotes too, as may be they were highlighted before. To do */
/* so, we can use two others pointers that points to the whole */
/* word including quotes. */
gint start,
end;
guchar c;
GtkXText *gtktext;
gtktext = gtkpspell->gtktext;
if (iswordsep(get_text_index_whar(gtkpspell, pos)))
return FALSE;
/* The apostrophe character is somtimes used for quotes
* So include it in the word only if it is not surrounded
* by other characters.
*/
for (start = pos; start >= 0; --start) {
c = get_text_index_whar(gtkpspell, start);
if (c == '\'') {
if (start > 0) {
if (!isalpha(get_text_index_whar(gtkpspell, start - 1))) {
/* start_quote = TRUE; */
break;
}
}
else {
/* start_quote = TRUE; */
break;
}
}
else
if (!isalpha(c))
break;
}
start++;
for (end = pos; end < gtk_xtext_get_length(gtktext); end++) {
c = get_text_index_whar(gtkpspell, end);
if (c == '\'') {
if (end < gtk_xtext_get_length(gtktext)) {
if (!isalpha(get_text_index_whar(gtkpspell, end + 1))) {
/* end_quote = TRUE; */
break;
}
}
else {
/* end_quote = TRUE; */
break;
}
}
else
if(!isalpha(c))
break;
}
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;
return TRUE;
}
static gboolean get_curword(GtkPspell *gtkpspell, unsigned char* buf,
int *pstart, int *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,
GdkColor *color)
{
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);
g_free(newtext);
}
gtk_xtext_thaw(gtktext);
}
static gboolean check_at(GtkPspell *gtkpspell, int from_pos)
{
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);
}
void gtkpspell_check_all(GtkPspell *gtkpspell)
{
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,
GtkPspell * gtkpspell)
{
guint origpos;
if (!gtkpspell_running(gtkpspell))
return;
/* We must insert ourself the character to impose the */
/* color of the inserted character to be default */
/* Never mess with set_insertion when frozen */
gtk_xtext_freeze(gtktext);
gtk_xtext_backward_delete(GTK_XTEXT(gtktext), len);
gtk_xtext_insert(GTK_XTEXT(gtktext), NULL,
&(GTK_WIDGET(gtktext)->style->fg[0]), NULL, newtext, len);
*ppos = gtk_xtext_get_point(GTK_XTEXT(gtktext));
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);
}
gtk_xtext_thaw(gtktext);
gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
}
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));
if (start) {
check_at(gtkpspell, start - 1);
check_at(gtkpspell, start);
}
gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
gtk_xtext_set_point(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)
{
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 (end-start > 0 && gtkpspell->learn) {
/* Just be sure the buffer ends somewhere... */
buf[end-start] = 0;
/* Learn from common misspellings */
pspell_manager_store_replacement(gtkpspell->checker, buf,
end-start, newword,
strlen(newword));
}
/* 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));
}
/* 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));
pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword, strlen(gtkpspell->theword));
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));
}
/* add_word_to_personal() - add word to personal dict. */
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));
pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword));
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));
}
static GtkMenu *make_menu_config(GtkPspell *gtkpspell)
{
GtkWidget *menu, *item, *submenu;
menu = gtk_menu_new();
item = gtk_menu_item_new_with_label(_("Spell check all"));
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
gtk_signal_connect(GTK_OBJECT(item),"activate",
GTK_SIGNAL_FUNC(check_all),
gtkpspell);
item = gtk_menu_item_new();
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu),item);
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);
{
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();
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
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);
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);
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);
item = gtk_menu_item_new();
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
item = gtk_check_menu_item_new_with_label(_("Learn from mistakes"));
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),
gtkpspell->learn);
gtk_signal_connect(GTK_OBJECT(item), "activate",
GTK_SIGNAL_FUNC(set_learn_mode), gtkpspell);
return GTK_MENU(menu);
}
/* 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;
menu = gtk_menu_new();
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);
gtk_signal_connect(GTK_OBJECT(item), "activate",
GTK_SIGNAL_FUNC(add_word_to_session),
gtkpspell);
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);
gtk_signal_connect(GTK_OBJECT(item), "activate",
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_with_label(_("(no suggestions)"));
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
} 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);
}
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] = 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:
* we need to let the right-mouse-click go through, so it moves the cursor,
* but we *can't* let it go through, because GtkText interprets rightclicks as
* weird selection modifiers.
*
* 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)
{
GdkEventButton *eb;
gboolean retval;
if (!gtkpspell_running(gtkpspell))
return FALSE;
if (e->type != GDK_BUTTON_PRESS)
return FALSE;
eb = (GdkEventButton*) e;
if (eb->button != 3)
return FALSE;
/* forge the leftclick */
eb->button = 1;
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");
/* now do the menu wackiness */
popup_menu(gtkpspell, eb);
gtk_grab_remove(GTK_WIDGET(gtktext));
return TRUE;
}
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);
}
void gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *gtktext)
{
gtkpspell->gtktext=gtktext;
gtk_signal_connect_after(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)
{
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(button_press_intercept_cb), gtkpspell);
gtkpspell_uncheck_all(gtkpspell);
}
/*** Sylpheed (Claws) ***/
static GSList *create_empty_dictionary_list(void)
{
GSList *list = NULL;
Dictionary *dict;
dict = g_new0(Dictionary, 1);
dict->name = g_strdup(_("None"));
return g_slist_append(list, dict);
}
/* gtkpspell_get_dictionary_list() - returns list of dictionary names */
GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path)
{
GSList *list;
gchar *dict_path, *tmp, *prevdir;
GSList *walk;
Dictionary *dict;
DIR *dir;
struct dirent *ent;
list = NULL;
#ifdef USE_THREADS
#warning TODO: no directory change
#endif
dict_path=g_strdup(pspell_path);
prevdir = g_get_current_dir();
if (chdir(dict_path) <0) {
FILE_OP_ERROR(dict_path, "chdir");
g_free(prevdir);
g_free(dict_path);
return create_empty_dictionary_list();
}
debug_print(_("Checking for dictionaries in %s\n"), dict_path);
if (NULL != (dir = opendir("."))) {
while (NULL != (ent = readdir(dir))) {
/* search for pwli */
if (NULL != (tmp = strstr(ent->d_name, ".pwli"))) {
dict = g_new0(Dictionary, 1);
dict->name = g_strndup(ent->d_name, tmp - ent->d_name);
debug_print(_("Found dictionary %s\n"), dict->name);
list = g_slist_insert_sorted(list, dict, (GCompareFunc) compare_dict);
}
}
closedir(dir);
}
else {
FILE_OP_ERROR(dict_path, "opendir");
debug_print(_("No dictionary found\n"));
list = create_empty_dictionary_list();
}
if(list==NULL){
debug_print(_("No dictionary found\n"));
list = create_empty_dictionary_list();
}
chdir(prevdir);
g_free(dict_path);
g_free(prevdir);
return list;
}
/* compare_dict () - compare 2 dict names */
static gint compare_dict(Dictionary *a, Dictionary *b)
{
guchar *alanguage, *blanguage,
*aspelling, *bspelling,
*ajargon , *bjargon ,
*amodule , *bmodule ;
guint aparts = 0, bparts = 0, i;
for (i=0; i < strlen(a->name) ; i++)
if (a->name[i]=='-')
aparts++;
for (i=0; i < strlen(b->name) ; i++)
if (b->name[i]=='-')
bparts++;
if (aparts != bparts)
return (aparts < bparts) ? -1 : +1 ;
else
return strcmp2(a->name, b->name);
}
void gtkpspell_free_dictionary_list(GSList *list)
{
Dictionary *dict;
GSList *walk;
for (walk = list; walk != NULL; walk = g_slist_next(walk))
if (walk->data) {
dict = (Dictionary *) walk->data;
if (dict->name)
g_free(dict->name);
g_free(dict);
}
g_slist_free(list);
}
static void dictionary_option_menu_item_data_destroy(gpointer data)
{
gchar *str = (gchar *) data;
if (str)
g_free(str);
}
GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path)
{
GSList *dict_list, *tmp;
GtkWidget *item;
GtkWidget *menu;
Dictionary *dict;
dict_list = gtkpspell_get_dictionary_list(pspell_path);
g_return_val_if_fail(dict_list, NULL);
menu = gtk_menu_new();
for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
dict = (Dictionary *) tmp->data;
item = gtk_menu_item_new_with_label(dict->name);
if (dict->name)
gtk_object_set_data_full(GTK_OBJECT(item), "dict_name",
g_strdup(dict->name),
dictionary_option_menu_item_data_destroy);
gtk_menu_append(GTK_MENU(menu), item);
gtk_widget_show(item);
}
gtk_widget_show(menu);
gtkpspell_free_dictionary_list(dict_list);
return menu;
}
gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu)
{
GtkWidget *menuitem;
gchar *result;
g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
menuitem = gtk_menu_get_active(GTK_MENU(menu));
result = gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name");
g_return_val_if_fail(result, NULL);
return g_strdup(result);
}
/* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-*
* as needed by pspell. Returns an allocated string.
*/
guchar *convert_to_pspell_encoding (const guchar *encoding)
{
guchar * pspell_encoding;
if (strstr2(encoding, "ISO-8859-")) {
pspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
}
else
if (!strcmp2(encoding, "US-ASCII"))
pspell_encoding = g_strdup("iso8859-1");
else
pspell_encoding = g_strdup(encoding);
return pspell_encoding;
}
#endif
Reference in a new issue View git blame Copy permalink