• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 // Original code is licensed as follows:
7 /*
8  * Copyright 2011 ZXing authors
9  *
10  * Licensed under the Apache License, Version 2.0 (the "License");
11  * you may not use this file except in compliance with the License.
12  * You may obtain a copy of the License at
13  *
14  *      http://www.apache.org/licenses/LICENSE-2.0
15  *
16  * Unless required by applicable law or agreed to in writing, software
17  * distributed under the License is distributed on an "AS IS" BASIS,
18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19  * See the License for the specific language governing permissions and
20  * limitations under the License.
21  */
22 
23 #include "fxbarcode/oned/BC_OneDimWriter.h"
24 
25 #include <algorithm>
26 #include <memory>
27 #include <vector>
28 
29 #include "core/fxge/cfx_defaultrenderdevice.h"
30 #include "core/fxge/cfx_font.h"
31 #include "core/fxge/cfx_graphstatedata.h"
32 #include "core/fxge/cfx_pathdata.h"
33 #include "core/fxge/cfx_renderdevice.h"
34 #include "core/fxge/cfx_unicodeencodingex.h"
35 #include "fxbarcode/BC_Writer.h"
36 #include "third_party/base/ptr_util.h"
37 
CBC_OneDimWriter()38 CBC_OneDimWriter::CBC_OneDimWriter() {
39   m_locTextLoc = BC_TEXT_LOC_BELOWEMBED;
40   m_bPrintChecksum = true;
41   m_iDataLenth = 0;
42   m_bCalcChecksum = false;
43   m_pFont = nullptr;
44   m_fFontSize = 10;
45   m_iFontStyle = 0;
46   m_fontColor = 0xff000000;
47   m_iContentLen = 0;
48   m_bLeftPadding = false;
49   m_bRightPadding = false;
50 }
51 
~CBC_OneDimWriter()52 CBC_OneDimWriter::~CBC_OneDimWriter() {}
53 
SetPrintChecksum(bool checksum)54 void CBC_OneDimWriter::SetPrintChecksum(bool checksum) {
55   m_bPrintChecksum = checksum;
56 }
57 
SetDataLength(int32_t length)58 void CBC_OneDimWriter::SetDataLength(int32_t length) {
59   m_iDataLenth = length;
60 }
61 
SetCalcChecksum(bool state)62 void CBC_OneDimWriter::SetCalcChecksum(bool state) {
63   m_bCalcChecksum = state;
64 }
65 
SetFont(CFX_Font * cFont)66 bool CBC_OneDimWriter::SetFont(CFX_Font* cFont) {
67   if (!cFont)
68     return false;
69 
70   m_pFont = cFont;
71   return true;
72 }
73 
SetFontSize(float size)74 void CBC_OneDimWriter::SetFontSize(float size) {
75   m_fFontSize = size;
76 }
77 
SetFontStyle(int32_t style)78 void CBC_OneDimWriter::SetFontStyle(int32_t style) {
79   m_iFontStyle = style;
80 }
81 
SetFontColor(FX_ARGB color)82 void CBC_OneDimWriter::SetFontColor(FX_ARGB color) {
83   m_fontColor = color;
84 }
85 
Upper(wchar_t ch)86 wchar_t CBC_OneDimWriter::Upper(wchar_t ch) {
87   if (ch >= 'a' && ch <= 'z') {
88     ch = ch - ('a' - 'A');
89   }
90   return ch;
91 }
92 
EncodeWithHint(const ByteString & contents,BCFORMAT format,int32_t & outWidth,int32_t & outHeight,int32_t hints)93 uint8_t* CBC_OneDimWriter::EncodeWithHint(const ByteString& contents,
94                                           BCFORMAT format,
95                                           int32_t& outWidth,
96                                           int32_t& outHeight,
97                                           int32_t hints) {
98   outHeight = 1;
99   return EncodeImpl(contents, outWidth);
100 }
101 
Encode(const ByteString & contents,BCFORMAT format,int32_t & outWidth,int32_t & outHeight)102 uint8_t* CBC_OneDimWriter::Encode(const ByteString& contents,
103                                   BCFORMAT format,
104                                   int32_t& outWidth,
105                                   int32_t& outHeight) {
106   return EncodeWithHint(contents, format, outWidth, outHeight, 0);
107 }
108 
AppendPattern(uint8_t * target,int32_t pos,const int8_t * pattern,int32_t patternLength,int32_t startColor,int32_t & e)109 int32_t CBC_OneDimWriter::AppendPattern(uint8_t* target,
110                                         int32_t pos,
111                                         const int8_t* pattern,
112                                         int32_t patternLength,
113                                         int32_t startColor,
114                                         int32_t& e) {
115   if (startColor != 0 && startColor != 1) {
116     e = BCExceptionValueMustBeEither0or1;
117     return 0;
118   }
119   uint8_t color = (uint8_t)startColor;
120   int32_t numAdded = 0;
121   for (int32_t i = 0; i < patternLength; i++) {
122     for (int32_t j = 0; j < pattern[i]; j++) {
123       target[pos++] = color;
124       numAdded += 1;
125     }
126     color ^= 1;
127   }
128   return numAdded;
129 }
130 
CalcTextInfo(const ByteString & text,FXTEXT_CHARPOS * charPos,CFX_Font * cFont,float geWidth,int32_t fontSize,float & charsLen)131 void CBC_OneDimWriter::CalcTextInfo(const ByteString& text,
132                                     FXTEXT_CHARPOS* charPos,
133                                     CFX_Font* cFont,
134                                     float geWidth,
135                                     int32_t fontSize,
136                                     float& charsLen) {
137   std::unique_ptr<CFX_UnicodeEncodingEx> encoding =
138       FX_CreateFontEncodingEx(cFont, FXFM_ENCODING_NONE);
139 
140   size_t length = text.GetLength();
141   uint32_t* pCharCode = FX_Alloc(uint32_t, text.GetLength());
142   float charWidth = 0;
143   for (size_t j = 0; j < length; j++) {
144     pCharCode[j] = encoding->CharCodeFromUnicode(text[j]);
145     int32_t glyp_code = encoding->GlyphFromCharCode(pCharCode[j]);
146     int32_t glyp_value = cFont->GetGlyphWidth(glyp_code);
147     float temp = (float)((glyp_value)*fontSize / 1000.0);
148     charWidth += temp;
149   }
150   charsLen = charWidth;
151   float leftPositon = (float)(geWidth - charsLen) / 2.0f;
152   if (leftPositon < 0 && geWidth == 0) {
153     leftPositon = 0;
154   }
155   float penX = 0.0;
156   float penY = (float)abs(cFont->GetDescent()) * (float)fontSize / 1000.0f;
157   float left = leftPositon;
158   float top = 0.0;
159   charPos[0].m_Origin = CFX_PointF(penX + left, penY + top);
160   charPos[0].m_GlyphIndex = encoding->GlyphFromCharCode(pCharCode[0]);
161   charPos[0].m_FontCharWidth = cFont->GetGlyphWidth(charPos[0].m_GlyphIndex);
162 #if _FX_PLATFORM_ == _FX_PLATFORM_APPLE_
163   charPos[0].m_ExtGID = charPos[0].m_GlyphIndex;
164 #endif
165   penX += (float)(charPos[0].m_FontCharWidth) * (float)fontSize / 1000.0f;
166   for (size_t i = 1; i < length; i++) {
167     charPos[i].m_Origin = CFX_PointF(penX + left, penY + top);
168     charPos[i].m_GlyphIndex = encoding->GlyphFromCharCode(pCharCode[i]);
169     charPos[i].m_FontCharWidth = cFont->GetGlyphWidth(charPos[i].m_GlyphIndex);
170 #if _FX_PLATFORM_ == _FX_PLATFORM_APPLE_
171     charPos[i].m_ExtGID = charPos[i].m_GlyphIndex;
172 #endif
173     penX += (float)(charPos[i].m_FontCharWidth) * (float)fontSize / 1000.0f;
174   }
175   FX_Free(pCharCode);
176 }
177 
ShowDeviceChars(CFX_RenderDevice * device,const CFX_Matrix * matrix,const ByteString str,float geWidth,FXTEXT_CHARPOS * pCharPos,float locX,float locY,int32_t barWidth)178 void CBC_OneDimWriter::ShowDeviceChars(CFX_RenderDevice* device,
179                                        const CFX_Matrix* matrix,
180                                        const ByteString str,
181                                        float geWidth,
182                                        FXTEXT_CHARPOS* pCharPos,
183                                        float locX,
184                                        float locY,
185                                        int32_t barWidth) {
186   int32_t iFontSize = (int32_t)fabs(m_fFontSize);
187   int32_t iTextHeight = iFontSize + 1;
188   CFX_FloatRect rect((float)locX, (float)locY, (float)(locX + geWidth),
189                      (float)(locY + iTextHeight));
190   if (geWidth != m_Width) {
191     rect.right -= 1;
192   }
193   FX_RECT re = matrix->TransformRect(rect).GetOuterRect();
194   device->FillRect(&re, m_backgroundColor);
195   CFX_Matrix affine_matrix(1.0, 0.0, 0.0, -1.0, (float)locX,
196                            (float)(locY + iFontSize));
197   if (matrix) {
198     affine_matrix.Concat(*matrix);
199   }
200   device->DrawNormalText(str.GetLength(), pCharPos, m_pFont.Get(),
201                          static_cast<float>(iFontSize), &affine_matrix,
202                          m_fontColor, FXTEXT_CLEARTYPE);
203 }
204 
ShowChars(const WideStringView & contents,CFX_RenderDevice * device,const CFX_Matrix * matrix,int32_t barWidth,int32_t multiple)205 bool CBC_OneDimWriter::ShowChars(const WideStringView& contents,
206                                  CFX_RenderDevice* device,
207                                  const CFX_Matrix* matrix,
208                                  int32_t barWidth,
209                                  int32_t multiple) {
210   if (!device || !m_pFont)
211     return false;
212 
213   ByteString str = FX_UTF8Encode(contents);
214   int32_t iLen = str.GetLength();
215   std::vector<FXTEXT_CHARPOS> charpos(iLen);
216   float charsLen = 0;
217   float geWidth = 0;
218   if (m_locTextLoc == BC_TEXT_LOC_ABOVEEMBED ||
219       m_locTextLoc == BC_TEXT_LOC_BELOWEMBED) {
220     geWidth = 0;
221   } else if (m_locTextLoc == BC_TEXT_LOC_ABOVE ||
222              m_locTextLoc == BC_TEXT_LOC_BELOW) {
223     geWidth = (float)barWidth;
224   }
225   int32_t iFontSize = (int32_t)fabs(m_fFontSize);
226   int32_t iTextHeight = iFontSize + 1;
227   CalcTextInfo(str, charpos.data(), m_pFont.Get(), geWidth, iFontSize,
228                charsLen);
229   if (charsLen < 1)
230     return true;
231 
232   int32_t locX = 0;
233   int32_t locY = 0;
234   switch (m_locTextLoc) {
235     case BC_TEXT_LOC_ABOVEEMBED:
236       locX = (int32_t)(barWidth - charsLen) / 2;
237       locY = 0;
238       geWidth = charsLen;
239       break;
240     case BC_TEXT_LOC_ABOVE:
241       locX = 0;
242       locY = 0;
243       geWidth = (float)barWidth;
244       break;
245     case BC_TEXT_LOC_BELOWEMBED:
246       locX = (int32_t)(barWidth - charsLen) / 2;
247       locY = m_Height - iTextHeight;
248       geWidth = charsLen;
249       break;
250     case BC_TEXT_LOC_BELOW:
251     default:
252       locX = 0;
253       locY = m_Height - iTextHeight;
254       geWidth = (float)barWidth;
255       break;
256   }
257   ShowDeviceChars(device, matrix, str, geWidth, charpos.data(), (float)locX,
258                   (float)locY, barWidth);
259   return true;
260 }
261 
RenderDeviceResult(CFX_RenderDevice * device,const CFX_Matrix * matrix,const WideStringView & contents)262 bool CBC_OneDimWriter::RenderDeviceResult(CFX_RenderDevice* device,
263                                           const CFX_Matrix* matrix,
264                                           const WideStringView& contents) {
265   if (m_output.empty())
266     return false;
267 
268   CFX_GraphStateData stateData;
269   CFX_PathData path;
270   path.AppendRect(0, 0, static_cast<float>(m_Width),
271                   static_cast<float>(m_Height));
272   device->DrawPath(&path, matrix, &stateData, m_backgroundColor,
273                    m_backgroundColor, FXFILL_ALTERNATE);
274   CFX_Matrix scaledMatrix(m_outputHScale, 0.0, 0.0,
275                           static_cast<float>(m_Height), 0.0, 0.0);
276   scaledMatrix.Concat(*matrix);
277   for (auto& rect : m_output) {
278     CFX_GraphStateData data;
279     device->DrawPath(&rect, &scaledMatrix, &data, m_barColor, 0,
280                      FXFILL_WINDING);
281   }
282 
283   return m_locTextLoc == BC_TEXT_LOC_NONE || !contents.Contains(' ') ||
284          ShowChars(contents, device, matrix, m_barWidth, m_multiple);
285 }
286 
RenderResult(const WideStringView & contents,uint8_t * code,int32_t codeLength)287 bool CBC_OneDimWriter::RenderResult(const WideStringView& contents,
288                                     uint8_t* code,
289                                     int32_t codeLength) {
290   if (codeLength < 1)
291     return false;
292 
293   m_ModuleHeight = std::max(m_ModuleHeight, 20);
294   const int32_t codeOldLength = codeLength;
295   const int32_t leftPadding = m_bLeftPadding ? 7 : 0;
296   const int32_t rightPadding = m_bRightPadding ? 7 : 0;
297   codeLength += leftPadding;
298   codeLength += rightPadding;
299   m_outputHScale =
300       m_Width > 0 ? static_cast<float>(m_Width) / static_cast<float>(codeLength)
301                   : 1.0;
302   m_multiple = 1;
303   const int32_t outputHeight = 1;
304   const int32_t outputWidth = codeLength;
305   m_barWidth = m_Width;
306 
307   m_output.clear();
308   for (int32_t inputX = 0, outputX = leftPadding * m_multiple;
309        inputX < codeOldLength; ++inputX, outputX += m_multiple) {
310     if (code[inputX] != 1)
311       continue;
312 
313     if (outputX >= outputWidth)
314       return true;
315 
316     if (outputX + m_multiple > outputWidth && outputWidth - outputX > 0) {
317       RenderVerticalBars(outputX, outputWidth - outputX, outputHeight);
318       return true;
319     }
320 
321     RenderVerticalBars(outputX, m_multiple, outputHeight);
322   }
323   return true;
324 }
325 
RenderVerticalBars(int32_t outputX,int32_t width,int32_t height)326 void CBC_OneDimWriter::RenderVerticalBars(int32_t outputX,
327                                           int32_t width,
328                                           int32_t height) {
329   for (int i = 0; i < width; ++i) {
330     float x = outputX + i;
331     CFX_PathData rect;
332     rect.AppendRect(x, 0.0f, x + 1, static_cast<float>(height));
333     m_output.push_back(rect);
334   }
335 }
336 
RenderTextContents(const WideStringView & contents)337 WideString CBC_OneDimWriter::RenderTextContents(
338     const WideStringView& contents) {
339   return WideString();
340 }
341