Aide pour contribuer, code à barre

Bonjour,

J'ai eu à faire un petit code pour me créer un code à barre code39.

J'aimerais le partager, mais j'aimerais avoir des commentaires et des suggestions avant de le partager officiellement dans la section dédiée à ces fins.

Donc, je vous mets le code ici. Vous les regardez, vous me dites ce qu'il manque/ce qu'il y a à changer.

Je prends en compte les commentaires puis j'envoie ma contribution dans la section "Contribuez".

Voici le Code (Désolé pour la longueur hors-norme) :

Code:

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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
#include <vector.h>
 
	//--------------------------------------------------------//
	//Le code 39 est expliquée en détails sur wikipédia : en.wikipedia.org/wiki/code_39
	//Selon ce site, un code a toujours 3 w (wide) et 6 n (narrow)
	//Toujours selon ce site, le ratio w/n peut être de 2/1 ou 3/1
	//C'est donc de dire que la largeur marximal est de w*3+n*6
	//Soit dans un ratio 2/1 : 2*3+1*6 = 12
	//Ou ratio 3/1 : 3*3 + 1*6 = 15
	//Dans ce cas-ci, un ratio de 2/1 sera utilisé dans la variable "ratio"
	//--------------------------------------------------------//
 
 
bool BarCode39Lettre(TRect RLettre, TCanvas *Canvas, AnsiString Lettre, int LargeurN, int ratio)
{
	/*
	Fonction secondaire servant à convertir une lettre en code 39 et écrit sur le Canvas à l'emplacement RLettre
	Les arguments sont les suivants :
	RLettre : Rectangle situé sur le canvas contenant une lettre en code 39
	Canvas : canvas sur lequel écrire le code bar
	Lettre : Lettre à écrire, si elle n'est pas parmis les lettres disponible du code 39, la fonction retourne false (ou 0)
	LargeurN : largeur d'une bande de type narrow (mince)
	Ratio : ratio entre les bandes larges(wide) et les bande minces (narrow) (typiquement 2:1, ou 3:1)
			pour un ratio de 2:1, le total de bande en unité est de 12
			pour un ratio de 3:1, le total unitaire est de 15
			Exemple 1 : Une lettre occupant 1.5cm de largeur avec un ratio de 3:1 aura une bande mince de 0.1cm de large et une large de 0.3cm
			Exemple 2 : Une lettre occupant 0.60cm de largeur et un ratio de 2:1 aura une bande unitaire (mince) de
	*/
 
	int Xmin; //Variable servant à déterminer le début de la barre
	int Xmax; //Variable servant à déterminer la fin de la barre
 
	unsigned int i = 0; //Varibale pour la boucle for
	unsigned int j = 0; //Varibale pour la boucle for
 
	bool found = false; //Booléen qui enregistre si le caractère a été trouvé ou non, sert pour le "return" de la fonction
 
	//********* Liste des Charactèrs valides pour le code 39  ***********//    (Mise à part le "*" qui sert de start and stop)
 
	vector<AnsiString> ListeChar; //Liste des caractères
	vector<string> ListeCharCode; //Liste des codes  "NarrowBlack/narrowWhite/WideBlack/WideWhite" pour les caractères
 
	//Liste des caractères        //Liste des codes correspondants
	ListeChar.clear();        	  ListeCharCode.clear();
 
	ListeChar.push_back("*");     ListeCharCode.push_back("NwNnWnWnN");
	ListeChar.push_back("-");     ListeCharCode.push_back("NwNnNnWnW");
	ListeChar.push_back("$");     ListeCharCode.push_back("NwNwNwNnN");
	ListeChar.push_back("%");     ListeCharCode.push_back("NnNwNwNwN");
	ListeChar.push_back(" ");     ListeCharCode.push_back("NwWnNnWnN");
	ListeChar.push_back(".");     ListeCharCode.push_back("WwNnNnWnN");
	ListeChar.push_back("/");     ListeCharCode.push_back("NwNwNnNwN");
	ListeChar.push_back("+");     ListeCharCode.push_back("NwNnNwNwN");
	ListeChar.push_back("0");     ListeCharCode.push_back("NnNwWnWnN");
	ListeChar.push_back("1");     ListeCharCode.push_back("WnNwNnNnW");
	ListeChar.push_back("2");     ListeCharCode.push_back("NnWwNnNnW");
	ListeChar.push_back("3");     ListeCharCode.push_back("WnWwNnNnN");
	ListeChar.push_back("4");     ListeCharCode.push_back("NnNwWnNnW");
	ListeChar.push_back("5");     ListeCharCode.push_back("WnNwWnNnN");
	ListeChar.push_back("6");     ListeCharCode.push_back("NnWwWnNnN");
	ListeChar.push_back("7");     ListeCharCode.push_back("NnNwNnWnW");
	ListeChar.push_back("8");     ListeCharCode.push_back("WnNwNnWnN");
	ListeChar.push_back("9");     ListeCharCode.push_back("NnWwNnWnN");
	ListeChar.push_back("A");     ListeCharCode.push_back("WnNnNwNnW");
	ListeChar.push_back("B");     ListeCharCode.push_back("NnWnNwNnW");
	ListeChar.push_back("C");     ListeCharCode.push_back("WnWnNwNnN");
	ListeChar.push_back("D");     ListeCharCode.push_back("NnNnWwNnW");
	ListeChar.push_back("E");     ListeCharCode.push_back("WnNnWwNnN");
	ListeChar.push_back("F");     ListeCharCode.push_back("NnWnWwNnN");
	ListeChar.push_back("G");     ListeCharCode.push_back("NnNnNwWnW");
	ListeChar.push_back("H");     ListeCharCode.push_back("WnNnNwWnN");
	ListeChar.push_back("I");     ListeCharCode.push_back("NnWnNwWnN");
	ListeChar.push_back("J");     ListeCharCode.push_back("NnNnWwWnN");
	ListeChar.push_back("K");     ListeCharCode.push_back("WnNnNnNwW");
	ListeChar.push_back("L");     ListeCharCode.push_back("NnWnNnNwW");
	ListeChar.push_back("M");     ListeCharCode.push_back("WnWnNnNwN");
	ListeChar.push_back("N");     ListeCharCode.push_back("NnNnWnNwW");
	ListeChar.push_back("O");     ListeCharCode.push_back("WnNnWnNwN");
	ListeChar.push_back("P");     ListeCharCode.push_back("NnWnWnNwN");
	ListeChar.push_back("Q");     ListeCharCode.push_back("NnNnNnWwW");
	ListeChar.push_back("R");     ListeCharCode.push_back("WnNnNnWwN");
	ListeChar.push_back("S");     ListeCharCode.push_back("NnWnNnWwN");
	ListeChar.push_back("T");     ListeCharCode.push_back("NnNnWnWwN");
	ListeChar.push_back("U");     ListeCharCode.push_back("WwNnNnNnW");
	ListeChar.push_back("V");     ListeCharCode.push_back("NwWnNnNnW");
	ListeChar.push_back("W");     ListeCharCode.push_back("WwWnNnNnN");
	ListeChar.push_back("X");     ListeCharCode.push_back("NwNnWnNnW");
	ListeChar.push_back("Y");     ListeCharCode.push_back("WwNnWnNnN");
	ListeChar.push_back("Z");     ListeCharCode.push_back("NwWnWnNnN");
 
	//***********************************************************************//
 
	Xmin = RLettre.left; //Initialisation du Xmin à gauche
 
	Canvas->Brush->Color = clBlack; //Pinceau en noir
 
	i = 0;
 
	//Tant que la lettre n'a pas été trouvé et que la fin de la liste de caractères n'est pas atteint
	while(found == false && i<ListeChar.size())
	{
		//Si le caractère est trouvé
		if(ListeChar[i].UpperCase() == Lettre.UpperCase())
		{
			//Pour les 9 codes (exemple : NwWnWnNnN pour la lettre Z)
			for(j=0;j<9;j++)
			{
				//Si c'est un narrow white
				if(AnsiString(ListeCharCode[i][j]) == "n")
				{
					//On laisse l'espace blanc, donc on se tasse de LargeurN
					Xmin += LargeurN;
				}
				//Si c'est un narrow Black
				if(AnsiString(ListeCharCode[i][j]) == "N")
				{
					//On dessine un carré noir(couleur du brush) de LargeurN (définit par un carré Xmin, Xmin + LargeurN)
					Canvas->FillRect(Rect(Xmin,RLettre.top,Xmin + LargeurN,RLettre.bottom));
					Xmin += LargeurN;
				}
				if(AnsiString(ListeCharCode[i][j]) == "w")
				{
					//On laisse l'espace blanc, donc on se tasse de LargeurN multiplié par ratio
					Xmin += LargeurN*ratio;
				}
				if(AnsiString(ListeCharCode[i][j]) == "W")
				{
					//On dessine un carré noir(couleur du brush) de LargeurN multiplié par le ratio (définit par un carré Xmin, Xmin + LargeurN*ratio)
					Canvas->FillRect(Rect(Xmin,RLettre.top,Xmin + LargeurN*ratio,RLettre.bottom));
					Xmin += LargeurN*ratio;
				}
			}
			//booléen changé pour vrai
			found = true;
		}
		//Si le caractère n'est pas le i ième, incrémenter
		else
		{
			i++;
        }
	}
	//Remise à blanc la couleur du pinceau (sinon le texte écrit sur le canvas aura un fond noir)
	Canvas->Brush->Color = clWhite;
 
	//Retourne si la lettre a été trouvée
	return found;
};
 
 
void BarCode39(TRect RectCodeBarre, TCanvas *Canvas, string Text)
{
	/*
	Fonction principale calculant la largeur requise pour chacun des caractère en fonction de la largeur du rectangle
	Ensuite elle écrit sur le canvas vis-à-vis le rectangle le text souhaité grâce à la fonction  "BarCode39Lettre"
	Les arguments sont les suivants :
	RectCodeBarre : Rectangle dans lequel on veut le code à barre
	Canvas : Canvas dans lequel on veut dessiner (écrire) le code à barre
	Text : le text à écrire
	*/
	int ratio = 2;	//Ratio W/N
 
	int LentghText = Text.length();  //Longueur du text, variable servant à calculer la largeur en pixel de chacun des barres
 
	int LargeurN;   //Narrow Black
	int Largeurn;   //narrow White
	int LargeurW;   //Wide Black
	int Largeurw;   //wide White
	int LargeurChar; //Largeur d'un caractère
 
	int Xmin;   //Variable servant à déterminer le début du caractère lors de l'écriture sur le Canvas
	int Xmax;   //Variable servant à déterminer la fin du caractère lors de l'écriture sur le Canvas
 
	unsigned int i = 0;  //Variable pour la boucle For
 
 
	//********* Répartition égale des caractères dans le rectangle ***************//
 
		LargeurChar = RectCodeBarre.Width()/(LentghText + 2); // + 2 pour les "start and stop" caractères "*"
 
		//--Narrow--//
		LargeurN = LargeurChar/(ratio*3+6); //Largeur d'une barre "narrow"
		Largeurn = LargeurN; //Largeur narrow white = narrow black
 
		//--Wide--//
		LargeurW = Largeurn*ratio; //Largeur wide black = narrow black * ratio
		Largeurw = LargeurW; //Largeur wide white = wide black
 
	//****************************************************************************//
 
	//*** Start character "*"  *****//
 
		Xmin = RectCodeBarre.left; //Initialisation des variables Xmin et Xmax
		Xmax = Xmin + LargeurChar; //Initialisation des variables Xmin et Xmax
 
		BarCode39Lettre(Rect(Xmin,RectCodeBarre.top,Xmax,RectCodeBarre.bottom),Canvas,"*", LargeurN, ratio);
 
	//*****************************//
 
 
	//*** Boucle for sur chacun des caractères du text à imprimer  ****//
 
		Xmin += LargeurChar;    //Incrément de la largeur de 1 caractère
		Xmax += LargeurChar;    //Incrément de la largeur de 1 caractère
 
		for (i = 0;i<LentghText;i++)
		{
			if(BarCode39Lettre(Rect(Xmin,RectCodeBarre.top,Xmax,RectCodeBarre.bottom),Canvas,Text[i], LargeurN, ratio) == true) //Si c'est un caractère imprimable en code 39
			{
				Xmin += LargeurChar;
				Xmax += LargeurChar;
			}
		}
 
	//***************************************************************//
 
	//***** Stop character "*"  *****//
		BarCode39Lettre(Rect(Xmin,RectCodeBarre.top,Xmax,RectCodeBarre.bottom),Canvas,"*", LargeurN, ratio);
	//*******************************//
 
};

Je le mets en fichier joint.

J'attends alors vos commentaires.

Salut, ton code m'a l'air très bien, mais étant donné que tu veux notre avis, je vais te donner la mienne :D.

Est-ce qu'il y a une raison pour laquelle tu n'a pas créé une classe. Sa aurait pu être intéressant d'hériter directement de TImage ou autre truc graphique. Si tu le fais ainsi tu pourrais faire ton propre composant (TBarCode39).

C'est le seul commentaire que j'ai ;)

Bonne continuation...

Class

Bonjour Crayon,

Merci d'avoir pris le temps de regarder/répondre.

J'aime bien ton idée, mais je ne suis pas certain de savoir comment l'appliquer.

Quand tu dit faire une classe, et hérité d'un TImage disons, qu'entend tu exactement?

Je cache mes fonction dans une clas TBarcode39 dans laquelle j'aurais des pointeur correspondant à mes argument?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class TBarCode39 { public : TRect RectCodeBarre; TCanvas *Canvas; string Text; void BarCode39(); TBareCode39; //Constructeur par défaut ~TBareCode39; // et pourquoi pas un destructeur, si le besoin est.. private : bool BarCode39Lettre(); };
Un truc du genre?

Et comment je décide que ça hérite d'un TImage disons?

Merci de ton idée, j'ai hate de l'appliquée (lorsque je l'aurais parfaitement comprise)

antoine

En général c'est un peu ce que je veut dire. Voici quelques resources pour t'aider:

Lien sur le forum:
http://www.developpez.net/forums/d41...mer-code-barre

Composant existant:
http://stilius.net/tbarcode
http://www.psoft.sk

Héritage

Très bien, merci!

J'adopte la classe.

Je me demandais ce que tu voulais dire par : "Sa aurait pu être intéressant d'hériter directement de TImage ou autre truc graphique. "

Je ne suis pas très famillier à la programmation fak, je suis un peu perdu là...

;\

merci,

antoine

Voici le code tiré de Barcode.h, on voit qu'il hérite de la classe TImage.
Code:

1 2 3 4 5 6 7 8 9 10 11 class PACKAGE TBarcode : public TImage { private: String FBarcodeID; void __fastcall SetBarcodeID(const String barcode); protected: public: __fastcall TBarcode(TComponent* Owner); __published: __property String BarcodeID = {read = FBarcodeID, write = SetBarcodeID}; };
Donc, TBarcode possède tous les attributs et méthodes (publiques et protégés) de TImage.