Merge to XFA: Use stdint.h types throughout PDFium.
[pdfium.git] / xfa / src / fxbarcode / BC_BarCode.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.\r
2 // Use of this source code is governed by a BSD-style license that can be\r
3 // found in the LICENSE file.\r
4 \r
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com\r
6 // Original code is licensed as follows:
7 /*\r
8  * Copyright 2011 ZXing authors\r
9  *\r
10  * Licensed under the Apache License, Version 2.0 (the "License");\r
11  * you may not use this file except in compliance with the License.\r
12  * You may obtain a copy of the License at\r
13  *\r
14  *      http://www.apache.org/licenses/LICENSE-2.0\r
15  *\r
16  * Unless required by applicable law or agreed to in writing, software\r
17  * distributed under the License is distributed on an "AS IS" BASIS,\r
18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
19  * See the License for the specific language governing permissions and\r
20  * limitations under the License.\r
21  */\r
22 \r
23 #include "barcode.h"\r
24 #include "BC_Reader.h"\r
25 #include "BC_Writer.h"\r
26 #include "BC_DecoderResult.h"\r
27 #include "BC_LuminanceSource.h"\r
28 #include "BC_BufferedImageLuminanceSource.h"\r
29 #include "BC_Binarizer.h"\r
30 #include "BC_BinaryBitmap.h"\r
31 #include "BC_UtilCodingConvert.h"\r
32 #include "BC_ResultPoint.h"\r
33 #include "BC_BinaryBitmap.h"\r
34 #include "BC_TwoDimWriter.h"\r
35 #include "common/BC_GlobalHistogramBinarizer.h"\r
36 #include "common/BC_CommonBitMatrix.h"\r
37 #include "common/BC_CommonBitArray.h"\r
38 #include "common/BC_CommonBitMatrix.h"\r
39 #include "common/BC_CommonDecoderResult.h"\r
40 #include "datamatrix/BC_DataMatrixReader.h"\r
41 #include "datamatrix/BC_DataMatrixWriter.h"\r
42 #include "oned/BC_OneDReader.h"\r
43 #include "oned/BC_OneDimReader.h"\r
44 #include "oned/BC_OneDimWriter.h"\r
45 #include "oned/BC_OnedCode39Reader.h"\r
46 #include "oned/BC_OnedCode39Writer.h"\r
47 #include "oned/BC_OnedCodaBarReader.h"\r
48 #include "oned/BC_OnedCodaBarWriter.h"\r
49 #include "oned/BC_OnedCode128Reader.h"\r
50 #include "oned/BC_OnedCode128Writer.h"\r
51 #include "oned/BC_OnedEAN8Reader.h"\r
52 #include "oned/BC_OnedEAN8Writer.h"\r
53 #include "oned/BC_OnedEAN13Reader.h"\r
54 #include "oned/BC_OnedEAN13Writer.h"\r
55 #include "oned/BC_OnedUPCAReader.h"\r
56 #include "oned/BC_OnedUPCAWriter.h"\r
57 #include "pdf417/BC_PDF417DetectorResult.h"\r
58 #include "pdf417/BC_PDF417Compaction.h"\r
59 #include "pdf417/BC_PDF417.h"\r
60 #include "pdf417/BC_PDF417Writer.h"\r
61 #include "pdf417/BC_PDF417Detector.h"\r
62 #include "pdf417/BC_PDF417DetectorResult.h"\r
63 #include "pdf417/BC_PDF417Codeword.h"\r
64 #include "pdf417/BC_PDF417Common.h"\r
65 #include "pdf417/BC_PDF417BarcodeValue.h"\r
66 #include "pdf417/BC_PDF417BarcodeMetadata.h"\r
67 #include "pdf417/BC_PDF417BoundingBox.h"\r
68 #include "pdf417/BC_PDF417DetectionResultColumn.h"\r
69 #include "pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h"\r
70 #include "pdf417/BC_PDF417DetectionResult.h"\r
71 #include "pdf417/BC_PDF417DecodedBitStreamParser.h"\r
72 #include "pdf417/BC_PDF417CodewordDecoder.h"\r
73 #include "pdf417/BC_PDF417DecodedBitStreamParser.h"\r
74 #include "pdf417/BC_PDF417ECModulusPoly.h"\r
75 #include "pdf417/BC_PDF417ECModulusGF.h"\r
76 #include "pdf417/BC_PDF417ECErrorCorrection.h"\r
77 #include "pdf417/BC_PDF417DecodedBitStreamParser.h"\r
78 #include "pdf417/BC_PDF417ScanningDecoder.h"\r
79 #include "pdf417/BC_PDF417Reader.h"\r
80 #include "pdf417/BC_PDF417HighLevelEncoder.h"\r
81 #include "qrcode/BC_QRCodeReader.h"\r
82 #include "qrcode/BC_QRCodeWriter.h"\r
83 CBC_CodeBase :: CBC_CodeBase()\r
84 {\r
85 }\r
86 CBC_CodeBase :: ~CBC_CodeBase()\r
87 {\r
88 }\r
89 FX_BOOL CBC_CodeBase::SetCharEncoding(int32_t encoding)\r
90 {\r
91     if (m_pBCWriter) {\r
92         return m_pBCWriter->SetCharEncoding(encoding);\r
93     }\r
94     return FALSE;\r
95 }\r
96 FX_BOOL CBC_CodeBase::SetModuleHeight(int32_t moduleHeight)\r
97 {\r
98     if (m_pBCWriter) {\r
99         return m_pBCWriter->SetModuleHeight(moduleHeight);\r
100     }\r
101     return FALSE;\r
102 }\r
103 FX_BOOL CBC_CodeBase::SetModuleWidth(int32_t moduleWidth)\r
104 {\r
105     if (m_pBCWriter) {\r
106         return m_pBCWriter->SetModuleWidth(moduleWidth);\r
107     }\r
108     return FALSE;\r
109 }\r
110 FX_BOOL CBC_CodeBase::SetHeight(int32_t height)\r
111 {\r
112     if (m_pBCWriter) {\r
113         return m_pBCWriter->SetHeight(height);\r
114     }\r
115     return FALSE;\r
116 }\r
117 FX_BOOL CBC_CodeBase::SetWidth(int32_t width)\r
118 {\r
119     if (m_pBCWriter) {\r
120         return m_pBCWriter->SetWidth(width);\r
121     }\r
122     return FALSE;\r
123 }\r
124 void CBC_CodeBase::SetBackgroundColor(FX_ARGB backgroundColor)\r
125 {\r
126     if (m_pBCWriter) {\r
127         m_pBCWriter->SetBackgroundColor(backgroundColor);\r
128     }\r
129 }\r
130 void CBC_CodeBase::SetBarcodeColor(FX_ARGB foregroundColor)\r
131 {\r
132     if (m_pBCWriter) {\r
133         m_pBCWriter->SetBarcodeColor(foregroundColor);\r
134     }\r
135 }\r
136 CBC_OneCode::CBC_OneCode()\r
137 {\r
138 };\r
139 CBC_OneCode::~CBC_OneCode()\r
140 {\r
141 }\r
142 FX_BOOL CBC_OneCode::CheckContentValidity(FX_WSTR contents)\r
143 {\r
144     if (m_pBCWriter) {\r
145         return ((CBC_OneDimWriter*)m_pBCWriter)->CheckContentValidity(contents);\r
146     }\r
147     return FALSE;\r
148 }\r
149 CFX_WideString CBC_OneCode::FilterContents(FX_WSTR contents)\r
150 {\r
151     CFX_WideString tmp;\r
152     if (m_pBCWriter == NULL) {\r
153         return tmp;\r
154     }\r
155     return ((CBC_OneDimWriter*)m_pBCWriter)->FilterContents(contents);\r
156 }\r
157 void CBC_OneCode::SetPrintChecksum(FX_BOOL checksum)\r
158 {\r
159     if (m_pBCWriter) {\r
160         ((CBC_OneDimWriter*)m_pBCWriter)->SetPrintChecksum(checksum);\r
161     }\r
162 }\r
163 void CBC_OneCode::SetDataLength(int32_t length)\r
164 {\r
165     if (m_pBCWriter) {\r
166         ((CBC_OneDimWriter*)m_pBCWriter)->SetDataLength(length);\r
167     }\r
168 }\r
169 void CBC_OneCode::SetCalChecksum(FX_BOOL calc)\r
170 {\r
171     if (m_pBCWriter) {\r
172         ((CBC_OneDimWriter*)m_pBCWriter)->SetCalcChecksum(calc);\r
173     }\r
174 }\r
175 FX_BOOL CBC_OneCode::SetFont(CFX_Font* cFont)\r
176 {\r
177     if (m_pBCWriter) {\r
178         return ((CBC_OneDimWriter*)m_pBCWriter)->SetFont(cFont);\r
179     }\r
180     return FALSE;\r
181 }\r
182 void CBC_OneCode::SetFontSize(FX_FLOAT size)\r
183 {\r
184     if (m_pBCWriter) {\r
185         ((CBC_OneDimWriter*)m_pBCWriter)->SetFontSize(size);\r
186     }\r
187 }\r
188 void CBC_OneCode::SetFontStyle(int32_t style)\r
189 {\r
190     if (m_pBCWriter) {\r
191         ((CBC_OneDimWriter*)m_pBCWriter)->SetFontStyle(style);\r
192     }\r
193 }\r
194 void CBC_OneCode::SetFontColor(FX_ARGB color)\r
195 {\r
196     if (m_pBCWriter) {\r
197         ((CBC_OneDimWriter*)m_pBCWriter)->SetFontColor(color);\r
198     }\r
199 }\r
200 CBC_Code39::CBC_Code39()\r
201 {\r
202     m_pBCReader = (CBC_Reader*) FX_NEW (CBC_OnedCode39Reader);\r
203     m_pBCWriter = (CBC_Writer*) FX_NEW (CBC_OnedCode39Writer);\r
204 }\r
205 CBC_Code39::CBC_Code39(FX_BOOL usingCheckDigit)\r
206 {\r
207     m_pBCReader = (CBC_Reader*) FX_NEW CBC_OnedCode39Reader(usingCheckDigit);\r
208     m_pBCWriter = (CBC_Writer*) FX_NEW CBC_OnedCode39Writer;\r
209 }\r
210 CBC_Code39::CBC_Code39(FX_BOOL usingCheckDigit, FX_BOOL extendedMode)\r
211 {\r
212     m_pBCReader = (CBC_Reader*) FX_NEW CBC_OnedCode39Reader(usingCheckDigit, extendedMode);\r
213     m_pBCWriter = (CBC_Writer*) FX_NEW CBC_OnedCode39Writer(extendedMode);\r
214 }\r
215 CBC_Code39::~CBC_Code39()\r
216 {\r
217     if(m_pBCReader) {\r
218         delete(m_pBCReader);\r
219         m_pBCReader = NULL;\r
220     }\r
221     if(m_pBCWriter) {\r
222         delete(m_pBCWriter);\r
223         m_pBCWriter = NULL;\r
224     }\r
225 }\r
226 FX_BOOL CBC_Code39::Encode(FX_WSTR contents, FX_BOOL isDevice, int32_t &e)\r
227 {\r
228     if(contents.IsEmpty()) {\r
229         e = BCExceptionNoContents;\r
230         return FALSE;\r
231     }\r
232     BCFORMAT format     = BCFORMAT_CODE_39;\r
233     int32_t outWidth = 0;\r
234     int32_t outHeight = 0;\r
235     CFX_WideString filtercontents = ((CBC_OnedCode39Writer*)m_pBCWriter)->FilterContents(contents);\r
236     CFX_WideString renderContents = ((CBC_OnedCode39Writer*)m_pBCWriter)->RenderTextContents(contents);\r
237     m_renderContents = renderContents;\r
238     CFX_ByteString byteString =  filtercontents.UTF8Encode();\r
239     uint8_t *data = m_pBCWriter->Encode(byteString, format, outWidth, outHeight, e);\r
240     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
241     ((CBC_OneDimWriter*)m_pBCWriter)->RenderResult(renderContents, data, outWidth, isDevice, e);\r
242     FX_Free(data);\r
243     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
244     return TRUE;\r
245 }\r
246 FX_BOOL CBC_Code39::RenderDevice(CFX_RenderDevice* device, const CFX_Matrix* matirx, int32_t &e)\r
247 {\r
248     CFX_WideString renderCon = ((CBC_OnedCode39Writer*)m_pBCWriter)->encodedContents(m_renderContents, e);\r
249     ((CBC_OneDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx, renderCon, e);\r
250     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
251     return TRUE;\r
252 }\r
253 FX_BOOL CBC_Code39::RenderBitmap(CFX_DIBitmap *&pOutBitmap, int32_t &e)\r
254 {\r
255     CFX_WideString renderCon = ((CBC_OnedCode39Writer*)m_pBCWriter)->encodedContents(m_renderContents, e);\r
256     ((CBC_OneDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, renderCon, e);\r
257     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
258     return TRUE;\r
259 }\r
260 CFX_WideString CBC_Code39::Decode(uint8_t* buf, int32_t width, int32_t hight, int32_t &e)\r
261 {\r
262     CFX_WideString str;\r
263     return str;\r
264 }\r
265 CFX_WideString CBC_Code39::Decode(CFX_DIBitmap *pBitmap, int32_t &e)\r
266 {\r
267     CBC_BufferedImageLuminanceSource source(pBitmap);\r
268     CBC_GlobalHistogramBinarizer binarizer(&source);\r
269     CBC_BinaryBitmap  bitmap(&binarizer);\r
270     CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);\r
271     BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));\r
272     return CFX_WideString::FromUTF8(str, str.GetLength());\r
273 }\r
274 FX_BOOL CBC_Code39::SetTextLocation(BC_TEXT_LOC location)\r
275 {\r
276     if (m_pBCWriter) {\r
277         return ((CBC_OnedCode39Writer*)m_pBCWriter)->SetTextLocation(location);\r
278     }\r
279     return FALSE;\r
280 }\r
281 FX_BOOL CBC_Code39::SetWideNarrowRatio(int32_t ratio)\r
282 {\r
283     if (m_pBCWriter) {\r
284         return ((CBC_OnedCode39Writer*)m_pBCWriter)->SetWideNarrowRatio(ratio);\r
285     }\r
286     return FALSE;\r
287 }\r
288 CBC_Codabar::CBC_Codabar()\r
289 {\r
290     m_pBCReader = (CBC_Reader*) FX_NEW (CBC_OnedCodaBarReader);\r
291     m_pBCWriter = (CBC_Writer*) FX_NEW (CBC_OnedCodaBarWriter);\r
292 }\r
293 CBC_Codabar::~CBC_Codabar()\r
294 {\r
295     if(m_pBCReader) {\r
296         delete(m_pBCReader);\r
297         m_pBCReader = NULL;\r
298     }\r
299     if(m_pBCWriter) {\r
300         delete(m_pBCWriter);\r
301         m_pBCWriter = NULL;\r
302     }\r
303 }\r
304 FX_BOOL CBC_Codabar::SetStartChar(FX_CHAR start)\r
305 {\r
306     if (m_pBCWriter) {\r
307         return ((CBC_OnedCodaBarWriter*)m_pBCWriter)->SetStartChar(start);\r
308     }\r
309     return FALSE;\r
310 }\r
311 FX_BOOL CBC_Codabar::SetEndChar(FX_CHAR end)\r
312 {\r
313     if (m_pBCWriter) {\r
314         return ((CBC_OnedCodaBarWriter*)m_pBCWriter)->SetEndChar(end);\r
315     }\r
316     return FALSE;\r
317 }\r
318 FX_BOOL CBC_Codabar::SetTextLocation(BC_TEXT_LOC location)\r
319 {\r
320     return ((CBC_OnedCodaBarWriter*) m_pBCWriter)->SetTextLocation(location);\r
321 }\r
322 FX_BOOL CBC_Codabar::SetWideNarrowRatio(int32_t ratio)\r
323 {\r
324     if (m_pBCWriter) {\r
325         return ((CBC_OnedCodaBarWriter*) m_pBCWriter)->SetWideNarrowRatio(ratio);\r
326     }\r
327     return FALSE;\r
328 }\r
329 FX_BOOL CBC_Codabar::Encode(FX_WSTR contents, FX_BOOL isDevice, int32_t &e)\r
330 {\r
331     if(contents.IsEmpty()) {\r
332         e = BCExceptionNoContents;\r
333         return FALSE;\r
334     }\r
335     BCFORMAT format     = BCFORMAT_CODABAR;\r
336     int32_t outWidth = 0;\r
337     int32_t outHeight = 0;\r
338     CFX_WideString filtercontents = ((CBC_OneDimWriter*)m_pBCWriter)->FilterContents(contents);\r
339     CFX_ByteString byteString = filtercontents.UTF8Encode();\r
340     m_renderContents = filtercontents;\r
341     uint8_t *data = m_pBCWriter->Encode(byteString, format, outWidth, outHeight, e);\r
342     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
343     ((CBC_OneDimWriter*)m_pBCWriter)->RenderResult(filtercontents, data, outWidth, isDevice, e);\r
344     FX_Free(data);\r
345     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
346     return TRUE;\r
347 }\r
348 FX_BOOL CBC_Codabar::RenderDevice(CFX_RenderDevice* device, const CFX_Matrix* matirx, int32_t &e)\r
349 {\r
350     CFX_WideString renderCon = ((CBC_OnedCodaBarWriter*)m_pBCWriter)->encodedContents(m_renderContents);\r
351     ((CBC_OneDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx, renderCon, e);\r
352     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
353     return TRUE;\r
354 }\r
355 FX_BOOL CBC_Codabar::RenderBitmap(CFX_DIBitmap *&pOutBitmap, int32_t &e)\r
356 {\r
357     CFX_WideString renderCon = ((CBC_OnedCodaBarWriter*)m_pBCWriter)->encodedContents(m_renderContents);\r
358     ((CBC_OneDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, renderCon, e);\r
359     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
360     return TRUE;\r
361 }\r
362 CFX_WideString CBC_Codabar::Decode(uint8_t* buf, int32_t width, int32_t hight, int32_t &e)\r
363 {\r
364     CFX_WideString str;\r
365     return str;\r
366 }\r
367 CFX_WideString CBC_Codabar::Decode(CFX_DIBitmap *pBitmap, int32_t &e)\r
368 {\r
369     CBC_BufferedImageLuminanceSource source(pBitmap);\r
370     CBC_GlobalHistogramBinarizer binarizer(&source);\r
371     CBC_BinaryBitmap  bitmap(&binarizer);\r
372     CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);\r
373     BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));\r
374     return CFX_WideString::FromUTF8(str, str.GetLength());\r
375 }\r
376 CBC_Code128::CBC_Code128(BC_TYPE type)\r
377 {\r
378     m_pBCReader = (CBC_Reader *) FX_NEW (CBC_OnedCode128Reader);\r
379     m_pBCWriter = (CBC_Writer *) FX_NEW CBC_OnedCode128Writer(type);\r
380 }\r
381 CBC_Code128::~CBC_Code128()\r
382 {\r
383     if(m_pBCReader) {\r
384         delete(m_pBCReader);\r
385         m_pBCReader = NULL;\r
386     }\r
387     if(m_pBCWriter) {\r
388         delete(m_pBCWriter);\r
389         m_pBCWriter = NULL;\r
390     }\r
391 }\r
392 FX_BOOL CBC_Code128::SetTextLocation(BC_TEXT_LOC location)\r
393 {\r
394     if (m_pBCWriter) {\r
395         return (( CBC_OnedCode128Writer*)m_pBCWriter)->SetTextLocation(location);\r
396     }\r
397     return FALSE;\r
398 }\r
399 FX_BOOL CBC_Code128::Encode(FX_WSTR contents, FX_BOOL isDevice, int32_t &e)\r
400 {\r
401     if(contents.IsEmpty()) {\r
402         e = BCExceptionNoContents;\r
403         return FALSE;\r
404     }\r
405     BCFORMAT format     = BCFORMAT_CODE_128;\r
406     int32_t outWidth = 0;\r
407     int32_t outHeight = 0;\r
408     CFX_WideString content = contents;\r
409     if (contents.GetLength() % 2 && ((CBC_OnedCode128Writer *)m_pBCWriter)->GetType() == BC_CODE128_C) {\r
410         content += '0';\r
411     }\r
412     CFX_WideString encodeContents = ((CBC_OnedCode128Writer*)m_pBCWriter)->FilterContents(content);\r
413     m_renderContents = encodeContents;\r
414     CFX_ByteString byteString = encodeContents.UTF8Encode();\r
415     uint8_t *data = m_pBCWriter->Encode(byteString, format, outWidth, outHeight, e);\r
416     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
417     ((CBC_OneDimWriter*)m_pBCWriter)->RenderResult(encodeContents, data, outWidth, isDevice, e);\r
418     FX_Free(data);\r
419     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
420     return TRUE;\r
421 }\r
422 FX_BOOL CBC_Code128::RenderDevice(CFX_RenderDevice* device, const CFX_Matrix* matirx, int32_t &e)\r
423 {\r
424     ((CBC_OneDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx, m_renderContents, e);\r
425     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
426     return TRUE;\r
427 }\r
428 FX_BOOL CBC_Code128::RenderBitmap(CFX_DIBitmap *&pOutBitmap, int32_t &e)\r
429 {\r
430     ((CBC_OneDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, m_renderContents, e);\r
431     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
432     return TRUE;\r
433 }\r
434 CFX_WideString CBC_Code128::Decode(uint8_t* buf, int32_t width, int32_t hight, int32_t &e)\r
435 {\r
436     CFX_WideString str;\r
437     return str;\r
438 }\r
439 CFX_WideString CBC_Code128::Decode(CFX_DIBitmap *pBitmap, int32_t &e)\r
440 {\r
441     CBC_BufferedImageLuminanceSource source(pBitmap);\r
442     CBC_GlobalHistogramBinarizer binarizer(&source);\r
443     CBC_BinaryBitmap  bitmap(&binarizer);\r
444     CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);\r
445     BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));\r
446     return CFX_WideString::FromUTF8(str, str.GetLength());\r
447 }\r
448 CBC_EAN8::CBC_EAN8()\r
449 {\r
450     m_pBCReader = (CBC_Reader*) FX_NEW (CBC_OnedEAN8Reader);\r
451     m_pBCWriter = (CBC_Writer*) FX_NEW (CBC_OnedEAN8Writer);\r
452 }\r
453 CBC_EAN8::~CBC_EAN8()\r
454 {\r
455     if(m_pBCReader) {\r
456         delete(m_pBCReader);\r
457         m_pBCReader = NULL;\r
458     }\r
459     if(m_pBCWriter) {\r
460         delete(m_pBCWriter);\r
461         m_pBCWriter = NULL;\r
462     }\r
463 }\r
464 CFX_WideString  CBC_EAN8::Preprocess(FX_WSTR contents)\r
465 {\r
466     CFX_WideString encodeContents = ((CBC_OnedEAN8Writer*)m_pBCWriter)->FilterContents(contents);\r
467     int32_t length = encodeContents.GetLength();\r
468     if (length <= 7) {\r
469         for (int32_t i = 0; i < 7 - length; i++) {\r
470             encodeContents = FX_WCHAR('0') + encodeContents;\r
471         }\r
472         CFX_ByteString byteString = encodeContents.UTF8Encode();\r
473         int32_t checksum = ((CBC_OnedEAN8Writer *)m_pBCWriter)->CalcChecksum(byteString);\r
474         encodeContents += FX_WCHAR(checksum - 0 + '0');\r
475     }\r
476     if (length > 8) {\r
477         encodeContents = encodeContents.Mid(0, 8);\r
478     }\r
479     return encodeContents;\r
480 }\r
481 FX_BOOL CBC_EAN8::Encode(FX_WSTR contents, FX_BOOL isDevice, int32_t &e)\r
482 {\r
483     if(contents.IsEmpty()) {\r
484         e = BCExceptionNoContents;\r
485         return FALSE;\r
486     }\r
487     BCFORMAT format     = BCFORMAT_EAN_8;\r
488     int32_t outWidth = 0;\r
489     int32_t outHeight = 0;\r
490     CFX_WideString encodeContents = Preprocess(contents);\r
491     CFX_ByteString byteString = encodeContents.UTF8Encode();\r
492     m_renderContents = encodeContents;\r
493     uint8_t *data = m_pBCWriter->Encode(byteString, format, outWidth, outHeight, e);\r
494     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
495     ((CBC_OneDimWriter*)m_pBCWriter)->RenderResult(encodeContents, data, outWidth, isDevice, e);\r
496     FX_Free(data);\r
497     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
498     return TRUE;\r
499 }\r
500 FX_BOOL CBC_EAN8::RenderDevice(CFX_RenderDevice* device, const CFX_Matrix* matirx, int32_t &e)\r
501 {\r
502     ((CBC_OneDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx, m_renderContents, e);\r
503     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
504     return TRUE;\r
505 }\r
506 FX_BOOL CBC_EAN8::RenderBitmap(CFX_DIBitmap *&pOutBitmap, int32_t &e)\r
507 {\r
508     ((CBC_OneDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, m_renderContents, e);\r
509     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
510     return TRUE;\r
511 }\r
512 CFX_WideString CBC_EAN8::Decode(uint8_t* buf, int32_t width, int32_t hight, int32_t &e)\r
513 {\r
514     CFX_WideString str;\r
515     return str;\r
516 }\r
517 CFX_WideString CBC_EAN8::Decode(CFX_DIBitmap *pBitmap, int32_t &e)\r
518 {\r
519     CBC_BufferedImageLuminanceSource source(pBitmap);\r
520     CBC_GlobalHistogramBinarizer binarizer(&source);\r
521     CBC_BinaryBitmap  bitmap(&binarizer);\r
522     CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);\r
523     BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));\r
524     return CFX_WideString::FromUTF8(str, str.GetLength());\r
525 }\r
526 CBC_EAN13::CBC_EAN13()\r
527 {\r
528     m_pBCReader = (CBC_Reader*) FX_NEW (CBC_OnedEAN13Reader);\r
529     m_pBCWriter = (CBC_Writer*) FX_NEW (CBC_OnedEAN13Writer);\r
530 }\r
531 CBC_EAN13::~CBC_EAN13()\r
532 {\r
533     if(m_pBCReader) {\r
534         delete(m_pBCReader);\r
535         m_pBCReader = NULL;\r
536     }\r
537     if(m_pBCWriter) {\r
538         delete(m_pBCWriter);\r
539         m_pBCWriter = NULL;\r
540     }\r
541 }\r
542 CFX_WideString CBC_EAN13::Preprocess(FX_WSTR contents)\r
543 {\r
544     CFX_WideString encodeContents = ((CBC_OnedEAN8Writer*)m_pBCWriter)->FilterContents(contents);\r
545     int32_t length = encodeContents.GetLength();\r
546     if (length <= 12) {\r
547         for (int32_t i = 0; i < 12 - length; i++) {\r
548             encodeContents = FX_WCHAR('0') + encodeContents;\r
549         }\r
550         CFX_ByteString byteString = encodeContents.UTF8Encode();\r
551         int32_t checksum = ((CBC_OnedEAN13Writer *)m_pBCWriter)->CalcChecksum(byteString);\r
552         byteString += checksum - 0 + '0';\r
553         encodeContents = byteString.UTF8Decode();\r
554     }\r
555     if (length > 13) {\r
556         encodeContents = encodeContents.Mid(0, 13);\r
557     }\r
558     return encodeContents;\r
559 }\r
560 FX_BOOL CBC_EAN13::Encode(FX_WSTR contents, FX_BOOL isDevice, int32_t &e)\r
561 {\r
562     if(contents.IsEmpty()) {\r
563         e = BCExceptionNoContents;\r
564         return FALSE;\r
565     }\r
566     BCFORMAT format     = BCFORMAT_EAN_13;\r
567     int32_t outWidth = 0;\r
568     int32_t outHeight = 0;\r
569     CFX_WideString encodeContents = Preprocess(contents);\r
570     CFX_ByteString byteString = encodeContents.UTF8Encode();\r
571     m_renderContents = encodeContents;\r
572     uint8_t *data = m_pBCWriter->Encode(byteString, format, outWidth, outHeight, e);\r
573     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
574     ((CBC_OneDimWriter*)m_pBCWriter)->RenderResult(encodeContents, data, outWidth, isDevice, e);\r
575     FX_Free(data);\r
576     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
577     return TRUE;\r
578 }\r
579 FX_BOOL CBC_EAN13::RenderDevice(CFX_RenderDevice* device, const CFX_Matrix* matirx, int32_t &e)\r
580 {\r
581     ((CBC_OneDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx, m_renderContents, e);\r
582     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
583     return TRUE;\r
584 }\r
585 FX_BOOL CBC_EAN13::RenderBitmap(CFX_DIBitmap *&pOutBitmap, int32_t &e)\r
586 {\r
587     ((CBC_OneDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, m_renderContents, e);\r
588     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
589     return TRUE;\r
590 }\r
591 CFX_WideString CBC_EAN13::Decode(uint8_t* buf, int32_t width, int32_t hight, int32_t &e)\r
592 {\r
593     CFX_WideString str;\r
594     return str;\r
595 }\r
596 CFX_WideString CBC_EAN13::Decode(CFX_DIBitmap *pBitmap, int32_t &e)\r
597 {\r
598     CBC_BufferedImageLuminanceSource source(pBitmap);\r
599     CBC_GlobalHistogramBinarizer binarizer(&source);\r
600     CBC_BinaryBitmap  bitmap(&binarizer);\r
601     CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);\r
602     BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));\r
603     return CFX_WideString::FromUTF8(str, str.GetLength());\r
604 }\r
605 CBC_UPCA::CBC_UPCA()\r
606 {\r
607     m_pBCReader = (CBC_Reader*) FX_NEW (CBC_OnedUPCAReader);\r
608     ((CBC_OnedUPCAReader *)m_pBCReader)->Init();\r
609     m_pBCWriter = (CBC_Writer*) FX_NEW (CBC_OnedUPCAWriter);\r
610 }\r
611 CBC_UPCA::~CBC_UPCA()\r
612 {\r
613     if(m_pBCReader) {\r
614         delete(m_pBCReader);\r
615         m_pBCReader = NULL;\r
616     }\r
617     if(m_pBCWriter) {\r
618         delete(m_pBCWriter);\r
619         m_pBCWriter = NULL;\r
620     }\r
621 }\r
622 CFX_WideString  CBC_UPCA::Preprocess(FX_WSTR contents)\r
623 {\r
624     CFX_WideString encodeContents = ((CBC_OnedEAN8Writer*)m_pBCWriter)->FilterContents(contents);\r
625     int32_t length = encodeContents.GetLength();\r
626     if (length <= 11) {\r
627         for (int32_t i = 0; i < 11 - length; i++) {\r
628             encodeContents = FX_WCHAR('0') + encodeContents;\r
629         }\r
630         CFX_ByteString byteString = encodeContents.UTF8Encode();\r
631         int32_t checksum = ((CBC_OnedUPCAWriter *)m_pBCWriter)->CalcChecksum(byteString);\r
632         byteString += checksum - 0 + '0';\r
633         encodeContents = byteString.UTF8Decode();\r
634     }\r
635     if (length > 12) {\r
636         encodeContents = encodeContents.Mid(0, 12);\r
637     }\r
638     return encodeContents;\r
639 }\r
640 FX_BOOL CBC_UPCA::Encode(FX_WSTR contents, FX_BOOL isDevice, int32_t &e)\r
641 {\r
642     if(contents.IsEmpty()) {\r
643         e = BCExceptionNoContents;\r
644         return FALSE;\r
645     }\r
646     BCFORMAT format     = BCFORMAT_UPC_A;\r
647     int32_t outWidth = 0;\r
648     int32_t outHeight = 0;\r
649     CFX_WideString encodeContents = Preprocess(contents);\r
650     CFX_ByteString byteString = encodeContents.UTF8Encode();\r
651     m_renderContents = encodeContents;\r
652     ((CBC_OnedUPCAWriter*)m_pBCWriter)->Init();\r
653     uint8_t *data = m_pBCWriter->Encode(byteString, format, outWidth, outHeight, e);\r
654     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
655     ((CBC_OneDimWriter*)m_pBCWriter)->RenderResult(encodeContents, data, outWidth, isDevice, e);\r
656     FX_Free(data);\r
657     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
658     return TRUE;\r
659 }\r
660 FX_BOOL CBC_UPCA::RenderDevice(CFX_RenderDevice* device, const CFX_Matrix* matirx, int32_t &e)\r
661 {\r
662     ((CBC_OneDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx, m_renderContents, e);\r
663     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
664     return TRUE;\r
665 }\r
666 FX_BOOL CBC_UPCA::RenderBitmap(CFX_DIBitmap *&pOutBitmap, int32_t &e)\r
667 {\r
668     ((CBC_OneDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, m_renderContents, e);\r
669     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
670     return TRUE;\r
671 }\r
672 CFX_WideString CBC_UPCA::Decode(uint8_t* buf, int32_t width, int32_t hight, int32_t &e)\r
673 {\r
674     CFX_WideString str;\r
675     return str;\r
676 }\r
677 CFX_WideString CBC_UPCA::Decode(CFX_DIBitmap *pBitmap, int32_t &e)\r
678 {\r
679     CBC_BufferedImageLuminanceSource source(pBitmap);\r
680     CBC_GlobalHistogramBinarizer binarizer(&source);\r
681     CBC_BinaryBitmap  bitmap(&binarizer);\r
682     CFX_ByteString str = m_pBCReader->Decode(&bitmap, 0, e);\r
683     BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));\r
684     return CFX_WideString::FromUTF8(str, str.GetLength());\r
685 }\r
686 CBC_QRCode::CBC_QRCode()\r
687 {\r
688     m_pBCReader = (CBC_Reader *) FX_NEW (CBC_QRCodeReader);\r
689     ((CBC_QRCodeReader*)m_pBCReader)->Init();\r
690     m_pBCWriter = (CBC_Writer *) FX_NEW (CBC_QRCodeWriter);\r
691 }\r
692 CBC_QRCode ::~CBC_QRCode()\r
693 {\r
694     if(m_pBCReader) {\r
695         delete(m_pBCReader);\r
696         m_pBCReader = NULL;\r
697     }\r
698     if(m_pBCWriter) {\r
699         delete(m_pBCWriter);\r
700         m_pBCWriter = NULL;\r
701     }\r
702 }\r
703 FX_BOOL CBC_QRCode::SetVersion(int32_t version)\r
704 {\r
705     if (version < 0 || version > 40) {\r
706         return FALSE;\r
707     }\r
708     if (m_pBCWriter == NULL) {\r
709         return FALSE;\r
710     }\r
711     return((CBC_QRCodeWriter*)m_pBCWriter)->SetVersion(version);\r
712 }\r
713 FX_BOOL CBC_QRCode::SetErrorCorrectionLevel (int32_t level)\r
714 {\r
715     if (level < 0 || level > 3) {\r
716         return FALSE;\r
717     }\r
718     if (m_pBCWriter == NULL) {\r
719         return FALSE;\r
720     }\r
721     return ((CBC_TwoDimWriter*)m_pBCWriter)->SetErrorCorrectionLevel(level);\r
722 }\r
723 FX_BOOL CBC_QRCode::Encode(FX_WSTR contents, FX_BOOL isDevice, int32_t &e)\r
724 {\r
725     int32_t outWidth = 0;\r
726     int32_t outHeight = 0;\r
727     uint8_t *data = ((CBC_QRCodeWriter*)m_pBCWriter)->Encode(contents, ((CBC_QRCodeWriter*)m_pBCWriter)->GetErrorCorrectionLevel(), outWidth, outHeight, e);\r
728     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
729     ((CBC_TwoDimWriter*)m_pBCWriter)->RenderResult(data, outWidth, outHeight, e);\r
730     FX_Free(data);\r
731     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
732     return TRUE;\r
733 }\r
734 FX_BOOL CBC_QRCode::RenderDevice(CFX_RenderDevice* device, const CFX_Matrix* matirx, int32_t &e)\r
735 {\r
736     ((CBC_TwoDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx);\r
737     return TRUE;\r
738 }\r
739 FX_BOOL CBC_QRCode::RenderBitmap(CFX_DIBitmap *&pOutBitmap, int32_t &e)\r
740 {\r
741     ((CBC_TwoDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, e);\r
742     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
743     return TRUE;\r
744 }\r
745 CFX_WideString CBC_QRCode::Decode(uint8_t* buf, int32_t width, int32_t hight, int32_t &e)\r
746 {\r
747     CFX_WideString str;\r
748     return str;\r
749 }\r
750 CFX_WideString CBC_QRCode::Decode(CFX_DIBitmap *pBitmap, int32_t &e)\r
751 {\r
752     CBC_BufferedImageLuminanceSource source(pBitmap);\r
753     CBC_GlobalHistogramBinarizer binarizer(&source);\r
754     CBC_BinaryBitmap  bitmap(&binarizer);\r
755     CFX_ByteString retStr = m_pBCReader->Decode(&bitmap, 0, e);\r
756     BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));\r
757     return CFX_WideString::FromUTF8(retStr, retStr.GetLength());\r
758 }\r
759 CBC_PDF417I::CBC_PDF417I()\r
760 {\r
761     m_pBCReader = (CBC_Reader*) FX_NEW (CBC_PDF417Reader);\r
762     m_pBCWriter = (CBC_Writer*) FX_NEW (CBC_PDF417Writer);\r
763 }\r
764 CBC_PDF417I::~CBC_PDF417I()\r
765 {\r
766     if(m_pBCReader) {\r
767         delete(m_pBCReader);\r
768         m_pBCReader = NULL;\r
769     }\r
770     if(m_pBCWriter) {\r
771         delete(m_pBCWriter);\r
772         m_pBCWriter = NULL;\r
773     }\r
774 }\r
775 FX_BOOL CBC_PDF417I::SetErrorCorrectionLevel (int32_t level)\r
776 {\r
777     ((CBC_PDF417Writer*)m_pBCWriter)->SetErrorCorrectionLevel(level);\r
778     return TRUE;\r
779 }\r
780 void CBC_PDF417I::SetTruncated(FX_BOOL truncated)\r
781 {\r
782     ((CBC_PDF417Writer*)m_pBCWriter)->SetTruncated(truncated);\r
783 }\r
784 FX_BOOL CBC_PDF417I::Encode(FX_WSTR contents, FX_BOOL isDevice, int32_t &e)\r
785 {\r
786     BCFORMAT format     = BCFORMAT_PDF_417;\r
787     int32_t outWidth = 0;\r
788     int32_t outHeight = 0;\r
789     uint8_t *data = ((CBC_PDF417Writer*)m_pBCWriter)->Encode(contents, outWidth, outHeight, e);\r
790     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
791     ((CBC_TwoDimWriter*)m_pBCWriter)->RenderResult(data, outWidth, outHeight, e);\r
792     FX_Free(data);\r
793     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
794     return TRUE;\r
795 }\r
796 FX_BOOL CBC_PDF417I::RenderDevice(CFX_RenderDevice* device, const CFX_Matrix* matirx, int32_t &e)\r
797 {\r
798     ((CBC_TwoDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx);\r
799     return TRUE;\r
800 }\r
801 FX_BOOL CBC_PDF417I::RenderBitmap(CFX_DIBitmap *&pOutBitmap, int32_t &e)\r
802 {\r
803     ((CBC_TwoDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, e);\r
804     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
805     return TRUE;\r
806 }\r
807 CFX_WideString CBC_PDF417I::Decode(uint8_t* buf, int32_t width, int32_t hight, int32_t &e)\r
808 {\r
809     CFX_WideString str;\r
810     return str;\r
811 }\r
812 CFX_WideString CBC_PDF417I::Decode(CFX_DIBitmap *pBitmap, int32_t &e)\r
813 {\r
814     CBC_BufferedImageLuminanceSource source(pBitmap);\r
815     CBC_GlobalHistogramBinarizer binarizer(&source);\r
816     CBC_BinaryBitmap  bitmap(&binarizer);\r
817     CFX_ByteString bytestring = m_pBCReader->Decode(&bitmap, 0, e);\r
818     BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));\r
819     return CFX_WideString::FromUTF8(bytestring, bytestring.GetLength());\r
820 }\r
821 CBC_DataMatrix::CBC_DataMatrix()\r
822 {\r
823     m_pBCReader = (CBC_Reader*) FX_NEW (CBC_DataMatrixReader);\r
824     ((CBC_DataMatrixReader*)m_pBCReader)->Init();\r
825     m_pBCWriter = (CBC_Writer*) FX_NEW (CBC_DataMatrixWriter);\r
826 }\r
827 CBC_DataMatrix::~CBC_DataMatrix()\r
828 {\r
829     if(m_pBCReader) {\r
830         delete(m_pBCReader);\r
831         m_pBCReader = NULL;\r
832     }\r
833     if(m_pBCWriter) {\r
834         delete(m_pBCWriter);\r
835         m_pBCWriter = NULL;\r
836     }\r
837 }\r
838 FX_BOOL CBC_DataMatrix::Encode(FX_WSTR contents, FX_BOOL isDevice, int32_t &e)\r
839 {\r
840     int32_t outWidth = 0;\r
841     int32_t outHeight = 0;\r
842     uint8_t *data = ((CBC_DataMatrixWriter *)m_pBCWriter)->Encode(contents, outWidth, outHeight, e);\r
843     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
844     ((CBC_TwoDimWriter*)m_pBCWriter)->RenderResult(data, outWidth, outHeight, e);\r
845     FX_Free(data);\r
846     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
847     return TRUE;\r
848 }\r
849 FX_BOOL CBC_DataMatrix::RenderDevice(CFX_RenderDevice* device, const CFX_Matrix* matirx, int32_t &e)\r
850 {\r
851     ((CBC_TwoDimWriter*)m_pBCWriter)->RenderDeviceResult(device, matirx);\r
852     return TRUE;\r
853 }\r
854 FX_BOOL CBC_DataMatrix::RenderBitmap(CFX_DIBitmap *&pOutBitmap, int32_t &e)\r
855 {\r
856     ((CBC_TwoDimWriter*)m_pBCWriter)->RenderBitmapResult(pOutBitmap, e);\r
857     BC_EXCEPTION_CHECK_ReturnValue(e, FALSE);\r
858     return TRUE;\r
859 }\r
860 CFX_WideString CBC_DataMatrix::Decode(uint8_t* buf, int32_t width, int32_t hight, int32_t &e)\r
861 {\r
862     CFX_WideString str;\r
863     return str;\r
864 }\r
865 CFX_WideString CBC_DataMatrix::Decode(CFX_DIBitmap *pBitmap, int32_t &e)\r
866 {\r
867     CBC_BufferedImageLuminanceSource source(pBitmap);\r
868     CBC_GlobalHistogramBinarizer binarizer(&source);\r
869     CBC_BinaryBitmap  bitmap(&binarizer);\r
870     CFX_ByteString retStr = m_pBCReader->Decode(&bitmap, 0, e);\r
871     BC_EXCEPTION_CHECK_ReturnValue(e, FX_WSTRC(L""));\r
872     return CFX_WideString::FromUTF8(retStr, retStr.GetLength());\r
873 }\r