spelling/es: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Utilizar hunspell con Lazarus
2	2
3	3		En esta página vermos la forma de utilizar la librería hunspell con Lazarus. Veremos un esbozo, un modelo funcional pero incompleto. Es casi seguro que se necesitará hacer algunos cambios para propósitos específicos, pero con suerte esta página será un buen comienzo.
4	4
5	5		En primer lugar, en el foro hay varias referencias a algún código que funcionará con la biblioteca hunspell. La unidad hunspell.pas se basa en gran medida en estos bloques de código. La mayoría no tiene información de licencia y se supone que son "de conocimiento común" y, por lo tanto, libres de cualquier restricción. He agregado un bit que soluciona el problema de encontrar la biblioteca y los archivos del diccionario. Y estableció una interfaz razonable.
6	6
7	7		Además, el usuario rvk del foro ha creado una DLL de Windows de 64 bits, ya que parecía haber pocas alternativas para los usuarios de Windows
8	8
9	9		## Sobre Hunspell
10	10
11	11		Hunspell es un proyecto activo de código abierto, distribuido bajo la Licencia Pública de Mozilla. La biblioteca hunspell se utiliza en productos como Libra Office, Open Office y Firefox. Se puede hacer que funcione en Windows, Linux y Mac (y probablemente en muchas otras plataformas). Consulte las páginas específicas de la plataforma a continuación. Los diccionarios de Hunspell están fácilmente disponibles y es posible que ya estén instalados en muchas máquinas. Incluso si no puede acceder a la biblioteca de otra aplicación, puede usar su diccionario.
12	12
13	13		Los diccionarios de Hunspell vienen como un par de archivos .dic y .aff. Por ejemplo, el diccionario australiano consta de en_AU.dic y en_AU.aff. La 'en' indica que es inglés y la 'AU' dice que es específicamente para Australia. Como hablante de inglés, observo que los diccionarios en_US siempre parecen estar instalados y agrego los australianos. No sé qué tan extendido está este patrón en los sistemas que no hablan inglés. Puede encontrar diccionarios aquí <https://github.com/LibreOffice/dictionaries> y también información relacionada aquí <https://wiki.documentfoundation.org/Development/Dictionaries>
14	14
15	15		## Note about dictionaries
16	16
17	17		In some cases in order to display the suggested words correctly the dictionaries must be encoded in UTF-8. If you have notice that some words are not shown correctly--for example, apple in Polish is jabłko but you get jab�ko--it means that dictionary pl_PL.aff and pl_PL.dic must be converted in UTF-8. To convert dictionaries into UTF-8 in Linux Debian (it should work in any Linux, converted dictionaries can be used in Windows-check also [this forum thread](http://forum.lazarus.freepascal.org/index.php/topic,44298.0.html)) follow below steps:
18	18
19	19		1\. Start terminal as root
20	20
21		-	~~` su`~~
	21	+	```text
	22	+	su
	23	+	```
22	24
23	25		2\. If not yet installed, install hunspell (hunspell-pl is for Polish dictionary--more at [Debian Hunspell package](https://packages.debian.org/search?keywords=hunspell))
24	26
25		-	~~` apt-get install hunspell`\~~
26		-	~~` apt-get install hunspell-pl`~~
	27	+	```text
	28	+	apt-get install hunspell
	29	+	apt-get install hunspell-pl
	30	+	```
27	31
28	32		3\. Go to /usr/share/hunspell/ where dictionaries are kept and create folder dic
29	33
30		-	~~` cd /usr/share/hunspell/`\~~
31		-	~~` mkdir dic`~~
	34	+	```text
	35	+	cd /usr/share/hunspell/
	36	+	mkdir dic
	37	+	```
32	38
33	39		4\. Convert for example dictionary pl_PL.aff and pl_PL.dic Use [ISO-8859-2](https://en.wikipedia.org/wiki/ISO/IEC_8859-2) (for Eastern Europe), [ISO-8859-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) (or ISO-8859-15)for Western Europe, ISO-8859-5 for (Russian?), etc.
34	40
35		-	~~` iconv -f ISO-8859-2 -t UTF-8 /usr/share/hunspell/pl_PL.aff \| sed 's/^SET ISO8859-2$/SET UTF-8/g' > dic/pl_PL.aff`\~~
36		-	~~` iconv -f ISO-8859-2 -t UTF-8 /usr/share/hunspell/pl_PL.dic > dic/pl_PL.dic`~~
	41	+	```text
	42	+	iconv -f ISO-8859-2 -t UTF-8 /usr/share/hunspell/pl_PL.aff \| sed 's/^SET ISO8859-2$/SET UTF-8/g' > dic/pl_PL.aff
	43	+	iconv -f ISO-8859-2 -t UTF-8 /usr/share/hunspell/pl_PL.dic > dic/pl_PL.dic
	44	+	```
37	45
38	46		5\. Copy your dic folder or dictionaries from dic folder to your application
39	47
40	48		## Platform Specific
41	49
42	50		### Linux
43	51
44	52		Many Linux distributions will have Hunspell installed by default along with the appropriate language dictionaries. If not, its probably just a case of using the distribution's package manager. If all else fails, grab the source from the hunspell github site and build it yourself. Linux users are like that.
45	53
46	54		To see if you do in fact have a hunspell library installed, try this command.
47	55
48		-	~~` ldconfig -p \| grep hunspell`~~
	56	+	```text
	57	+	ldconfig -p \| grep hunspell
	58	+	```
49	59
50	60		Similarly, you can probably find some dictionaries with
51	61
52		-	~~` ls -l /usr/share/hunspell`~~
	62	+	```text
	63	+	ls -l /usr/share/hunspell
	64	+	```
53	65
54	66		If that does not work, try
55	67
56		-	~~` find /usr -name *.aff`~~
	68	+	```text
	69	+	find /usr -name *.aff
	70	+	```
57	71
58	72		it will take a bit longer ..
59	73
60	74		### Windows
61	75
62	76		Installing the hunspell library on windows is more of an issue. There is apparently no pre compiled 'kit' available and most Windows apps that use Hunspell appear to bind it staticly thus no hunspell.dll left lying around for you to use. But just to be sure, try searching for `hunspell.dll`. The Hunspell github site lists a recipe to build one but it involves installing MSYS2 and is quite involved. The resulting DLL also needs a couple of gcc DLLs along as well.
63	77
64	78		Fortunately user rvk on the Lazarus Forum has built us a nice statically (ie stand alone) linked DLL using Microsoft Visual Studio Community 2015. As such, you can use and distribute this DLL with your programme subject to the Mozilla Public License.
65	79
66	80		You will find this DLL bundled with its license file in <https://github.com/davidbannon/hunspell4pas>, click 'DLL', click the dll file, and you will get a 'Download' button. Don't forget to also get the license file, it should be distributed, one way or another with your app.
67	81
68	82		### Mac
69	83
70	84		The author's Mac appears to have had the Hunspell library installed when Sierra was installed. But maybe, just maybe, it came along with Firefox. I'd like some feed back .... \[already installed on Mojave and Catalina\]
71	85
72	86		> Note: See <https://opensource.apple.com/tarballs/hunspell/> for source download for v1.2.8.
73	87
74	88		To see if you aleady have a hunspell library installed, try this command
75	89
76		-	~~` find / 2>&1 \| grep "\hunspell"`~~
	90	+	```text
	91	+	find / 2>&1 \| grep "\hunspell"
	92	+	```
77	93
78	94		It will run for some time, depending on how many files on your system. It will likely find several files including some in your XCode directory. However, end users will probably not have XCode installed. The one particularly interesting file to me was
79	95
80		-	~~` /usr/lib/libhunspell-1.2.dylib`~~
	96	+	```text
	97	+	/usr/lib/libhunspell-1.2.dylib
	98	+	```
81	99
82	100		Version 1.2 is a bit older than elsewhere but it worked fine. If you don't find a usable library, I suggest you install one using a package manager like MacPorts, Fink or brew. Next issue issue is you will need some dictionaries. Similar command,
83	101
84		-	~~` find / 2>&1 \| grep "\.aff"`~~
	102	+	```text
	103	+	find / 2>&1 \| grep "\.aff"
	104	+	```
85	105
86	106		again, slow, it searches your whole disk. I found
87	107
88		-	~~` /Applications/Firefox.app/Contents/Resources/dictionaries/en-US.aff`~~
	108	+	```text
	109	+	/Applications/Firefox.app/Contents/Resources/dictionaries/en-US.aff
	110	+	```
89	111
90	112		And a quick 'ls' assured me that there was a matching 'en-US.dic' files so all good. A more experienced Mac user might like to suggest better search strategies. Please !
91	113
92	114		## The Hunspell Unit
93	115
94	116		When this page was initially created (2017 ?) I made a serious mistake and used some code that did not have a clear license or history. It has been suggested that by doing so, I breached the Hunspell license as has anyone who has used it since then.
95	117
96	118		To correct this situation, I have now released a new version of the Hunspell Wrapper that has a quite small part, just the function definitions, with the Hunspell (License: MPL 1.1/GPL 2.0/LGPL 2.1) and the Hunspell Unit (License: The Clear BSD License) in seperate files. From a coding point of view, its almost identical to what used to be here.
97	119
98	120		Please see <https://github.com/davidbannon/hunspell4pas>
99	121
100	122		I have removed the hunspell wrapper that used to live on this page. The one on Github above is a drop in replacement, you need hunspell.pas and hunspell.inc. The remainder of the file make a basic test/demo command line Lazarus project that replaces Demo 1.
101	123
102	124		### Demo 2 in a Full GUI
103	125
104	126		A Lazarus GUI demo makes a lot more sense and has been tested on Linux, Mac and Windows. But it is a bit harder to copy and paste.
105	127
106	128		For this demo, you'll need a form with two TMemos, Memo1 and MemoMsg. A button, ButtonSpell, a Tlistbox, Listbox1. Make the following event handlers : FormCreate for the main form; a double click for the listbox and click on the Button.
107	129
108	130		First you must create the hunspell object and see if it found a library its own way, here is an example in the FormCreate() method ....
109	131
110	132		``` pascal
111	133		uses hunspell; // get hunspell.pas and hunspell.inc from https://github.com/davidbannon/hunspell4pas
112	134		var
113	135		Form1: TForm1;
114	136		Sp: THunspell;
115	137		DictPath : AnsiString;
116	138
117	139		procedure TForm1.FormCreate(Sender: TObject);
118	140		begin
119	141		SetDefaultDicPath();
120	142		Sp := THunspell.Create(True);
121	143		if Sp.ErrorMessage = '' then begin
122	144		MemoMsg.append('Library Loaded =' + Sp.LibraryFullName);
123	145		ButtonSpell.enabled := CheckForDict();
124	146		end else
125	147		MemoMsg.append(SP.ErrorMessage);
126	148		end;
127	149		```
128	150
129	151		In this example, we are writing some status message to MemoMsg, its an easy way to see whats happening. The ButtonSpell is NOT enabled until the dictionaries have been set. Wait for it ....
130	152
131	153		We now need two methods, one reads a nominated directory looking for any likely dictionary files, the other manages the decisions. If we find just one dictionary set, use it, if we find none, complain. But if we find several, and thats most likely, we have to ask the user which dictionary (ie language) they wish to use.
132	154
133	155		``` pascal
134	156		function TForm1.FindDictionary(const Dict : TStrings; const DPath : AnsiString) : boolean;
135	157		var
136	158		Info : TSearchRec;
137	159		begin
138	160		Dict.Clear;
139	161		if FindFirst(AppendPathDelim(DPath) + '*.dic', faAnyFile and faDirectory, Info)=0 then begin
140	162		repeat
141	163		Dict.Add(Info.Name);
142	164		until FindNext(Info) <> 0;
143	165		end;
144	166		FindClose(Info);
145	167		Result := Dict.Count >= 1;
146	168		end;
147	169
148	170		function TForm1.CheckForDict() : boolean;
149	171		begin
150	172		Result := False;
151	173		EditDictPath.Caption := DictPathAlt;
152	174		if not FindDictionary(ListBox1.Items, DictPath) then
153	175		MemoMsg.Append('ERROR - no dictionaries found in ' + DictPath);
154	176		if ListBox1.Items.Count = 1 then begin // Exactly one returned.
155	177		if not Sp.SetDictionary( AppendPathDelim(DictPath) +
156	178		ListBox1.Items.Strings[0])
157	179		then
158	180		MemoMsg.Append('ERROR ' + SP.ErrorMessage)
159	181		else
160	182		MemoMsg.Append('Dictionary set to ' + DictPath +
161	183		ListBox1.Items.Strings[0]);
162	184		end;
163	185		Result := SP.GoodToGo; // only true if count was exactly one or FindDict failed and nothing changed
164	186		end;
165	187		```
166	188
167	189		Ah, you say, but where are we looking for the dictionaries ? Sadly, I don't have a good solution for that. Here is where I found mine -
168	190
169	191		``` pascal
170	192		procedure TForm1.SetDefaultDicPath();
171	193		begin
172	194		{$ifdef LINUX}
173	195		DictPath := '/usr/share/hunspell/';
174	196		{$ENDIF}
175	197		{$ifdef WINDOWS}
176	198		DictPath := ExtractFilePath(Application.ExeName);
177	199		//DictPath := 'C:\Program Files\LibreOffice 5\share\extensions\dict-en\';
178	200		{$ENDIF}
179	201		{$ifdef DARWIN}
180	202		DictPath := '/Applications/Firefox.app/Contents/Resources/dictionaries/';
181	203		//DictPathAlt := ExtractFilePath(Application.ExeName);
182	204		{$endif}
183	205		end;
184	206		```
185	207
186	208		Maybe, if other users contribute where they found usable hunspell dictionaries, we can build a list for each platform. Or just take the easy way out and tell user to get some dictionaries and put them into the application directory on Windows and Mac. Your thoughts very welcome....
187	209
188	210		So far, if there is exactly one dictionary set in the indicated directory, all good. But what if there are several ? Our list box has a list of them, if the user double clicks one, they trigger this method -
189	211
190	212		``` pascal
191	213		procedure TForm1.ListBox1DblClick(Sender: TObject);
192	214		begin
193	215		if ListBox1.ItemIndex > -1 then
194	216		ButtonSpell.enabled := Sp.SetDictionary( AppendPathDelim(DictPath) +
195	217		ListBox1.Items.Strings[ListBox1.ItemIndex]);
196	218		if SP.ErrorMessage = '' then begin
197	219		MemoMsg.Append('Good To Go =' + booltostr(Sp.GoodToGo, True));
198	220		MemoMsg.Append('Dictionary set to ' + AppendPathDelim(DictPath) +
199	221		ListBox1.Items.Strings[ListBox1.ItemIndex]);
200	222		end else
201	223		MemoMsg.append('ERROR ' + SP.ErrorMessage);
202	224		end;
203	225		```
204	226
205	227		Assuming we now have everything "good to go" we can press the Spell button and trigger this -
206	228
207	229		``` pascal
208	230		procedure TForm1.ButtonSpellClick(Sender: TObject);
209	231		begin
210	232		if not Sp.Spell(Edit1.text) then begin
211	233		Memo1.Lines.BeginUpdate;
212	234		Sp.Suggest('badspeller', Memo1.lines);
213	235		Memo1.Lines.EndUpdate;
214	236		end else
215	237		Memo1.Lines.Clear;
216	238		end;
217	239		```
218	240
219	241		Memo1 now contains some suggestions for better ways to spell badspeller !
220	242
221	243		Important ! Don't forget to free up our hunspeller object, memory leaks are evil !
222	244
223	245		``` pascal
224	246		procedure TForm1.FormDestroy(Sender: TObject);
225	247		begin
226	248		Sp.free;
227	249		Sp := nil;
228	250		end;
229	251		```
230	252
231	253		This module will do considerably more but its presented here in its most stripped down form for readability.
232	254
233	255		A note to people new to Lazarus, methods with "(Sender: TObject)" shown above cannot just be pasted into your source, use the Form's Object Inspector to create the events first, then paste my sample code into the method.
234	256
235	257		### Demo 3 - Lazspell - Tmemo
236	258
237	259		In this example TMemo component was used.
238	260
239	261		![](/wiki-images/b/b3/Lazspell.gif)
240	262
241	263		Lazspell - an example of spelling checker - from <https://github.com/Raf20076/Lazspell>
242	264
243	265		### Demo 4 - Lazspell 2-version 2 - TRichMemo
244	266
245	267		In this example TRichMemo component was used.
246	268
247	269		![](/wiki-images/8/8c/Lazspell-ver2.gif)
248	270
249	271		Lazspell 2 version 2 - an example of spelling checker - from <https://github.com/Raf20076/Lazspell-2-version-2>
250	272
251	273		### Demo 5 - Simple spelling checker
252	274
253	275		1\. Start Lazarus Ide
254	276
255	277		2\. Click Project -\> New Project -\> Choose -\> Application
256	278
257		-	~~` You have just created a new application. Now save it `~~
	279	+	```text
	280	+	You have just created a new application. Now save it
	281	+	```
258	282
259	283		3\. Click File -\> Save as
260	284
261		-	~~` Choose a folder where your application will be saved`\~~
262		-	~~` First, project1.lpi will be saved, then unit1.pas`~~
	285	+	```text
	286	+	Choose a folder where your application will be saved
	287	+	First, project1.lpi will be saved, then unit1.pas
	288	+	```
263	289
264	290		4\. Place hunspell.pas and hunspell.inc (from <https://github.com/davidbannon/hunspell4pas>) in your folder.
265	291
266	292		5\. Place libhunspell.dll in your application folder (you can download it from here <https://github.com/Raf20076/Lazspell> or <https://github.com/davidbannon/hunspell4pas>) any options or compile by yourself.
267	293
268	294		6\. Place dictionary in your application folder, (two files) like pl_PL.aff, pl_PL.dic. Ditionaries must be encoded in UTF8. You can download them from here <https://github.com/Raf20076/Lazspell/tree/master/dict>
269	295
270	296		7\. On Form1 place component TButton (Button1) from Standard Tab
271	297
272	298		8\. On Form1 place component TMemo (Memo1) from Standard Tab
273	299
274	300		9\. On Form1 place component TListbox (ListBox1) from Standard Tab (here misspell words will be shown)
275	301
276	302		10\. Click once Button1 on Form1 then go to ObjectInspector, click Events tab, and double click next to OnClik event: it creates OnClick event and paste code (see the code of the whole application) starts from
277	303
278	304		``` pascal
279	305
280	306		{Check spelling}
281	307		var
282	308		i : Integer;
283	309		MAX : Integer;
284	310		FillInArrayWithWords:TStringArray;
285	311		FillInString1: String;
286	312		FillInString2: String;
287	313		```
288	314
289	315		till
290	316
291	317		``` pascal
292	318
293	319		//If word is not in dictionary show it in Listbox as an error
294	320		```
295	321
296	322		11\. Go to ObjectInspector and click Form1, then click Events tab then double click next to OnCreate it creates OnCreate event and paste code (see the code of the whole application)
297	323
298	324		``` pascal
299	325		SpellCheck := THunspell.Create(True);
300	326		SpellCheck.SetDictionary('pl_PL.dic');//Load dictionary
301	327		SpellCheck.GoodToGo := True;
302	328		```
303	329
304	330		12\. Still in ObjectInspector click Form1,then click Events tab then double click next to OnDestroy it creates OnDestroy event and paste code (see the code of the whole application)
305	331
306		-	~~` SpellCheck.free;`\~~
307		-	~~` SpellCheck := nil;`~~
	332	+	``` pascal
	333	+	SpellCheck.free;
	334	+	SpellCheck := nil;
	335	+	```
308	336
309	337		13\. Then in your code place functions like ArrayValueCount etc
310	338
311	339		See Below the code of the whole application to compare with your one.
312	340
313	341		``` pascal
314	342		//SpellChecker by Raf20076, Poland 2019
315	343
316	344		unit Unit1;
317	345
318	346		{$mode objfpc}{$H+}
319	347
320	348		interface
321	349
322	350		uses
323	351		Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls,
324	352		LazFileUtils, LCLProc, LazUtils, LazUtf8;
325	353
326	354		type
327	355		TForm1 = class(TForm)
328	356		Button1: TButton;
329	357		Label1: TLabel;
330	358		Label2: TLabel;
331	359		ListBox1: TListBox;
332	360		ListBox2: TListBox;
333	361		Memo1: TMemo;
334	362		procedure Button1Click(Sender: TObject);
335	363		procedure FormCreate(Sender: TObject);
336	364		procedure FormDestroy(Sender: TObject);
337	365		end;
338	366
339	367		var
340	368		Form1: TForm1;
341	369
342	370		implementation
343	371
344	372		uses hunspell;//place hunspell.pas and hunspell .inc in your application folder
345	373		//from https://github.com/davidbannon/hunspell4pas
346	374
347	375		var
348	376		SpellCheck: THunspell;
349	377
350	378		{$R *.lfm}
351	379
352	380		procedure TForm1.FormCreate(Sender: TObject);
353	381		begin
354	382		SpellCheck := THunspell.Create(True);
355	383		SpellCheck.SetDictionary('pl_PL.dic');//Load dictionary
356	384		SpellCheck.GoodToGo := True;
357	385		end;
358	386
359	387		{Extract words from string: non characters, spaces, carriagereturn aware}
360	388
361	389		function ArrayValueCount(const InputArray: Array of string): Integer;
362	390		{Count elements in array}
363	391		var
364	392		i:Integer;
365	393		begin
366	394		result := 0;
367	395		for i := low(InputArray) to high(InputArray) do
368	396		if InputArray[i] <> ' ' then // 'between them one space'
369	397		inc(result);
370	398		end;
371	399
372	400		function StripOffNonCharacter(const aString: string): string;
373	401		{Remove non characters from string}
374	402		var
375	403		a: Char;
376	404		begin
377	405		Result := '';
378	406		for a in aString do begin //below punctuation marks, numbers to remove from string
379	407		if not CharInSet( a, ['.', ',', ';', ':', '!', '/',
380	408		'?', '@', '#', '$', '%', '&', '*', '(', ')', '{',
381	409		'}', '[', ']', '-', '\', '\|', '<', '>', '''', '"', '^',
382	410		'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '_', '+',
383	411		'=', '~']) then //'„', '”'])these marks make error: Ordinal expression expected, need to be fixed
384	412		begin
385	413		Result := Result + a;
386	414		end;
387	415		end;
388	416		end;
389	417
390	418		function ReplaceCarriageReturn(s: string) : string;
391	419		{Replace carriagereturn with one space}
392	420		var
393	421		i: Integer;
394	422		begin
395	423		Result:=s;
396	424		for i := 1 to Length(Result) do
397	425		if Result[i] in [#3..#13] then
398	426		Result[i] := ' ';//'Between them one space'
399	427		end;
400	428
401	429		procedure TForm1.Button1Click(Sender: TObject);
402	430		{Check spelling}
403	431		var
404	432		i : Integer;
405	433		MAX : Integer;
406	434		FillInArrayWithWords:TStringArray;
407	435		FillInString1: String;
408	436		FillInString2: String;
409	437		begin
410	438		ListBox1.clear;
411	439		ListBox1.Items.Clear;
412	440
413	441		FillInString1 := ReplaceCarriageReturn(Memo1.Lines.Text);//take text from Memo1; replace carriage return
414	442		//with one space (using ReplaceCarriageReturn function) and put into FillInString1
415	443
416	444		FillInString2 := StripOffNonCharacter(FillInString1);//remove all non characters from FillInString1
417	445		//(using StripOffNonCharacter function) and put string without non charachters into FillInString2
418	446
419	447		FillInArrayWithWords := FillInString2.split(' '); //Split string into words with ' ' one space
420	448		//(using .split) and put separate words into array FillInArrayWithWords
421	449
422	450		MAX := ArrayValueCount(FillInArrayWithWords); //Give how many elements are in array
423	451		//(using function ArrayValueCount)
424	452
425	453		for i := 0 to MAX -1 do
426	454		if not SpellCheck.Spell(FillInArrayWithWords[i]) then
427	455		ListBox1.Items.add(FillInArrayWithWords[i]);
428	456		//Take word from array and check in dictionary through hunspell (using SpellCheck.Spell function)
429	457		//If word is not in dictionary show it in Listbox as an error
430	458		end;
431	459
432	460		procedure TForm1.FormDestroy(Sender: TObject);
433	461		begin
434	462		SpellCheck.free;
435	463		SpellCheck := nil;
436	464		end;
437	465
438	466		end.
439	467		```
440	468
441	469		When you run your application and type some text in Memo and then press the button, the application will check if any errors are found, if found then shows them in ListBox. The main problem was how to remove carriage return and non characters and then how to split text into separate words. It's not an easy task. Therefore there are three functions to do this:ReplaceCarriageReturn function, StripOffNonCharacter function and FillInString2.split , function. The FillInString2.split function actually uses .split function from SysUtils. Hopefully the code of the whole application is self explanatory.
442	470
443	471		## Further Reading and Links
444	472
445	473		- <https://github.com/hunspell/hunspell>
446	474		- <https://github.com/davidbannon/hunspell4pas> - the (correctly licensed) hunspell object pascal unit.
447	475		- <https://github.com/Homebrew> - probably sensible way to get hunspell on your Mac if it's not already there.
448	476		- <https://github.com/tomboy-notes/tomboy-ng/releases> - Contains The 64bit Windows DLL in a tomboy-ng_win64_\<ver\>.zip
449	477		- <https://github.com/cutec-chris/hunspell>
450	478		- <https://forum.lazarus.freepascal.org/index.php/topic,50474.0.html> - FastHighliter code to use for highlighting misspelt words
451	479		- <https://github.com/Raf20076> - Lazspell is an example of simple spelling checker application written in Lazarus IDE.
452	480		- <https://forum.lazarus.freepascal.org/index.php/topic,46233.0.html>
453	481		- <https://forum.lazarus.freepascal.org/index.php/topic,51569.0.html>
454	482		- <https://forum.lazarus.freepascal.org/index.php?topic=44298.0>
455	483
456	484		---
457	485		From the Free Pascal wiki, page "spelling/es", as it stood on 2022-03-07 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history