QR код всегда разный

#pragma hdrstop
 
#include "BarCode.h"
//---------------------------------------------------------------------------
 
#pragma package(smart_init)
//---------------------------------------------------------------------------
 
namespace Barcode {
//---------------------------------------------------------------------------
 
bool __fastcall CheckIfChangeModeOpimized(DynamicArray <QRCode_Segment> &segments, int segIndex)
{
    bool result = true;
    if (segIndex > 0 && segments[segIndex].bitLength != -1/*LENGTH_OVERFLOW*/ && segments[segIndex - 1].bitLength != -1/*LENGTH_OVERFLOW*/)
    {
        if (segments[segIndex - 1].mode == segments[segIndex].mode)
            result = false;
        else if (segments[segIndex - 1].mode > segments[segIndex].mode)
        {
            int bitLength = QRCodeEnc::CalcSegmentBitLength(segments[segIndex - 1].mode, segments[segIndex - 1].numChars + segments[segIndex].numChars);
            int modeAndLenBitLength;
            if (segments[segIndex].mode == QRCode_Mode_NUMERIC)
                modeAndLenBitLength = 4 + 10;// + 4;
            else if (segments[segIndex].mode == QRCode_Mode_ALPHANUMERIC)
                modeAndLenBitLength = 4 + 9;// + 4;
            if (segments[segIndex - 1].bitLength + modeAndLenBitLength + segments[segIndex].bitLength >= bitLength)
            {
                result = false;
                //segments[segIndex - 1].bitLength = bitLength;
            }
        }
    }
    return result;
}
//---------------------------------------------------------------------------
 
TBytes __fastcall QRCodeEncode (const UTF8String &text, bool splitIntoSegments, int &version, QRCode_Ecc &ecl, QRCode_Mask &mask, bool eclBoost)
{
    TBytes tempBuffer, qrcode;
    qrcode.Length = QRCode_BUFFER_LEN_MAX;
    tempBuffer.Length = qrcode.Length;
    int dataLen = text.Length();
    bool res = false;
    if (splitIntoSegments && dataLen > 0)
    {
        DynamicArray <QRCode_Segment> segments;
        DynamicArray <TBytes> buffers;
 
        // Split data into segments and calculate the size of the segments
        int l;
        char* data = text.c_str();
        QRCode_Mode currMode, mode = (QRCode_Mode)0;
        for (int i = 0; i < dataLen; ++i, ++data)
        {
            if (*data >= '0' && *data <= '9')
                currMode = QRCode_Mode_NUMERIC; // 0x1
            else if (QRCodeEnc::IsAlphanumericLatinChar(*data))
                currMode = QRCode_Mode_ALPHANUMERIC; // 0x2
            else
                currMode = QRCode_Mode_BYTE; // 0x4
            if (mode != currMode)
            {
                mode = currMode;
                int segIndex = segments.Length;
                segments.Length = segIndex + 1;
                segments[segIndex].mode = mode;
                if (segIndex > 0)
                {
                    segments[segIndex - 1].numChars = i - l; // Data size in bytes
                    segments[segIndex - 1].bitLength = QRCodeEnc::CalcSegmentBitLength(segments[segIndex - 1].mode, segments[segIndex - 1].numChars); // Segment bit length
                    if (!CheckIfChangeModeOpimized(segments, segIndex - 1))
                    {
                        segments[segIndex - 2].numChars += segments[segIndex - 1].numChars;
                        segments[segIndex - 2].bitLength = QRCodeEnc::CalcSegmentBitLength(segments[segIndex - 2].mode, segments[segIndex - 2].numChars);
                        segments[segIndex - 1] = segments[segIndex];
                        segments.Length = segIndex;
                    }
                }
                l = i;
            }
        }
        segments[segments.Length - 1].numChars = dataLen - l;
        if (!CheckIfChangeModeOpimized(segments, segments.Length - 1))
        {
            segments[segments.Length - 2].numChars += segments[segments.Length - 1].numChars;
            segments[segments.Length - 2].bitLength = QRCodeEnc::CalcSegmentBitLength(segments[segments.Length - 2].mode, segments[segments.Length - 2].numChars);
            segments.Length = segments.Length - 1;
        }
 
        // Another segment optimization
        l = 0;
        for (int i = 0; i < segments.Length - 2; ++i)
        {
            l += segments[i].numChars;
            if (segments[i].mode == segments[i + 2].mode && segments[i].mode > segments[i + 1].mode && segments[i].bitLength != -1/*LENGTH_OVERFLOW*/ && segments[i + 1].bitLength != -1/*LENGTH_OVERFLOW*/ && segments[i + 2].bitLength != -1/*LENGTH_OVERFLOW*/)
            {
                int bitLength = QRCodeEnc::CalcSegmentBitLength(segments[i].mode, segments[i].numChars + segments[i + 1].numChars + segments[i + 2].numChars);
                int modeAndLenBitLength1;
                if (segments[i + 1].mode == QRCode_Mode_NUMERIC)
                    modeAndLenBitLength1 = 4 + 10;// + 4;
                else if (segments[i + 1].mode == QRCode_Mode_ALPHANUMERIC)
                    modeAndLenBitLength1 = 4 + 9;// + 4;
                int modeAndLenBitLength2;
                if (segments[i + 2].mode == QRCode_Mode_ALPHANUMERIC)
                    modeAndLenBitLength2 = 4 + 9;// + 4;
                else if (segments[i + 2].mode == QRCode_Mode_BYTE)
                    modeAndLenBitLength2 = 4 + 8;// + 8;
                if (segments[i].bitLength + modeAndLenBitLength1 + segments[i + 1].bitLength + modeAndLenBitLength2 + segments[i + 2].bitLength >= bitLength)
                {
                    segments[i].numChars += segments[i + 1].numChars + segments[i + 2].numChars;
                    segments[i].bitLength = QRCodeEnc::CalcSegmentBitLength(segments[i].mode, segments[i].numChars);
                    for (int j = i + 3; j < segments.Length; ++j)
                        segments[j - 2] = segments[j];
                    segments.Length = segments.Length - 2;
                }
            }
        }
 
        // Prepare the segments
        buffers.Length = segments.Length;
        data = text.c_str();
        res = true;
        for (int i = 0; res && i < segments.Length; ++i)
        {
            l = segments[i].numChars;
            if (segments[i].mode == QRCode_Mode_NUMERIC)
            {
                res = QRCodeEnc::CalcSegmentBufferSize(QRCode_Mode_NUMERIC, l) <= (size_t)tempBuffer.Length;
                if (res)
                {
                    segments[i] = QRCodeEnc::MakeNumeric(data, l, &tempBuffer[0]);
                    res = segments[i].bitLength != -1/*LENGTH_OVERFLOW*/;
                    data += l;
                }
            }
            else if (segments[i].mode == QRCode_Mode_ALPHANUMERIC)
            {
                res = QRCodeEnc::CalcSegmentBufferSize(QRCode_Mode_ALPHANUMERIC, l) <= (size_t)tempBuffer.Length;
                if (res)
                {
                    segments[i] = QRCodeEnc::MakeAlphanumeric(data, l, &tempBuffer[0]);
                    res = segments[i].bitLength != -1/*LENGTH_OVERFLOW*/;
                    data += l;
                }
            }
            else
            {
                res = l <= tempBuffer.Length;
                if (res)
                {
                    segments[i] = QRCodeEnc::MakeBytes(data, l, &tempBuffer[0]);
                    res = segments[i].bitLength != -1/*LENGTH_OVERFLOW*/;
                    data += l;
                }
            }
 
            if (res)
            {
                buffers[i].Length = segments[i].bitLength / 8 + (segments[i].bitLength % 8 > 0);
                segments[i].data = &buffers[i][0];
                memcpy(segments[i].data, &tempBuffer[0], buffers[i].Length);
            }
        }
 
        if (res)
            res = QRCodeEnc::EncodeSegmentsAdvanced(&segments[0],
                                                    segments.Length,
                                                    version,
                                                    QRCode_Ver_MAX, /* The smallest possible version within the given range is automatically chosen */
                                                    mask,
                                                    ecl, /* Error correction level */
                                                    eclBoost, /* true - The highest possible error correction level without increasing the version */
                                                    &tempBuffer[0],
                                                    &qrcode[0]
            );
    }
    else
    {
        res = QRCodeEnc::EncodeText(text.c_str(),
                                    &tempBuffer[0],
                                    &qrcode[0],
                                    version,
                                    QRCode_Ver_MAX, /* The smallest possible version within the given range is automatically chosen */
                                    mask,
                                    ecl, /* Error correction level */
                                    eclBoost /* true - The highest possible error correction level without increasing the version */
        );
    }
    if (res)
    {
        //int size = QRCodeEnc::GetSize(&qrcode[0]);
        //version = QRCodeEnc::GetVersion(size);
        qrcode.Length = QRCode_BUFFER_LEN_FOR_VERSION(version);
    }
    else
        qrcode.Length = 0;
    return qrcode;
}
//---------------------------------------------------------------------------
 
TBytes __fastcall QRCodeEncodeBin (const void* data, size_t dataLength, int &version, QRCode_Ecc &ecl, QRCode_Mask &mask, bool eclBoost)
{
    TBytes tempBuffer, qrcode;
    qrcode.Length = QRCode_BUFFER_LEN_MAX;
    tempBuffer.Length = qrcode.Length;
    memcpy(&tempBuffer[0], data, dataLength);
    bool res = QRCodeEnc::EncodeBinary( &tempBuffer[0],
                                        dataLength,
                                        &qrcode[0],
                                        version,
                                        QRCode_Ver_MAX, /* The smallest possible version within the given range is automatically chosen */
                                        mask,
                                        ecl, /* Error correction level */
                                        eclBoost /* true - The highest possible error correction level without increasing the version */
    );
    if (res)
    {
        //int size = QRCodeEnc::GetSize(&qrcode[0]);
        //version = QRCodeEnc::GetVersion(size);
        qrcode.Length = QRCode_BUFFER_LEN_FOR_VERSION(version);
    }
    else
        qrcode.Length = 0;
    return qrcode;
}
//---------------------------------------------------------------------------
 
Graphics::TBitmap* __fastcall QRCodeGetBMP (TBytes qrcode, TColor clrBase, TColor clrModule, size_t sizePxModule, size_t sizePxMargin)
{
    Graphics::TBitmap* bmp = new Graphics::TBitmap();
    try
    {
        if (clrBase != Graphics::clNone)
        {
            bmp->SetSize(0, 0);
            bmp->Canvas->Brush->Color = clrBase;
        }
        size_t size = QRCodeEnc::GetSize(&qrcode[0]);
        bmp->SetSize(sizePxModule * size + sizePxMargin * 2, sizePxModule * size + sizePxMargin * 2);
        bmp->Canvas->Brush->Color = clrModule;
        TRect rect(sizePxMargin, sizePxMargin, sizePxMargin + sizePxModule, sizePxMargin + sizePxModule);
        for (size_t y = 0; y < size; ++y)
        {
            OffsetRect(rect, sizePxMargin - rect.left, 0);
            for (size_t x = 0; x < size; ++x)
            {
                if (QRCodeEnc::GetModule(&qrcode[0], x, y))
                    bmp->Canvas->FillRect(rect);
                OffsetRect(rect, rect.Width(), 0);
            }
            OffsetRect(rect, 0, rect.Height());
        }
    }
    catch (...)
    {
        delete bmp;
        bmp = NULL;
    }
    return bmp;
}
//---------------------------------------------------------------------------
 
UTF8String __fastcall QRCodeGetSVG (TBytes qrcode, TColor clrBase, TColor clrModule, size_t sizeMargin)
{
    int size = QRCodeEnc::GetSize(&qrcode[0]);
    UTF8String sSize = IntToStr(size + (int)sizeMargin * 2) + L" " + IntToStr(size + (int)sizeMargin * 2);
    clrBase = (Graphics::TColor)ColorToRGB(clrBase);
    clrModule = (Graphics::TColor)ColorToRGB(clrModule);
    UTF8String sClrBase   = IntToHex(GetRValue(clrBase), 2) + IntToHex(GetGValue(clrBase), 2) + IntToHex(GetBValue(clrBase), 2);
    UTF8String sClrModule = IntToHex(GetRValue(clrModule), 2) + IntToHex(GetGValue(clrModule), 2) + IntToHex(GetBValue(clrModule), 2);
    UTF8String svg =    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                        "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n"
                        "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 " + sSize + "\" stroke=\"none\">"
                        "<rect fill=\"#" + sClrBase + "\" width=\"100%\" height=\"100%\"/>"
                        "<path fill=\"#" + sClrModule + "\" d=\"";
    for (int y = 0; y < size; ++y)
        for (int x = 0; x < size; ++x)
            if (QRCodeEnc::GetModule(&qrcode[0], x, y))
                svg += L" M" + IntToStr((int)sizeMargin + x) + L"," + IntToStr((int)sizeMargin + y) + L"h1v1h-1z";
    svg += "\"/></svg>";
    return svg;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
 
TFont* EAN13Font = new TFont();
//---------------------------------------------------------------------------
 
String __fastcall EAN13IntToStr (__int64 num12Digit)
{
    String result;
    AnsiString s = StringOfChar('0', sizeof(EAN13Str));
    EAN13Str* ean13Str = (EAN13Str*)s.c_str();
    if (EAN13_NumToStr(num12Digit, *ean13Str))
        result = s;
    return result;
}
//---------------------------------------------------------------------------
 
bool __fastcall EAN13StrToInt (const String &strEAN13, __int64 &numEAN13)
{
    bool result = strEAN13.Length() == (int)sizeof(EAN13Str);
    if (result)
    {
        AnsiString s = strEAN13;
        EAN13Str* ean13Str = (EAN13Str*)s.c_str();
        result = EAN13_ValidateStr(*ean13Str) && TryStrToInt64(strEAN13, numEAN13);
    }
    return result;
}
//---------------------------------------------------------------------------
 
TBytes __fastcall EAN13Encode (String strEAN13)
{
    TBytes arrEAN13;
    if (strEAN13.Length() == (int)sizeof(EAN13Str))
    {
        AnsiString s = strEAN13;
        EAN13Str* ean13Str = (EAN13Str*)s.c_str();
        arrEAN13.Length = sizeof(EAN13);
        EAN13* ean13 = (EAN13*)&arrEAN13[0];
        if (!EAN13_EncodeStr(*ean13Str, *ean13))
            arrEAN13.Length = 0;
    }
    return arrEAN13;
}
//---------------------------------------------------------------------------
 
Graphics::TBitmap* __fastcall EAN13GetBMP (TBytes ean13, String ean13Num, TColor clrBase, TColor clrLine, size_t sizePxLine, float height, size_t sizePxMargin)
{
    Graphics::TBitmap* bmp = NULL;
    if (ean13.Length == (int)sizeof(EAN13)) // 95
    {
        bmp = new Graphics::TBitmap();
        try
        {
            int w = sizePxLine * ean13.Length;
            int h = w * height;
            TRect rect;
            int digitWidth = sizePxLine * 7;
            int numRectWidth = digitWidth * 6;
            int numFirstWidth = 0;
            int fontHeight = 0;
 
            ean13Num = Trim(ean13Num);
            String numFirst, numLeft, numRight;
 
            if (!ean13Num.IsEmpty() && ean13Num.Length() < 13)
                ean13Num = StringOfChar('0', 13 - ean13Num.Length()) + ean13Num;
            __int64 num;
            if (ean13Num.Length() == 13 && TryStrToInt64(ean13Num, num) && num >= 0)
            {
                // F LLLLLL RRRRRR
                if (ean13Num[1] != '0')
                    numFirst = ean13Num.SubString(1, 1);
                numLeft = ean13Num.SubString(2, 6);
                numRight = ean13Num.SubString(8, 6);
 
                int curLeftWidth = 0, curRightWidth = 0;
                int curFontHeight;
                if (EAN13Font)
                    bmp->Canvas->Font->Assign(EAN13Font);
                bmp->Canvas->Font->Height = 1;
                do
                {
                    fontHeight = bmp->Canvas->Font->Height;
                    curFontHeight = fontHeight + 1;
                    bmp->Canvas->Font->Height = curFontHeight;
                    SetRect(&rect, 0, 0, 0, 0);
                    DrawText(bmp->Canvas->Handle, numLeft.c_str(), numLeft.Length(), &rect, DT_CALCRECT | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP);
                    curLeftWidth = rect.Width();
                    SetRect(&rect, 0, 0, 0, 0);
                    DrawText(bmp->Canvas->Handle, numRight.c_str(), numRight.Length(), &rect, DT_CALCRECT | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP);
                    curRightWidth = rect.Width();
                }
                while (curLeftWidth < numRectWidth && curRightWidth < numRectWidth);
                bmp->Canvas->Font->Height = fontHeight;
 
                if (!numFirst.IsEmpty())
                {
                    SetRect(&rect, 0, 0, 0, 0);
                    DrawText(bmp->Canvas->Handle, numFirst.c_str(), numFirst.Length(), &rect, DT_CALCRECT | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP);
                    numFirstWidth = rect.Width() + sizePxLine * 2;
                }
            }
 
            bmp->SetSize(0, 0);
            bmp->Canvas->Brush->Color = clrBase;
            bmp->SetSize(sizePxMargin * 2 + numFirstWidth + w, sizePxMargin * 2 + h - fontHeight / 2 + fontHeight);
 
            bmp->Canvas->Brush->Color = clrLine;
            SetRect(&rect, sizePxMargin + numFirstWidth, sizePxMargin, sizePxMargin + numFirstWidth + sizePxLine, sizePxMargin + h);
            for (int x = 0; x < ean13.Length; ++x)
            {
                if (ean13[x])
                    bmp->Canvas->FillRect(rect);
                OffsetRect(rect, rect.Width(), 0);
            }
 
            if (!numLeft.IsEmpty() && !numRight.IsEmpty())
            {
                bmp->Canvas->Brush->Color = clrBase;
                bmp->Canvas->Font->Color = clrLine;
 
                if (!numFirst.IsEmpty())
                {
                    SetRect(&rect, sizePxMargin, sizePxMargin + h - bmp->Canvas->Font->Height / 2, sizePxMargin + numFirstWidth, sizePxMargin + h - bmp->Canvas->Font->Height / 2 + bmp->Canvas->Font->Height);
                    DrawText(bmp->Canvas->Handle, numFirst.c_str(), numFirst.Length(), &rect, DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP);
                }
 
                SetRect(&rect, sizePxMargin + numFirstWidth + sizePxLine * 3, sizePxMargin + h - bmp->Canvas->Font->Height / 2, sizePxMargin + numFirstWidth + sizePxLine * 3 + numRectWidth, sizePxMargin + h - bmp->Canvas->Font->Height / 2 + bmp->Canvas->Font->Height);
                bmp->Canvas->FillRect(rect);
                DrawText(bmp->Canvas->Handle, numLeft.c_str(), numLeft.Length(), &rect, DT_CENTER | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP);
                OffsetRect(&rect, rect.Width() + sizePxLine * 5, 0);
                bmp->Canvas->FillRect(rect);
                DrawText(bmp->Canvas->Handle, numRight.c_str(), numRight.Length(), &rect, DT_CENTER | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP);
            }
        }
        catch (...)
        {
            delete bmp;
            bmp = NULL;
        }
    }
    return bmp;
}
//---------------------------------------------------------------------------
 
UTF8String __fastcall EAN13GetSVG (TBytes ean13, String ean13Num, TColor clrBase, TColor clrLine, float height, size_t sizeMargin)
{
    UTF8String svg;
    int w = ean13.Length;
    if (w == (int)sizeof(EAN13)) // 95
    {
        int h = w * height;
        int fontSize = 0;
        int numFirstWidth = 0;
 
        String numFirst, numLeft, numRight;
 
        if (!ean13Num.IsEmpty() && ean13Num.Length() < 13)
            ean13Num = StringOfChar('0', 13 - ean13Num.Length()) + ean13Num;
        __int64 num;
        if (ean13Num.Length() == 13 && TryStrToInt64(ean13Num, num) && num >= 0)
        {
            fontSize = 12;
            // F LLLLLL RRRRRR
            if (ean13Num[1] != '0')
            {
                numFirst = ean13Num.SubString(1, 1);
                numFirstWidth = fontSize / 2;
            }
            numLeft = ean13Num.SubString(2, 6);
            numRight = ean13Num.SubString(8, 6);
        }
 
        UTF8String sSize = IntToStr((int)sizeMargin * 2 + numFirstWidth + w) + L" " + IntToStr((int)sizeMargin * 2 + h + fontSize / 2);
        clrBase = (Graphics::TColor)ColorToRGB(clrBase);
        clrLine = (Graphics::TColor)ColorToRGB(clrLine);
        UTF8String sClrBase = IntToHex(GetRValue(clrBase), 2) + IntToHex(GetGValue(clrBase), 2) + IntToHex(GetBValue(clrBase), 2);
        UTF8String sClrLine = IntToHex(GetRValue(clrLine), 2) + IntToHex(GetGValue(clrLine), 2) + IntToHex(GetBValue(clrLine), 2);
        svg =   "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n"
                "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 " + sSize + "\" stroke=\"none\">"
                "<rect fill=\"#" + sClrBase + "\" width=\"100%\" height=\"100%\"/>"
                "<path fill=\"#" + sClrLine + "\" d=\"";
 
        int p = 0;
        bool guardLine;
        for (int x = 0; x < w; ++x)
        {
            if (ean13[x])
                ++p;
            else if (p)
            {
                guardLine = x <= 3 || (x >= 46 && x <= 50) || x >= 93;
                svg += L" M" + IntToStr((int)sizeMargin + numFirstWidth + x - p) + L"," + IntToStr((int)sizeMargin) + L"h" + IntToStr(p) + L"v" + IntToStr(h - !guardLine * fontSize / 2) + L"h-" + IntToStr(p) + L"z";
                p = 0;
            }
        }
        if (p)
            svg += L" M" + IntToStr((int)sizeMargin + numFirstWidth + w - p) + L"," + IntToStr((int)sizeMargin) + L"h" + IntToStr(p) + L"v" + IntToStr(h) + L"h-" + IntToStr(p) + L"z";
        svg += "\"/>";
 
        if (fontSize)
        {
            UTF8String sTextAttr =  " font-family=\"Arial, Helvetica, sans-serif\""
                                    " dominant-baseline=\"central\""
                                    " fill=\"#" + sClrLine + "\"";
            sTextAttr += L" font-size=\"" + IntToStr(fontSize) + L"px\""
                         L" y=\"" + IntToStr((int)sizeMargin + h) + L"\"";
            if (numFirstWidth)
            {
                svg += "<text" + sTextAttr; svg += L" x=\"" + IntToStr((int)sizeMargin + numFirstWidth - 1) + L"\" text-anchor=\"end\">" + numFirst + L"</text>";
            }
            svg += "<text" + sTextAttr; svg += L" x=\"" + IntToStr((int)sizeMargin + numFirstWidth + 3 + 7 * 6 / 2            ) + L"\" text-anchor=\"middle\">" + numLeft  + L"</text>";
            svg += "<text" + sTextAttr; svg += L" x=\"" + IntToStr((int)sizeMargin + numFirstWidth + 3 + 7 * 6 + 5 + 7 * 6 / 2) + L"\" text-anchor=\"middle\">" + numRight + L"</text>";
        }
 
        svg += "</svg>";
    }
    return svg;
}
//---------------------------------------------------------------------------
 
} //namespace Barcode
//---------------------------------------------------------------------------