Attachment #82854 for bug #127142

View | Details | Raw Unified | Return to bug 127142
Collapse All | Expand All





Gnome Spell is GNOME/Bonobo component for spell checking. In current 0.1 version
it contains GNOME::Spell::Dictionary object, which provides spell checking dictionary
(see Spell.idl for exact API definition). It's based on Enchant package, which is required
to build gnome-spell.

Dictionary object could be used for live spell checking. Look in test-spell.c or

In future it will be expanded by implementation of GNOME::Spell::Checker object (see
also Spell.idl) and also by spell checking dialog control with appropriate interface.

Enchant build
------------

From my experience with Enchant I recommend you to build it this way:

	1) build and install Pspell, Aspell
	2) build and install Enchant
	4) build and install GNOME Spell

You could get Enchant from:

	http://www.abisource.com/enchant/
	http://aspell.sourceforge.net/

End
---




AC_SUBST(API_VERSION)

dnl
dnl aspell
dnl

AC_ARG_WITH(aspell-prefix, [  --with-aspell-prefix=DIR
                          specify under which prefix aspell is installed.], with_aspell_prefix="$withval", )

if test "x$with_aspell_prefix" != "x"; then
   saved_LDFLAGS=$LDFLAGS
   LDFLAGS="-L$with_aspell_prefix/lib "$LDFLAGS
   ASPELL_INC="-I$with_aspell_prefix/include"
   ASPELL_LIBS="-L$with_aspell_prefix/lib -laspell"
   ASPELL_DATA="$with_aspell_prefix/lib/aspell"
else
   LDFLAGS="-L`aspell config prefix`/lib "$LDFLAGS
   ASPELL_INC="-I`aspell config prefix`/include"
   ASPELL_LIBS="-L`aspell config prefix`/lib -laspell"
   ASPELL_DICT="`aspell config dict-dir`"
fi
AC_CHECK_LIB(aspell,new_aspell_config,,AC_MSG_ERROR([gnome-spell cannot be built without aspell library]),)
if test "x$with_aspell_prefix" != "x"; then
   LDFLAGS=$saved_LDFLAGS
fi

AC_SUBST(ASPELL_DICT)
AC_SUBST(ASPELL_INC)
AC_SUBST(ASPELL_LIBS)

dnl
dnl flags
dnl


AC_SUBST(CPPFLAGS)
AC_SUBST(LDFLAGS)

GNOME_SPELL_MODULES="libgnomeui-2.0 >= 1.112.1 libbonoboui-2.0 >= 1.112.1 libglade-2.0 >= 1.99.9 enchant >= 1.2.2"
PKG_CHECK_MODULES(GNOME_SPELL, $GNOME_SPELL_MODULES)
AC_SUBST(GNOME_SPELL_CFLAGS)
AC_SUBST(GNOME_SPELL_LIBS)





INCLUDES =                                              \
        -I$(srcdir)                                     \
	$(ASPELL_INC)					\
	-DPREFIX=\""$(prefix)"\"			\
        -DGNOMEDATADIR=\""$(datadir)"\"         	\
        -DGNOMELOCALEDIR=\""$(datadir)/locale"\"        \
	-DGLADE_DATADIR=\"$(gladedir)\"			\
	-DPLUGIN_DIR=\""$(PLUGIN_DIR)"\"		\
	-DASPELL_DICT=\""$(ASPELL_DICT)"\"		\
	$(GNOME_SPELL_CFLAGS)				\
	$(END)


libgnome_spell_component_la_LDFLAGS = -release $(API_VERSION) $(NO_UNDEFINED)
libgnome_spell_component_la_LIBADD = 		\
	libgnome-spell-idl.la		\
	$(ASPELL_LIBS)		\
	$(GNOME_SPELL_LIBS)			\
	$(END)



test_gnome_spell_component_LDADD =		\
	libgnome-spell-idl.la		\
	$(ASPELL_LIBS)				\
	$(GNOME_SPELL_LIBS)			\
	$(END)


Lines 36-41 Link Here

(-)gnome-spell-1.0.7.orig/gnome-spell/dictionary.c (-86 / +60 lines)
36	#include "Spell.h"	36	#include "Spell.h"
37	#include "dictionary.h"	37	#include "dictionary.h"
38		38
		39	#include <enchant.h>
		40
		41	typedef struct {
		42	EnchantBroker * config;
		43	EnchantDict * speller;
		44	} SpellEngine;
		45
39	static BonoboObjectClass *dictionary_parent_class;	46	static BonoboObjectClass *dictionary_parent_class;
40		47
41	#define DICT_DEBUG(x)	48	#define DICT_DEBUG(x)
Lines 72-83 Link Here
72	{	79	{
73	GNOMESpellDictionary *dict = GNOME_SPELL_DICTIONARY (object);	80	GNOMESpellDictionary *dict = GNOME_SPELL_DICTIONARY (object);
74		81
75	dict->changed = TRUE;
76	dict->engines = NULL;	82	dict->engines = NULL;
77	dict->languages = g_hash_table_new (g_str_hash, g_str_equal);	83	dict->languages = g_hash_table_new (g_str_hash, g_str_equal);
78	dict->engines_ht = g_hash_table_new (NULL, NULL);	84	dict->engines_ht = g_hash_table_new (NULL, NULL);
79	}	85	}
80		86
		87	static char **
		88	dup_string_list (char ** str_list, size_t list_len)
		89	{
		90	char ** new_str_list;
		91	size_t i;
		92
		93	new_str_list = g_new0 (char *, list_len + 1);
		94	for (i = 0; i < list_len; i++)
		95	new_str_list [i] = g_strdup (str_list [i]);
		96
		97	return new_str_list;
		98	}
		99
81	static void	100	static void
82	dictionary_finalize (GObject *object)	101	dictionary_finalize (GObject *object)
83	{	102	{
Lines 93-107 Link Here
93	}	112	}
94		113
95	static SpellEngine *	114	static SpellEngine *
96	new_engine (const gchar *language)	115	new_engine (const gchar language, CORBA_Environment ev)
97	{	116	{
98	SpellEngine *se;	117	SpellEngine *se;
99		118
100	se = g_new0 (SpellEngine, 1);	119	se = g_new0 (SpellEngine, 1);
101	se->config = new_aspell_config ();	120	se->config = enchant_broker_init ();
102	aspell_config_replace (se->config, "language-tag", language);	121	se->speller = enchant_broker_request_dict (se->config, language);
103	aspell_config_replace (se->config, "encoding", "utf-8");	122
104	se->changed = TRUE;	123	if(se->speller == NULL)
		124	raise_error (ev, enchant_broker_get_error (se->config));
105		125
106	return se;	126	return se;
107	}	127	}
Lines 129-137 Link Here
129	SpellEngine *se = dict->engines->data;	149	SpellEngine *se = dict->engines->data;
130		150
131	if (se->speller)	151	if (se->speller)
132	delete_aspell_speller (se->speller);	152	enchant_broker_free_dict (se->config, se->speller);
133	if (se->config)	153	if (se->config)
134	delete_aspell_config (se->config);	154	enchant_broker_free (se->config);
135	g_free (se);	155	g_free (se);
136	dict->engines = g_slist_remove (dict->engines, se);	156	dict->engines = g_slist_remove (dict->engines, se);
137	}	157	}
Lines 140-146 Link Here
140	g_hash_table_foreach_remove (dict->languages, remove_engine_ht, NULL);	160	g_hash_table_foreach_remove (dict->languages, remove_engine_ht, NULL);
141		161
142	dict->engines = NULL;	162	dict->engines = NULL;
143	dict->changed = TRUE;
144	}	163	}
145		164
146	static LangInfo known_languages [] = {	165	static LangInfo known_languages [] = {
Lines 355-382 Link Here
355	get_languages_real (gint *ln)	374	get_languages_real (gint *ln)
356	{	375	{
357	GSList *langs;	376	GSList *langs;
358	AspellCanHaveError *err;	377	EnchantBroker *broker;
359	AspellConfig *config;
360	AspellSpeller *speller;
361	gint i;	378	gint i;
362		379
363	DICT_DEBUG (printf ("get_languages_real\n"));	380	DICT_DEBUG (printf ("get_languages_real\n"));
364		381
		382	/* todo: this could probably be better done by enchant_broker_list_dicts(), but let's keep
		383	the initial code change to a minimum */
		384
		385	broker = enchant_broker_init ();
365	langs = NULL;	386	langs = NULL;
366	*ln = 0;	387	*ln = 0;
367	for (i=0; i < G_N_ELEMENTS (known_languages); i++) {	388	for (i=0; i < G_N_ELEMENTS (known_languages); i++) {
368	config = new_aspell_config ();	389	if (enchant_broker_dict_exists (broker, known_languages [i].abbreviation)) {
369	aspell_config_replace (config, "language-tag", known_languages [i].abbreviation);
370	err = new_aspell_speller (config);
371	if (aspell_error_number (err) == 0) {
372	speller = to_aspell_speller (err);
373	DICT_DEBUG (printf ("Language: %s\n", known_languages [i].name));	390	DICT_DEBUG (printf ("Language: %s\n", known_languages [i].name));
374	delete_aspell_speller (speller);
375	langs = g_slist_prepend (langs, GINT_TO_POINTER (i));	391	langs = g_slist_prepend (langs, GINT_TO_POINTER (i));
376	(*ln) ++;	392	(*ln) ++;
377	}	393	}
378	}	394	}
379		395
		396	enchant_broker_free (broker);
		397
380	return langs;	398	return langs;
381	}	399	}
382		400
Lines 405-420 Link Here
405	{	423	{
406	GSList langs, l;	424	GSList langs, l;
407	GConfClient *gc;	425	GConfClient *gc;
408	time_t mtime;
409	struct stat buf;
410	gint i, kl;	426	gint i, kl;
411		427
412	gc = gconf_client_get_default ();	428	gc = gconf_client_get_default ();
413		429
414	mtime = gconf_client_get_int (gc, GNOME_SPELL_GCONF_DIR "/mtime", NULL);
415	kl = gconf_client_get_int (gc, GNOME_SPELL_GCONF_DIR "/known_languages", NULL);	430	kl = gconf_client_get_int (gc, GNOME_SPELL_GCONF_DIR "/known_languages", NULL);
416		431
417	if (stat (ASPELL_DICT, &buf) \|\| buf.st_mtime != mtime \|\| kl != G_N_ELEMENTS(known_languages)) {	432	if (kl != G_N_ELEMENTS(known_languages)) {
418	GString *str;	433	GString *str;
419	langs = get_languages_real (ln);	434	langs = get_languages_real (ln);
420		435
Lines 425-431 Link Here
425	gconf_client_set_int (gc, str->str, GPOINTER_TO_INT (l->data), NULL);	440	gconf_client_set_int (gc, str->str, GPOINTER_TO_INT (l->data), NULL);
426	l = l->next;	441	l = l->next;
427	}	442	}
428	gconf_client_set_int (gc, GNOME_SPELL_GCONF_DIR "/mtime", buf.st_mtime, NULL);	443
429	gconf_client_set_int (gc, GNOME_SPELL_GCONF_DIR "/known_languages", G_N_ELEMENTS(known_languages), NULL);	444	gconf_client_set_int (gc, GNOME_SPELL_GCONF_DIR "/known_languages", G_N_ELEMENTS(known_languages), NULL);
430	g_string_free (str, TRUE);	445	g_string_free (str, TRUE);
431	gnome_config_sync ();	446	gnome_config_sync ();
Lines 504-554 Link Here
504	SpellEngine *se;	519	SpellEngine *se;
505		520
506	one_language = g_strndup (begin, len);	521	one_language = g_strndup (begin, len);
507	se = new_engine (one_language);	522	se = new_engine (one_language, ev);
508	dict->engines = g_slist_prepend (dict->engines, se);	523	dict->engines = g_slist_prepend (dict->engines, se);
509	g_hash_table_insert (dict->languages, one_language, se);	524	g_hash_table_insert (dict->languages, one_language, se);
510	g_hash_table_insert (dict->engines_ht, se, g_strdup (one_language));	525	g_hash_table_insert (dict->engines_ht, se, g_strdup (one_language));
511
512	dict->changed = TRUE;
513	}
514	}
515	}
516
517	static void
518	update_engine (SpellEngine se, CORBA_Environment ev)
519	{
520	AspellCanHaveError *err;
521
522	DICT_DEBUG (printf ("Dictionary: creating new aspell speller\n"));
523
524	if (se->changed) {
525	if (se->speller)
526	delete_aspell_speller (se->speller);
527	err = new_aspell_speller (se->config);
528	if (aspell_error_number (err) != 0) {
529	g_warning ("aspell error: %s\n", aspell_error_message (err));
530	se->speller = NULL;
531	raise_error (ev, aspell_error_message (err));
532	} else {
533	se->speller = to_aspell_speller (err);
534	se->changed = FALSE;
535	}
536	}
537	}
538
539	static void
540	update_engines (GNOMESpellDictionary dict, CORBA_Environment ev)
541	{
542	g_return_if_fail (IS_GNOME_SPELL_DICTIONARY (dict));
543
544	if (dict->changed) {
545	GSList *l;
546
547	for (l = dict->engines; l; l = l->next) {
548	update_engine ((SpellEngine *) l->data, ev);
549	}	526	}
550
551	dict->changed = FALSE;
552	}	527	}
553	}	528	}
554		529
Lines 556-562 Link Here
556	engine_check_word (SpellEngine se, const gchar word, CORBA_Environment *ev)	531	engine_check_word (SpellEngine se, const gchar word, CORBA_Environment *ev)
557	{	532	{
558	CORBA_boolean result = CORBA_TRUE;	533	CORBA_boolean result = CORBA_TRUE;
559	gint aspell_result;	534	gint enchant_result;
560		535
561	#ifndef G_DISABLE_CHECKS	536	#ifndef G_DISABLE_CHECKS
562	g_return_val_if_fail (se->speller, CORBA_TRUE);	537	g_return_val_if_fail (se->speller, CORBA_TRUE);
Lines 564-575 Link Here
564	if (!se->speller)	539	if (!se->speller)
565	return CORBA_TRUE;	540	return CORBA_TRUE;
566	#endif	541	#endif
567	aspell_result = aspell_speller_check (se->speller, word, strlen (word));	542	enchant_result = enchant_dict_check (se->speller, word, strlen (word));
568	if (aspell_result == 0)	543	if (enchant_result == 0)
569	result = CORBA_FALSE;	544	result = CORBA_FALSE;
570	if (aspell_result == -1) {	545	if (enchant_result == -1) {
571	g_warning ("aspell error: %s\n", aspell_speller_error_message (se->speller));	546	g_warning ("enchant error: %s\n", enchant_dict_get_error (se->speller));
572	raise_error (ev, aspell_speller_error_message (se->speller));	547	raise_error (ev, enchant_dict_get_error (se->speller));
573	}	548	}
574		549
575	return result;	550	return result;
Lines 592-598 Link Here
592	if (!strcmp (word, "Ximian"))	567	if (!strcmp (word, "Ximian"))
593	return CORBA_TRUE;	568	return CORBA_TRUE;
594		569
595	update_engines (dict, ev);
596	for (l = dict->engines; l; l = l->next) {	570	for (l = dict->engines; l; l = l->next) {
597	if (((SpellEngine *) l->data)->speller) {	571	if (((SpellEngine *) l->data)->speller) {
598	valid_speller = TRUE;	572	valid_speller = TRUE;
Lines 621-631 Link Here
621	if (!word)	595	if (!word)
622	return;	596	return;
623	#endif	597	#endif
624	update_engines (dict, ev);
625	DICT_DEBUG (printf ("Dictionary add_word_to_session: %s\n", word));	598	DICT_DEBUG (printf ("Dictionary add_word_to_session: %s\n", word));
626	for (l = dict->engines; l; l = l->next) {	599	for (l = dict->engines; l; l = l->next) {
627	if (((SpellEngine *) l->data)->speller)	600	if (((SpellEngine *) l->data)->speller)
628	aspell_speller_add_to_session (((SpellEngine *) l->data)->speller, word, strlen (word));	601	enchant_dict_add_to_session (((SpellEngine *) l->data)->speller, word, strlen (word));
629	}	602	}
630	}	603	}
631		604
Lines 642-648 Link Here
642	if (!word \|\| !language)	615	if (!word \|\| !language)
643	return;	616	return;
644	#endif	617	#endif
645	update_engines (dict, ev);
646	DICT_DEBUG (printf ("Dictionary add_word_to_personal: %s (%s)\n", word, language));	618	DICT_DEBUG (printf ("Dictionary add_word_to_personal: %s (%s)\n", word, language));
647	se = (SpellEngine *) g_hash_table_lookup (dict->languages, language);	619	se = (SpellEngine *) g_hash_table_lookup (dict->languages, language);
648		620
Lines 666-672 Link Here
666	if (!word \|\| !replacement)	638	if (!word \|\| !replacement)
667	return;	639	return;
668	#endif	640	#endif
669	update_engines (dict, ev);
670	DICT_DEBUG (printf ("Dictionary correction: %s <-- %s\n", word, replacement));	641	DICT_DEBUG (printf ("Dictionary correction: %s <-- %s\n", word, replacement));
671	se = (SpellEngine *) g_hash_table_lookup (dict->languages, language);	642	se = (SpellEngine *) g_hash_table_lookup (dict->languages, language);
672		643
Lines 683-690 Link Here
683	const CORBA_char word, CORBA_Environment ev)	654	const CORBA_char word, CORBA_Environment ev)
684	{	655	{
685	GNOMESpellDictionary *dict = GNOME_SPELL_DICTIONARY (bonobo_object_from_servant (servant));	656	GNOMESpellDictionary *dict = GNOME_SPELL_DICTIONARY (bonobo_object_from_servant (servant));
686	const AspellWordList *suggestions;	657	char **suggestions;
687	AspellStringEnumeration *elements;	658	size_t number_of_suggestions;
688	GNOME_Spell_StringSeq *seq = NULL;	659	GNOME_Spell_StringSeq *seq = NULL;
689	GSList l, suggestion_list = NULL;	660	GSList l, suggestion_list = NULL;
690	gint i, len, pos;	661	gint i, len, pos;
Lines 696-712 Link Here
696	return NULL;	667	return NULL;
697	#endif	668	#endif
698	DICT_DEBUG (printf ("Dictionary correction: %s\n", word));	669	DICT_DEBUG (printf ("Dictionary correction: %s\n", word));
699	update_engines (dict, ev);
700		670
701	len = 0;	671	len = 0;
702	for (l = dict->engines; l; l = l->next) {	672	for (l = dict->engines; l; l = l->next) {
703	SpellEngine se = (SpellEngine ) l->data;	673	SpellEngine se = (SpellEngine ) l->data;
704		674
705	if (se->speller) {	675	if (se->speller) {
706	suggestions = aspell_speller_suggest (se->speller, word, strlen (word));	676	suggestions = enchant_dict_suggest (se->speller, word, strlen (word), &number_of_suggestions);
707	suggestion_list = g_slist_prepend (suggestion_list, (gpointer) suggestions);	677	suggestion_list = g_slist_prepend (suggestion_list,
708	len += 2*aspell_word_list_size (suggestions);	678	(gpointer) dup_string_list (suggestions, number_of_suggestions));
		679	len += 2*number_of_suggestions;
709	suggestion_list = g_slist_prepend (suggestion_list, engine_to_language (dict, se));	680	suggestion_list = g_slist_prepend (suggestion_list, engine_to_language (dict, se));
		681	suggestion_list = g_slist_prepend (suggestion_list, GINT_TO_POINTER (number_of_suggestions));
		682	enchant_dict_free_string_list (se->speller, suggestions);
710	}	683	}
711	}	684	}
712		685
Lines 723-739 Link Here
723	gint list_len;	696	gint list_len;
724	gchar *language;	697	gchar *language;
725		698
		699	list_len = GPOINTER_TO_INT (l->data);
		700	l = l->next;
726	language = (gchar *) l->data;	701	language = (gchar *) l->data;
727	l = l->next;	702	l = l->next;
728	suggestions = (const AspellWordList *) l->data;	703	suggestions = (char **) l->data;
729	elements = aspell_word_list_elements (suggestions);
730	list_len = aspell_word_list_size (suggestions);
731	for (i = 0; i < list_len; i ++, pos ++) {	704	for (i = 0; i < list_len; i ++, pos ++) {
732	seq->_buffer [pos] = CORBA_string_dup (aspell_string_enumeration_next (elements));	705	seq->_buffer [pos] = CORBA_string_dup (suggestions [i]);
733	pos ++;	706	pos ++;
734	seq->_buffer [pos] = CORBA_string_dup (language);	707	seq->_buffer [pos] = CORBA_string_dup (language);
735	}	708	}
736	delete_aspell_string_enumeration (elements);	709
		710	g_strfreev (suggestions);
737	}	711	}
738	CORBA_sequence_set_release (seq, CORBA_TRUE);	712	CORBA_sequence_set_release (seq, CORBA_TRUE);
739	g_slist_free (suggestion_list);	713	g_slist_free (suggestion_list);




G_BEGIN_DECLS

#include <bonobo/bonobo-object.h>
#include <aspell.h>

#define GNOME_SPELL_DICTIONARY_TYPE        (gnome_spell_dictionary_get_type ())
#define GNOME_SPELL_DICTIONARY(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), \

#define IS_GNOME_SPELL_DICTIONARY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNOME_SPELL_DICTIONARY_TYPE))

typedef struct {
	AspellConfig  *config;
	AspellSpeller *speller;
	gboolean       changed;
} SpellEngine;

typedef struct {
	gchar *abbreviation;
	gchar *name;
} LangInfo;

typedef struct {
	BonoboObject parent;

	gboolean changed;
	GSList *engines;
	GHashTable *languages;
	GHashTable *engines_ht;




Source:		ftp://ftp.gnome.org/pub/GNOME/unstable/sources/%{name}/%{name}-%{version}.tar.gz
Summary:	The spelling component for bonobo
Group:		System Environment/Libraries
Requires:	enchant >= 0.3.0
Requires:	pspell >= 0.12
Requires:	bonobo >= 0.28
Requires:	gal >= 0.7.99.5
BuildRequires:  enchant-devel >= 0.3.0
BuildRequires:  pspell-devel >= 0.12
BuildRequires:  bonobo-devel >= 0.28
BuildRequires:  libglade-devel
BuildRequires:	gal-devel >= 0.7.99.5

Return to bug 127142

Lines 3-9 Link Here

(-)gnome-spell-1.0.7.orig/README (-8 / +7 lines)
3		3
4	Gnome Spell is GNOME/Bonobo component for spell checking. In current 0.1 version	4	Gnome Spell is GNOME/Bonobo component for spell checking. In current 0.1 version
5	it contains GNOME::Spell::Dictionary object, which provides spell checking dictionary	5	it contains GNOME::Spell::Dictionary object, which provides spell checking dictionary
6	(see Spell.idl for exact API definition). It's based on pspell package, which is required	6	(see Spell.idl for exact API definition). It's based on Enchant package, which is required
7	to build gnome-spell.	7	to build gnome-spell.
8		8
9	Dictionary object could be used for live spell checking. Look in test-spell.c or	9	Dictionary object could be used for live spell checking. Look in test-spell.c or
Lines 12-30 Link Here
12	In future it will be expanded by implementation of GNOME::Spell::Checker object (see	12	In future it will be expanded by implementation of GNOME::Spell::Checker object (see
13	also Spell.idl) and also by spell checking dialog control with appropriate interface.	13	also Spell.idl) and also by spell checking dialog control with appropriate interface.
14		14
15	Pspell build	15	Enchant build
16	------------	16	------------
17		17
18	From my experience with pspell I recommend you to build pspell/aspell this way:	18	From my experience with Enchant I recommend you to build it this way:
19		19
20	1) build and install pspell	20	1) build and install Pspell, Aspell
21	2) build and install aspell	21	2) build and install Enchant
22	4) build and install GNOME Spell	22	4) build and install GNOME Spell
23		23
24	You could get Pspell and Aspell from:	24	You could get Enchant from:
25		25
26	http://pspell.sourceforge.net/	26	http://www.abisource.com/enchant/
27	http://aspell.sourceforge.net/
28		27
29	End	28	End
30	---	29	---

Lines 68-101 Link Here

(-)gnome-spell-1.0.7.orig/configure.in (-29 / +1 lines)
68	AC_SUBST(API_VERSION)	68	AC_SUBST(API_VERSION)
69		69
70	dnl	70	dnl
71	dnl aspell
72	dnl
73
74	AC_ARG_WITH(aspell-prefix, [ --with-aspell-prefix=DIR
75	specify under which prefix aspell is installed.], with_aspell_prefix="$withval", )
76
77	if test "x$with_aspell_prefix" != "x"; then
78	saved_LDFLAGS=$LDFLAGS
79	LDFLAGS="-L$with_aspell_prefix/lib "$LDFLAGS
80	ASPELL_INC="-I$with_aspell_prefix/include"
81	ASPELL_LIBS="-L$with_aspell_prefix/lib -laspell"
82	ASPELL_DATA="$with_aspell_prefix/lib/aspell"
83	else
84	LDFLAGS="-L`aspell config prefix`/lib "$LDFLAGS
85	ASPELL_INC="-I`aspell config prefix`/include"
86	ASPELL_LIBS="-L`aspell config prefix`/lib -laspell"
87	ASPELL_DICT="`aspell config dict-dir`"
88	fi
89	AC_CHECK_LIB(aspell,new_aspell_config,,AC_MSG_ERROR([gnome-spell cannot be built without aspell library]),)
90	if test "x$with_aspell_prefix" != "x"; then
91	LDFLAGS=$saved_LDFLAGS
92	fi
93
94	AC_SUBST(ASPELL_DICT)
95	AC_SUBST(ASPELL_INC)
96	AC_SUBST(ASPELL_LIBS)
97
98	dnl
99	dnl flags	71	dnl flags
100	dnl	72	dnl
101		73
Lines 104-110 Link Here
104	AC_SUBST(CPPFLAGS)	76	AC_SUBST(CPPFLAGS)
105	AC_SUBST(LDFLAGS)	77	AC_SUBST(LDFLAGS)
106		78
107	GNOME_SPELL_MODULES="libgnomeui-2.0 >= 1.112.1 libbonoboui-2.0 >= 1.112.1 libglade-2.0 >= 1.99.9"	79	GNOME_SPELL_MODULES="libgnomeui-2.0 >= 1.112.1 libbonoboui-2.0 >= 1.112.1 libglade-2.0 >= 1.99.9 enchant >= 1.2.2"
108	PKG_CHECK_MODULES(GNOME_SPELL, $GNOME_SPELL_MODULES)	80	PKG_CHECK_MODULES(GNOME_SPELL, $GNOME_SPELL_MODULES)
109	AC_SUBST(GNOME_SPELL_CFLAGS)	81	AC_SUBST(GNOME_SPELL_CFLAGS)
110	AC_SUBST(GNOME_SPELL_LIBS)	82	AC_SUBST(GNOME_SPELL_LIBS)

Lines 7-19 Link Here

(-)gnome-spell-1.0.7.orig/gnome-spell/Makefile.am (-4 lines)
7		7
8	INCLUDES = \	8	INCLUDES = \
9	-I$(srcdir) \	9	-I$(srcdir) \
10	$(ASPELL_INC) \
11	-DPREFIX=\""$(prefix)"\" \	10	-DPREFIX=\""$(prefix)"\" \
12	-DGNOMEDATADIR=\""$(datadir)"\" \	11	-DGNOMEDATADIR=\""$(datadir)"\" \
13	-DGNOMELOCALEDIR=\""$(datadir)/locale"\" \	12	-DGNOMELOCALEDIR=\""$(datadir)/locale"\" \
14	-DGLADE_DATADIR=\"$(gladedir)\" \	13	-DGLADE_DATADIR=\"$(gladedir)\" \
15	-DPLUGIN_DIR=\""$(PLUGIN_DIR)"\" \	14	-DPLUGIN_DIR=\""$(PLUGIN_DIR)"\" \
16	-DASPELL_DICT=\""$(ASPELL_DICT)"\" \
17	$(GNOME_SPELL_CFLAGS) \	15	$(GNOME_SPELL_CFLAGS) \
18	$(END)	16	$(END)
19		17
Lines 55-61 Link Here
55	libgnome_spell_component_la_LDFLAGS = -release $(API_VERSION) $(NO_UNDEFINED)	53	libgnome_spell_component_la_LDFLAGS = -release $(API_VERSION) $(NO_UNDEFINED)
56	libgnome_spell_component_la_LIBADD = \	54	libgnome_spell_component_la_LIBADD = \
57	libgnome-spell-idl.la \	55	libgnome-spell-idl.la \
58	$(ASPELL_LIBS) \
59	$(GNOME_SPELL_LIBS) \	56	$(GNOME_SPELL_LIBS) \
60	$(END)	57	$(END)
61		58
Lines 69-75 Link Here
69		66
70	test_gnome_spell_component_LDADD = \	67	test_gnome_spell_component_LDADD = \
71	libgnome-spell-idl.la \	68	libgnome-spell-idl.la \
72	$(ASPELL_LIBS) \
73	$(GNOME_SPELL_LIBS) \	69	$(GNOME_SPELL_LIBS) \
74	$(END)	70	$(END)
75		71

Lines 26-32 Link Here

(-)gnome-spell-1.0.7.orig/gnome-spell/dictionary.h (-8 lines)
26	G_BEGIN_DECLS	26	G_BEGIN_DECLS
27		27
28	#include <bonobo/bonobo-object.h>	28	#include <bonobo/bonobo-object.h>
29	#include <aspell.h>
30		29
31	#define GNOME_SPELL_DICTIONARY_TYPE (gnome_spell_dictionary_get_type ())	30	#define GNOME_SPELL_DICTIONARY_TYPE (gnome_spell_dictionary_get_type ())
32	#define GNOME_SPELL_DICTIONARY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), \	31	#define GNOME_SPELL_DICTIONARY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), \
Lines 37-48 Link Here
37	#define IS_GNOME_SPELL_DICTIONARY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNOME_SPELL_DICTIONARY_TYPE))	36	#define IS_GNOME_SPELL_DICTIONARY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNOME_SPELL_DICTIONARY_TYPE))
38		37
39	typedef struct {	38	typedef struct {
40	AspellConfig *config;
41	AspellSpeller *speller;
42	gboolean changed;
43	} SpellEngine;
44
45	typedef struct {
46	gchar *abbreviation;	39	gchar *abbreviation;
47	gchar *name;	40	gchar *name;
48	} LangInfo;	41	} LangInfo;
Lines 50-56 Link Here
50	typedef struct {	43	typedef struct {
51	BonoboObject parent;	44	BonoboObject parent;
52		45
53	gboolean changed;
54	GSList *engines;	46	GSList *engines;
55	GHashTable *languages;	47	GHashTable *languages;
56	GHashTable *engines_ht;	48	GHashTable *engines_ht;

Lines 7-18 Link Here

(-)gnome-spell-1.0.7.orig/gnome-spell.spec.in (-4 / +2 lines)
7	Source: ftp://ftp.gnome.org/pub/GNOME/unstable/sources/%{name}/%{name}-%{version}.tar.gz	7	Source: ftp://ftp.gnome.org/pub/GNOME/unstable/sources/%{name}/%{name}-%{version}.tar.gz
8	Summary: The spelling component for bonobo	8	Summary: The spelling component for bonobo
9	Group: System Environment/Libraries	9	Group: System Environment/Libraries
10	Requires: aspell >= 0.28	10	Requires: enchant >= 0.3.0
11	Requires: pspell >= 0.12
12	Requires: bonobo >= 0.28	11	Requires: bonobo >= 0.28
13	Requires: gal >= 0.7.99.5	12	Requires: gal >= 0.7.99.5
14	BuildRequires: aspell-devel >= 0.28	13	BuildRequires: enchant-devel >= 0.3.0
15	BuildRequires: pspell-devel >= 0.12
16	BuildRequires: bonobo-devel >= 0.28	14	BuildRequires: bonobo-devel >= 0.28
17	BuildRequires: libglade-devel	15	BuildRequires: libglade-devel
18	BuildRequires: gal-devel >= 0.7.99.5	16	BuildRequires: gal-devel >= 0.7.99.5