La césure

La cesure

La cesure : Plusieurs milliers de conseils pour vous faciliter la vie.

Un simple algorithme de cesure (syllabicates espagnol mots)
Cesure
nous avons Parfois besoin d'afficher ou d'imprimer un texte, et nous aimerions long de la cesure des mots qui ne correspondent pas a la fin d'une ligne, pour les empecher de tomber entierement dans la ligne suivante en laissant trop d'espace inutilise.
Le probleme principal qui se pose est de savoir comment diviser un mot en syllabes. Eh bien, je ne sais vraiment pas comment syllabicate en anglais, donc je laisse cette partie de vous, mais j'espere que vous trouverez l'exemple de l'espagne syllabication utile:
procedure Syllabify(les Syllabes: TStringList s: string)
& nbsp & nbsp const
& ! & ! & ! & nbsp Consonnes = ['b','B','c','C','d','D','f','F','g','G',
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! 'h','H','j','J','k','K','l','L','m','M','n','N',
&!&!&!&!&!&!&!&!&!&!&!&!' -',' -','p','P','q','Q','r','R','s','S','t','T',
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! 'v','V','w','W','x','X','y','Y','z','Z']
& ! & ! & ! & nbsp StrongVowels = ['a','A','a','A','e','E','e','E',
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! 'i','I','o','-','O','-','u','U']
& ! & ! & ! & nbsp WeakVowels = ['i','I','u','U','ü','Ü']
& ! & ! & ! & nbsp Voyelles = StrongVowels WeakVowels
& ! & ! & ! & nbsp Lettres = Voyelles Consonnes
& nbsp & nbsp var
& ! & ! & ! & nbsp i, j, n, m, trait d'union: integer
& nbsp & nbsp commencer
& ! & ! & ! & nbsp j := 2
& ! & ! & ! & nbsp s := #0 #0
& ! & ! & ! & nbsp n := Longueur(s) - 1
& ! & ! & ! & ! i := 2
& ! & ! & ! & nbsp Syllabes.Clair
& ! & ! & ! & nbsp while i <= n do begin
& ! & ! & ! & ! & ! & nbsp trait d'union := 0 // Ne pas cesure
& ! & ! & ! & ! & ! & nbsp si s[i] dans les Consonnes, puis commencer
& ! & ! & ! & ! & ! & ! & ! & nbsp si s[i 1] dans les Voyelles, puis commencer
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp si s[i-1] des Voyelles puis trait d'union := 1
& ! & ! & ! & ! & ! & ! & ! & nbsp fin else if (s[i 1] dans les Consonnes) et
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp (s[i-1] des Voyelles), puis commencer
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp si s[i 1] dans ['r','R'] ensuite, commencez
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp si s[i] dans ['b','B','c','C','d','D','f','F','g',
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! 'G','k','K','p','P','r','R','t','T','v','V']
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp puis trait d'union := 1 else trait d'union := 2
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp fin else if s[i 1] dans ['l','L'] ensuite, commencez
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp si s[i] dans ['b','B','c','C','d','D','f','F','g',
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! 'G','k','K','l','L','p','P','t','T','v','V']
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp puis trait d'union := 1 else trait d'union := 2
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp fin else if s[i 1] dans ['h', 'H'] ensuite, commencez
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp si s[i] dans ['c', 'C', 's', 'S', 'p', 'P']
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp puis trait d'union := 1 else trait d'union := 2
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp fin else
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp trait d'union := 2
& ! & ! & ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & nbsp fin else if s[i] dans StrongVowels puis commencer
& ! & ! & ! & ! & ! & ! & ! & nbsp if (s[i-1] dans StrongVowels) puis trait d'union := 1
& ! & ! & ! & ! & ! & nbsp fin else if s[i] = '-' alors commencer
& ! & ! & ! & ! & ! & ! & ! & nbsp Syllabes.Ajouter(Copie(s, j, i - j))
& ! & ! & ! & ! & ! & ! & ! & nbsp Syllabes.Add('-')
& ! & ! & ! & ! & ! & ! & ! & nbsp inc(i)
& ! & ! & ! & ! & ! & ! & ! & nbsp j := i
& ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & nbsp si le trait d'union = 1 then begin // Cesure ici
& ! & ! & ! & ! & ! & ! & ! & nbsp Syllabes.Ajouter(Copie(s, j, i - j))
& ! & ! & ! & ! & ! & ! & ! & nbsp j := i
& ! & ! & ! & ! & ! & nbsp fin sinon si le trait d'union = 2 then begin // Cesure apres
& ! & ! & ! & ! & ! & ! & ! & nbsp inc(i)
& ! & ! & ! & ! & ! & ! & ! & nbsp Syllabes.Ajouter(Copie(s, j, i - j))
& ! & ! & ! & ! & ! & ! & ! & nbsp j := i
& ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & nbsp inc(i)
& ! & ! & ! & nbsp fin
& ! & ! & ! & nbsp m := Syllabes.Count - 1
& ! & ! & ! & nbsp si (j = n) et (m >= 0) et (s[n] dans les Consonnes)
& ! & ! & ! & ! & ! & nbsp Syllabes[m] := Syllabes[m] s[n] // Derniere lettre
& ! & ! & ! & nbsp else
& ! & ! & ! & ! & ! & nbsp Syllabes.Ajouter(Copie(s, j, n - j 1)) // la Derniere syllabe
& nbsp & nbsp fin
Pour tester la procedure yon pouvez deposer une zone de texte et une Etiquette sur un formulaire, et dans l'evenement de Modification de la zone de texte a ecrire:
procedure TForm1.Edit1Change(Sender: TObject)
& nbsp & nbsp var
& ! & ! & ! & nbsp Syllabes: TStringList
& nbsp & nbsp commencer
& ! & ! & ! & nbsp Syllabes := TStringList.Creer
& ! & ! & ! & nbsp essayer
& ! & ! & ! & ! & ! & nbsp Syllabify(Syllabes, Edit1.Texte)
& ! & ! & ! & ! & ! & nbsp Label1.Legende := StringReplace(Trim(Les Syllabes.Texte),
& ! & ! & ! & ! & ! & ! & ! & nbsp #13#10, '-', [rfReplaceAll])
& ! & ! & ! & nbsp enfin
& ! & ! & ! & ! & ! & nbsp Syllabes.Gratuit
& ! & ! & ! & nbsp fin
& nbsp & nbsp fin
Maintenant que nous avons un syllabication procedure, nous devons noter que nous ne pouvons pas la cesure d'un mot dans n'importe quelle syllabe pause. Il est generalement correct
et/ou souhaitable pour rejoindre les petites syllabes a gauche et/ou droite d'un mot de garantir, par exemple, qu'il y a au moins deux syllabes de chaque cote de la parole quand il fait un trait d'union, ou bien, comme dans l'exemple suivant: faire en sorte que nous avons au moins quatre caracteres de chaque cote:
procedure ApplyRules(les Syllabes: TStringList)
& nbsp & nbsp // Garantie il y a au moins quatre lettres de la gauche
& nbsp & nbsp // et droite du mot
& nbsp & nbsp commencer
& ! & ! & ! & nbsp avec des Syllabes do begin
& ! & ! & ! & ! & ! & nbsp si Count = 1 then exit
& ! & ! & ! & ! & ! & nbsp tandis que Count > 1 do begin
& ! & ! & ! & ! & ! & ! & ! & nbsp si la Longueur(Cordes[0]) >= 4 then break
& ! & ! & ! & ! & ! & ! & ! & nbsp Cordes[0] := Cordes[0] Cordes[1]
& ! & ! & ! & ! & ! & ! & ! & nbsp Supprimer(1)
& ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & nbsp tandis que les Syllabes.Count > 1 do begin
& ! & ! & ! & ! & ! & ! & ! & nbsp si la Longueur(Cordes[Count-1]) >= 4 then break
& ! & ! & ! & ! & ! & ! & ! & nbsp Cordes[Comte-2] := Cordes[Comte-2]
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp Cordes[Count-1]
& ! & ! & ! & ! & ! & ! & ! & nbsp Supprimer(Count-1)
& ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & nbsp fin
& nbsp & nbsp fin
Enfin, vient le temps d'analyser le texte en separant les lignes d'un paragraphe de determiner quels mots doivent etre lies. L'exemple suivant n'est qu'avec un texte qui doit etre affiche dans un Memo:
procedure de la Cesure(Memo: TMemo OriginalText: TStrings)
& nbsp & nbsp var
& ! & ! & ! & nbsp paragraphe, i, j, k, m, n, MaxLineWidth: integer

& ! & ! & ! & nbsp s, ligne: string
& ! & ! & ! & nbsp Bitmap: TBitmap
& ! & ! & ! & nbsp Toile: TCanvas
& ! & ! & ! & nbsp Syllabes: TStringList
& nbsp & nbsp commencer
& ! & ! & ! & nbsp Syllabes := TStringList.Creer
& ! & ! & ! & nbsp essayer
& ! & ! & ! & nbsp // Nous avons besoin d'une toile a l'utilisation de son TextWidth methode pour obtenir la largeur
& ! & ! & ! & nbsp // du texte pour voir si elle s'inscrit dans l'espace client ou pas. L'
& ! & ! & ! & nbsp // TMemo classe n'a pas une Toile de propriete, de sorte que nous avons a
& ! & ! & ! & nbsp // creer l'un des notres.
& ! & ! & ! & ! & ! & nbsp Bitmap := TBitmap.Creer
& ! & ! & ! & ! & ! & nbsp Toile := Bitmap.Toile
& ! & ! & ! & ! & ! & nbsp essayer
& ! & ! & ! & ! & ! & ! & ! & nbsp Toile.Police := Memo.Police de caracteres
& ! & ! & ! & ! & ! & ! & ! & nbsp MaxLineWidth := Memo.ClientWidth - 6 // Maximum de la largeur
& ! & ! & ! & ! & ! & ! & ! & nbsp Memo.Les lignes.Clair
& ! & ! & ! & ! & ! & ! & ! & nbsp pour le paragraphe := 0 pour OriginalText.Count - 1 do begin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // Pour chaque paragraphe
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp s := OriginalText[paragraphe] // Obtenir le paragraphe original
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // Obtenir les lignes dans lesquelles nous devons briser le paragraphe
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp tout en Toile.TextWidth(s) > MaxLineWidth do begin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // tout d'Abord nous trouvons (en 'j') l'indice du debut de la
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // premier mot qui ne convient pas (la seule cesure)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp j := 1
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp n := Longueur(s)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp j' := 2
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp while i <= n do begin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp if (s[i-1] = ' ') et (s[i] <> ' ') puis
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp j := i // au debut d'un mot
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp si la Toile.TextWidth(Copie(s, 1, i)) > MaxLineWidth puis
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp pause // atteint une largeur qui ne repond pas a
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp inc(i)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // Ou est la rupture se produit?
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp si s[i] = '' then begin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // Grand! Nous pause sur un espace
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp Memo.Les lignes.Ajouter(Copie(s, 1, i - 1)) // Ajouter la ligne
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp s := Copy(s, i 1, n - i) // Suppression de la ligne
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp end else begin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // Nous casser quelque part dans un mot. Maintenant, nous trouvons ('k')
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // le premier espace apres le mot (k)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp k := j 1
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp while (k <= n) et (s[k] <> ' ') do inc(k)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // Diviser le mot en Syllabes
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp Syllabify(Syllabes, Copie de(s, j, k - j))
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp ApplyRules(Syllabes)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // Case (en 'm') combien de syllabes ajustement
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp m := 0
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp Ligne := Copy(s, 1, j-1)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp tout en Toile.TextWidth(Ligne Syllabes[m] '-')
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp <= MaxLineWidth do begin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp Ligne := Ligne de Syllabes[m]
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp inc(m)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp si (m <> 0) et (Syllabes[m-1] <> '-') ensuite, commencez
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp // Cesure
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp Ligne :Ligne = ' - '
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp j := Longueur(Ligne)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp si Syllabes[m] = '-' then inc(j)
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp Memo.Les lignes.Add(Ligne) // Ajouter la ligne
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp s := Copy(s, j, n - j 1) // Suppression de la ligne
& ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & ! & ! & ! & ! & nbsp Memo.Les lignes.Ajout(s) // Ajout de la derniere ligne (ajustement)
& ! & ! & ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & ! & ! & nbsp enfin
& ! & ! & ! & ! & ! & ! & ! & nbsp Bitmap.Gratuit
& ! & ! & ! & ! & ! & nbsp fin
& ! & ! & ! & nbsp enfin
& ! & ! & ! & ! & ! & nbsp Syllabes.Gratuit
& ! & ! & ! & nbsp fin
& nbsp & nbsp fin
Pour tester la procedure, deposer un Memo composant sur un formulaire, l'aligner par exemple vers le haut de la forme (Align = alTop) et d'ecrire le code suivant dans l'evenement de Redimensionnement de la forme:
procedure TForm1.FormResize(Sender: TObject)
& nbsp & nbsp var
& ! & ! & ! & nbsp OriginalText: TStringList
& nbsp & nbsp commencer
& ! & ! & ! & nbsp OriginalText := TStringList.Creer
& ! & ! & ! & nbsp essayer
& ! & ! & ! & ! & ! & nbsp OriginalText.Add('Si se ha preguntado como hacen los '
& ! & ! & ! & ! & ! & ! & ! & ! 'programas procesamiento de textos para dividir palabras '
& ! & ! & ! & ! & ! & ! & ! & ! 'con de guiones al final de una linea, il aqui des nations unies '
& ! & ! & ! & ! & ! & ! & ! & ! 'ejemplo sencillo (en comparacion con los que usan las '
& ! & ! & ! & ! & ! & ! & ! & ! 'aplicaciones de procesamiento de textos).')
& ! & ! & ! & ! & ! & nbsp OriginalText.Add('Este es un segundo parrafo que se fournit '
& ! & ! & ! & ! & ! & ! & ! & ! 'con fines de ejemplo.')
& ! & ! & ! & ! & ! & nbsp Cesure(Memo1, OriginalText)
& ! & ! & ! & nbsp enfin
& ! & ! & ! & ! & ! & nbsp OriginalText.Gratuit
& ! & ! & ! & nbsp fin
& nbsp & nbsp fin
Vous pouvez trouver le code source complet de cet article dans les archives qui accompagne le Pascal Newsletter #23