Discussion :

[Michelk12]

Hello,

Puisse un jour cette fonction intéresser quelqu'un.
Je l'aisse ici une fonction qui prend en paramètre une chaîne et en retourne une autre prête à être utilisée avec la police code128.ttf
Merci à GrandZebu car me suis inspiré de l'une de ces fonctions VB.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
/// <summary>
    /// Retourne une chaîne à afficher en police code128.ttf pour obtenir le code à barres.
    /// </summary>
    /// <param name="chaine">chaîne à convertir</param>
    /// <returns>chaîne à afficher en police code128.ttf</returns>
    public string code128_pr_ttf(String chaine)
    {
        string Valeur_retour = "";
        Int32 code_Ascii;
        bool tableB;
        Int32 mini = 0;
        Int32 dummy = 0;
        Int32 checksum = 0;
        Int32 i;
 
        //Un caractère incorrect trouvé : retourne une chaine vide
        if (chaine.Length > 0)
        {
            for (i = 0; i < chaine.Length; i++)
            {
                code_Ascii = (Int32)chaine[i];
                if (code_Ascii < 32 || code_Ascii > 126)
                    return Valeur_retour;
            }
        }
        else
            return Valeur_retour;
 
        //Calculer la chaine de code en optimisant l'usage des tables B et C
        tableB = true;
        if (i >= 0)
        {
            i = 0;
            //i devient l'index sur la chaine
            while (i < chaine.Length)
            {
                if (tableB)
                {
                    //Voir si intéressant de passer en table C
                    //Oui pour 4 chiffres au début ou à la fin, sinon pour 6 chiffres
                    mini = (((i == 0) || ((i + 2) == chaine.Length)) ? 3 : 5);
                    mini--;
                    if ((i + mini) < chaine.Length)
                    {
                        while (mini >= 0)
                        {
                            if (Convert.ToInt32(chaine[i + mini]) < 48 || Convert.ToInt32(chaine[i + mini]) > 57)
                                break;
                            mini--;
                        }
                    }
                    //Choix table C
                    if (mini <= 0)
                    {
                        //Débuter sur table C
                        if (i == 0) {
                            Valeur_retour = Convert.ToString((char)210);
                        }
                        //Commuter sur table C
                        else {
                            Valeur_retour = Valeur_retour + (char)204;
                        }
                        tableB = false;
                    }
                    else
                    {
                        if (i == 0) Valeur_retour = Convert.ToString((char)209);
                        //Débuter sur table B
                    }
                }
                if (!tableB)
                {
                    //On est sur la table C, essayer de traiter 2 chiffres
                    mini = 2;
                    mini--;
                    if ((i + mini) < chaine.Length)
                    {
                        while (mini >= 0)
                        {
                            if (Convert.ToInt32(chaine[i + mini]) < 48 || Convert.ToInt32(chaine[i + mini]) > 57)
                                break;
                            mini--;
                        }
                    }
                    //OK pour 2 chiffres, les traiter
                    if (mini < 0) {
                        //Conversion.Val(Strings.Mid(chaine, i, 2));
                        dummy = Convert.ToInt32(chaine.Substring(i,2));
                        dummy = ((dummy < 95) ? dummy + 32 : dummy + 105);
                        Valeur_retour = Valeur_retour + (char)dummy;
                        i = i + 2;
 
                    }
                    //On n'a pas 2 chiffres, repasser en table B
                    else {
                        Valeur_retour = Valeur_retour + (char)205;
                        tableB = true;
                    }
                }
                if (tableB)
                {
                    //Traiter 1 caractère en table B
                    Valeur_retour = Valeur_retour + chaine[i].ToString();
                    i++;
                }
            }
 
            //Calcul de la clé de contrôle
            for (i = 0; i < Valeur_retour.Length; i++)
            {
                dummy = Convert.ToInt32(Valeur_retour[i]);
                dummy = (dummy < 127 ? dummy - 32 : dummy - 105);
                if (i == 0)
                    checksum = dummy;
                else
                    checksum += i * dummy;
            }
            checksum = checksum % 103;
 
            //Calcul du code ASCII de la clé
            checksum = (checksum < 95 ? checksum + 32 : checksum + 105);
 
            //Ajout de la clé et du STOP à la valeur de retour
            Valeur_retour = Valeur_retour + (char)checksum + (char)211;
        }
        return Valeur_retour;
    }

N'hésitez pas à la modifier si vous souhaitez l'améliorer.

Michel

[MoThA]

Apprenant le C#, j'étais occupé à transcrire en C# un programme que j'avais fait en VB6 utilisant justement cette génération de code128 à utiliser avec la font.

Ton travail va me faire économiser du temps.

Merci à toi.

Edit : je me suis permis de changer quelques petites choses.

1. Tu ne test pas le code ascii 203 dans la validation des caractères
2. j'ai modifié ta boucle for par une boucle foreach
3. Le test à la ligne 31 ne sert plus à rien vu qu'on est déjà sorti de la fonction via le return dans le cas ou on rencontre un caractère non valide ou que l'on a une chaine vide.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
public string code128_pr_ttf(String chaine)
        {
            string Valeur_retour = "";
            Int32 code_Ascii;
            bool tableB;
            Int32 mini = 0;
            Int32 dummy = 0;
            Int32 checksum = 0;
            Int32 i;
 
            //Un caractère incorrect trouvé : retourne une chaine vide
            if (chaine.Length > 0)
            {
                foreach (char c in chaine)
                {
                    code_Ascii = (Int32)c;
                    if ((code_Ascii < 32 || code_Ascii > 126) && (code_Ascii != 203))
                        return Valeur_retour;
                }
            }
            else
                return Valeur_retour;
 
            //Calculer la chaine de code en optimisant l'usage des tables B et C
            tableB = true;
            //        Plus besoin de tester i vu qu'on est déjà sorti de la fonction via le return
            //        if (i >= 0)
            //        {
            i = 0;
            //i devient l'index sur la chaine
            while (i < chaine.Length)
            {
                if (tableB)
                {
                    //Voir si intéressant de passer en table C
                    //Oui pour 4 chiffres au début ou à la fin, sinon pour 6 chiffres
                    mini = (((i == 0) || ((i + 2) == chaine.Length)) ? 3 : 5);
                    mini--;
                    if ((i + mini) < chaine.Length)
                    {
                        while (mini >= 0)
                        {
                            if (Convert.ToInt32(chaine[i + mini]) < 48 || Convert.ToInt32(chaine[i + mini]) > 57)
                                break;
                            mini--;
                        }
                    }
                    //Choix table C
                    if (mini <= 0)
                    {
                        //Débuter sur table C
                        if (i == 0)
                        {
                            Valeur_retour = Convert.ToString((char)210);
                        }
                        //Commuter sur table C
                        else
                        {
                            Valeur_retour = Valeur_retour + (char)204;
                        }
                        tableB = false;
                    }
                    else
                    {
                        if (i == 0) Valeur_retour = Convert.ToString((char)209);
                        //Débuter sur table B
                    }
                }
                if (!tableB)
                {
                    //On est sur la table C, essayer de traiter 2 chiffres
                    mini = 2;
                    mini--;
                    if ((i + mini) < chaine.Length)
                    {
                        while (mini >= 0)
                        {
                            if (Convert.ToInt32(chaine[i + mini]) < 48 || Convert.ToInt32(chaine[i + mini]) > 57)
                                break;
                            mini--;
                        }
                    }
                    //OK pour 2 chiffres, les traiter
                    if (mini < 0)
                    {
                        //Conversion.Val(Strings.Mid(chaine, i, 2));
                        dummy = Convert.ToInt32(chaine.Substring(i, 2));
                        dummy = ((dummy < 95) ? dummy + 32 : dummy + 105);
                        Valeur_retour = Valeur_retour + (char)dummy;
                        i = i + 2;
 
                    }
                    //On n'a pas 2 chiffres, repasser en table B
                    else
                    {
                        Valeur_retour = Valeur_retour + (char)205;
                        tableB = true;
                    }
                }
                if (tableB)
                {
                    //Traiter 1 caractère en table B
                    Valeur_retour = Valeur_retour + chaine[i].ToString();
                    i++;
                }
            }
 
            //Calcul de la clé de contrôle
            for (i = 0; i < Valeur_retour.Length; i++)
            {
                dummy = Convert.ToInt32(Valeur_retour[i]);
                dummy = (dummy < 127 ? dummy - 32 : dummy - 105);
                if (i == 0)
                    checksum = dummy;
                else
                    checksum += i * dummy;
            }
            checksum = checksum % 103;
 
            //Calcul du code ASCII de la clé
            checksum = (checksum < 95 ? checksum + 32 : checksum + 105);
 
            //Ajout de la clé et du STOP à la valeur de retour
            Valeur_retour = Valeur_retour + (char)checksum + (char)211;
            //        }
            return Valeur_retour;
        }