blob: 22cc09513fdd835b215fb6cc5d864ad3668d4a8e [file] [log] [blame]
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
// Original code is licensed as follows:
/*
* Copyright 2011 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "fxbarcode/oned/BC_OneDimWriter.h"
#include <algorithm>
#include <memory>
#include <vector>
#include "core/fxge/cfx_defaultrenderdevice.h"
#include "core/fxge/cfx_graphstatedata.h"
#include "core/fxge/cfx_pathdata.h"
#include "core/fxge/cfx_renderdevice.h"
#include "core/fxge/cfx_unicodeencodingex.h"
#include "fxbarcode/BC_Writer.h"
#include "third_party/base/ptr_util.h"
CBC_OneDimWriter::CBC_OneDimWriter() {
m_locTextLoc = BC_TEXT_LOC_BELOWEMBED;
m_bPrintChecksum = true;
m_iDataLenth = 0;
m_bCalcChecksum = false;
m_pFont = nullptr;
m_fFontSize = 10;
m_iFontStyle = 0;
m_fontColor = 0xff000000;
m_iContentLen = 0;
m_bLeftPadding = false;
m_bRightPadding = false;
}
CBC_OneDimWriter::~CBC_OneDimWriter() {}
void CBC_OneDimWriter::SetPrintChecksum(bool checksum) {
m_bPrintChecksum = checksum;
}
void CBC_OneDimWriter::SetDataLength(int32_t length) {
m_iDataLenth = length;
}
void CBC_OneDimWriter::SetCalcChecksum(bool state) {
m_bCalcChecksum = state;
}
bool CBC_OneDimWriter::SetFont(CFX_Font* cFont) {
if (!cFont)
return false;
m_pFont = cFont;
return true;
}
void CBC_OneDimWriter::SetFontSize(float size) {
m_fFontSize = size;
}
void CBC_OneDimWriter::SetFontStyle(int32_t style) {
m_iFontStyle = style;
}
void CBC_OneDimWriter::SetFontColor(FX_ARGB color) {
m_fontColor = color;
}
wchar_t CBC_OneDimWriter::Upper(wchar_t ch) {
if (ch >= 'a' && ch <= 'z') {
ch = ch - ('a' - 'A');
}
return ch;
}
uint8_t* CBC_OneDimWriter::EncodeWithHint(const CFX_ByteString& contents,
BCFORMAT format,
int32_t& outWidth,
int32_t& outHeight,
int32_t hints) {
outHeight = 1;
return EncodeImpl(contents, outWidth);
}
uint8_t* CBC_OneDimWriter::Encode(const CFX_ByteString& contents,
BCFORMAT format,
int32_t& outWidth,
int32_t& outHeight) {
return EncodeWithHint(contents, format, outWidth, outHeight, 0);
}
int32_t CBC_OneDimWriter::AppendPattern(uint8_t* target,
int32_t pos,
const int8_t* pattern,
int32_t patternLength,
int32_t startColor,
int32_t& e) {
if (startColor != 0 && startColor != 1) {
e = BCExceptionValueMustBeEither0or1;
return 0;
}
uint8_t color = (uint8_t)startColor;
int32_t numAdded = 0;
for (int32_t i = 0; i < patternLength; i++) {
for (int32_t j = 0; j < pattern[i]; j++) {
target[pos++] = color;
numAdded += 1;
}
color ^= 1;
}
return numAdded;
}
void CBC_OneDimWriter::CalcTextInfo(const CFX_ByteString& text,
FXTEXT_CHARPOS* charPos,
CFX_Font* cFont,
float geWidth,
int32_t fontSize,
float& charsLen) {
std::unique_ptr<CFX_UnicodeEncodingEx> encoding =
FX_CreateFontEncodingEx(cFont, FXFM_ENCODING_NONE);
int32_t length = text.GetLength();
uint32_t* pCharCode = FX_Alloc(uint32_t, text.GetLength());
float charWidth = 0;
for (int32_t j = 0; j < text.GetLength(); j++) {
pCharCode[j] = encoding->CharCodeFromUnicode(text[j]);
int32_t glyp_code = encoding->GlyphFromCharCode(pCharCode[j]);
int32_t glyp_value = cFont->GetGlyphWidth(glyp_code);
float temp = (float)((glyp_value)*fontSize / 1000.0);
charWidth += temp;
}
charsLen = charWidth;
float leftPositon = (float)(geWidth - charsLen) / 2.0f;
if (leftPositon < 0 && geWidth == 0) {
leftPositon = 0;
}
float penX = 0.0;
float penY = (float)abs(cFont->GetDescent()) * (float)fontSize / 1000.0f;
float left = leftPositon;
float top = 0.0;
charPos[0].m_Origin = CFX_PointF(penX + left, penY + top);
charPos[0].m_GlyphIndex = encoding->GlyphFromCharCode(pCharCode[0]);
charPos[0].m_FontCharWidth = cFont->GetGlyphWidth(charPos[0].m_GlyphIndex);
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
charPos[0].m_ExtGID = charPos[0].m_GlyphIndex;
#endif
penX += (float)(charPos[0].m_FontCharWidth) * (float)fontSize / 1000.0f;
for (int32_t i = 1; i < length; i++) {
charPos[i].m_Origin = CFX_PointF(penX + left, penY + top);
charPos[i].m_GlyphIndex = encoding->GlyphFromCharCode(pCharCode[i]);
charPos[i].m_FontCharWidth = cFont->GetGlyphWidth(charPos[i].m_GlyphIndex);
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
charPos[i].m_ExtGID = charPos[i].m_GlyphIndex;
#endif
penX += (float)(charPos[i].m_FontCharWidth) * (float)fontSize / 1000.0f;
}
FX_Free(pCharCode);
}
void CBC_OneDimWriter::ShowDeviceChars(CFX_RenderDevice* device,
const CFX_Matrix* matrix,
const CFX_ByteString str,
float geWidth,
FXTEXT_CHARPOS* pCharPos,
float locX,
float locY,
int32_t barWidth) {
int32_t iFontSize = (int32_t)fabs(m_fFontSize);
int32_t iTextHeight = iFontSize + 1;
CFX_FloatRect rect((float)locX, (float)locY, (float)(locX + geWidth),
(float)(locY + iTextHeight));
if (geWidth != m_Width) {
rect.right -= 1;
}
matrix->TransformRect(rect);
FX_RECT re = rect.GetOuterRect();
device->FillRect(&re, m_backgroundColor);
CFX_Matrix affine_matrix(1.0, 0.0, 0.0, -1.0, (float)locX,
(float)(locY + iFontSize));
if (matrix) {
affine_matrix.Concat(*matrix);
}
device->DrawNormalText(str.GetLength(), pCharPos, m_pFont.Get(),
static_cast<float>(iFontSize), &affine_matrix,
m_fontColor, FXTEXT_CLEARTYPE);
}
bool CBC_OneDimWriter::ShowChars(const CFX_WideStringC& contents,
CFX_RenderDevice* device,
const CFX_Matrix* matrix,
int32_t barWidth,
int32_t multiple) {
if (!device || !m_pFont)
return false;
CFX_ByteString str = FX_UTF8Encode(contents);
int32_t iLen = str.GetLength();
std::vector<FXTEXT_CHARPOS> charpos(iLen);
float charsLen = 0;
float geWidth = 0;
if (m_locTextLoc == BC_TEXT_LOC_ABOVEEMBED ||
m_locTextLoc == BC_TEXT_LOC_BELOWEMBED) {
geWidth = 0;
} else if (m_locTextLoc == BC_TEXT_LOC_ABOVE ||
m_locTextLoc == BC_TEXT_LOC_BELOW) {
geWidth = (float)barWidth;
}
int32_t iFontSize = (int32_t)fabs(m_fFontSize);
int32_t iTextHeight = iFontSize + 1;
CalcTextInfo(str, charpos.data(), m_pFont.Get(), geWidth, iFontSize,
charsLen);
if (charsLen < 1)
return true;
int32_t locX = 0;
int32_t locY = 0;
switch (m_locTextLoc) {
case BC_TEXT_LOC_ABOVEEMBED:
locX = (int32_t)(barWidth - charsLen) / 2;
locY = 0;
geWidth = charsLen;
break;
case BC_TEXT_LOC_ABOVE:
locX = 0;
locY = 0;
geWidth = (float)barWidth;
break;
case BC_TEXT_LOC_BELOWEMBED:
locX = (int32_t)(barWidth - charsLen) / 2;
locY = m_Height - iTextHeight;
geWidth = charsLen;
break;
case BC_TEXT_LOC_BELOW:
default:
locX = 0;
locY = m_Height - iTextHeight;
geWidth = (float)barWidth;
break;
}
ShowDeviceChars(device, matrix, str, geWidth, charpos.data(), (float)locX,
(float)locY, barWidth);
return true;
}
bool CBC_OneDimWriter::RenderDeviceResult(CFX_RenderDevice* device,
const CFX_Matrix* matrix,
const CFX_WideStringC& contents) {
if (m_output.empty())
return false;
CFX_GraphStateData stateData;
CFX_PathData path;
path.AppendRect(0, 0, static_cast<float>(m_Width),
static_cast<float>(m_Height));
device->DrawPath(&path, matrix, &stateData, m_backgroundColor,
m_backgroundColor, FXFILL_ALTERNATE);
CFX_Matrix scaledMatrix(m_outputHScale, 0.0, 0.0,
static_cast<float>(m_Height), 0.0, 0.0);
scaledMatrix.Concat(*matrix);
for (auto& rect : m_output) {
CFX_GraphStateData data;
device->DrawPath(&rect, &scaledMatrix, &data, m_barColor, 0,
FXFILL_WINDING);
}
return m_locTextLoc == BC_TEXT_LOC_NONE || contents.Find(' ') == -1 ||
ShowChars(contents, device, matrix, m_barWidth, m_multiple);
}
bool CBC_OneDimWriter::RenderResult(const CFX_WideStringC& contents,
uint8_t* code,
int32_t codeLength,
bool isDevice) {
if (codeLength < 1)
return false;
m_ModuleHeight = std::max(m_ModuleHeight, 20);
const int32_t codeOldLength = codeLength;
const int32_t leftPadding = m_bLeftPadding ? 7 : 0;
const int32_t rightPadding = m_bRightPadding ? 7 : 0;
codeLength += leftPadding;
codeLength += rightPadding;
m_outputHScale =
m_Width > 0 ? static_cast<float>(m_Width) / static_cast<float>(codeLength)
: 1.0;
if (!isDevice) {
m_outputHScale =
std::max(m_outputHScale, static_cast<float>(m_ModuleWidth));
}
float dataLengthScale = 1.0;
if (m_iDataLenth > 0 && contents.GetLength() != 0)
dataLengthScale = float(contents.GetLength()) / float(m_iDataLenth);
if (m_iDataLenth > 0 && contents.GetLength() == 0)
dataLengthScale = float(1) / float(m_iDataLenth);
m_multiple = 1;
if (!isDevice) {
m_multiple = (int32_t)ceil(m_outputHScale * dataLengthScale);
}
int32_t outputHeight = 1;
if (!isDevice)
outputHeight = m_Height ? m_Height : std::max(20, m_ModuleHeight);
int32_t outputWidth = codeLength;
if (!isDevice)
outputWidth = (int32_t)(codeLength * m_multiple / dataLengthScale);
m_barWidth = m_Width;
if (!isDevice)
m_barWidth = codeLength * m_multiple;
m_output.clear();
for (int32_t inputX = 0, outputX = leftPadding * m_multiple;
inputX < codeOldLength; ++inputX, outputX += m_multiple) {
if (code[inputX] != 1)
continue;
if (outputX >= outputWidth)
return true;
if (outputX + m_multiple > outputWidth && outputWidth - outputX > 0) {
RenderVerticalBars(outputX, outputWidth - outputX, outputHeight);
return true;
}
RenderVerticalBars(outputX, m_multiple, outputHeight);
}
return true;
}
void CBC_OneDimWriter::RenderVerticalBars(int32_t outputX,
int32_t width,
int32_t height) {
for (int i = 0; i < width; ++i) {
float x = outputX + i;
CFX_PathData rect;
rect.AppendRect(x, 0.0f, x + 1, static_cast<float>(height));
m_output.push_back(rect);
}
}
CFX_WideString CBC_OneDimWriter::RenderTextContents(
const CFX_WideStringC& contents) {
return CFX_WideString();
}