
代码
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;


/**//// <summary>
/// Summary description for FontTools
/// </summary>
public class FontTools


{
const int MAX_LEN = 256;
string szOutput;

public FontTools()

{
//
// TODO: Add constructor logic here
//
}
private bool IsNumeric(string Instr)

{
int idx1 = 0;
int strLen = Instr.Length;
char[] InChar = Instr.ToCharArray();
bool Result = true;
if (strLen > 0)

{
for (idx1 = 0; idx1 < strLen; idx1++)

{
if (Char.IsNumber(InChar[idx1]) == false)
Result = false;
}
}
else

{
Result = false;
}
return Result;
}

private string SpecialChar(string szInpara)

{
string test;
int i, nLen;
int nTemp;
string szTemp = "";
nLen = szInpara.Length;
for (i = 0; i < nLen; i++)

{
if (szInpara[i] == '\\')

{
if (i + 1 < nLen && szInpara[i + 1] == '\\')

{
szTemp += '\\';
i++;
}
else if (i + 3 < nLen && char.IsNumber(szInpara[i + 1]) && char.IsNumber(szInpara[i + 2]) && char.IsNumber(szInpara[i + 3]))

{
test = szInpara.Substring(i + 1, 3);
nTemp = Convert.ToInt32(test);
if (nTemp == 0)
szTemp += (char)240; // use F0 to replace 0
else
szTemp += (char)nTemp;
i = i + 3;
}
else
szTemp += szInpara[i];
}
else
szTemp += szInpara[i];
}
return szTemp;
}


/**//*---------------------------------------------------------------------*/

/**//* Function: Code39 - applies to Morovia Code39 Fontware */

/**//* Code39(text) Converts the input text into a Code 39 barcode string. The */

/**//* function throws off characters not in the Code 39 character set, */

/**//* and adds start/stop characters. */

/**//*----------------------------------------------------------------------*/
public string Code39(string szInpara)

{
int i, nPos;
string szBuffer = "";
string szCharSet = "0123456789.+-/ $%ABCDEFGHIJKLMNOPQRSTUVWXYZ";
i = 0;
while (i < szInpara.Length)

{
nPos = szCharSet.IndexOf(szInpara[i]);
if (szInpara[i] == ' ')
szBuffer += "=";
else if (nPos >= 0)
szBuffer += szInpara[i];
i = i + 1;
}
return "*" + szBuffer + "*";

}

/**//*--------------------------Code39Mod43---------------------------------------*/

/**//*Converts the input text into a Code39 extended symbol. This function */

/**//*should be used to format Morovia code39 font, not Code39 full ASCII font.*/

/**//*The text can be any combinations of ASCII characters. Note that the symbol */

/**//*generated is an extended Code39, and the scanner must be put in Code39 */

/**//*extended mode to read the symbol properly.*/

/**//*----------------------------------------------------------------------------*/
public string Code39Mod43(string szInpara)

{
int i = 0, nPos, nCheckSum = 0;
string inPara = "";
string szBuffer = "";
string szSwap = "";
string szCharSet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%";
string szMappingSet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-.=$/+%";
i = 0;
inPara = szInpara;
while (i < inPara.Length)

{
nPos = szCharSet.IndexOf(inPara[i]);
if (nPos >= 0)

{
szBuffer += szMappingSet[nPos];
nCheckSum = nCheckSum + nPos;
}
i = i + 1;
}
nCheckSum = nCheckSum % 43;
szSwap = '*' + szBuffer + szMappingSet[nCheckSum] + '*';
return szSwap;
}

/**//*--------------------------------Code39Ascii----------------------------------------------*/

/**//*Converts the input text into a Code39 extended symbol. This function should be */

/**//*used to format Morovia code39 font, not Code39 full ASCII font. The text can be*/

/**//*any combinations of ASCII characters. Note that the symbol generated is an extended*/

/**//*Code39, and the scanner must be put in Code39 extended mode to read the symbol properly.*/

/**//*-----------------------------------------------------------------------------------------*/
public string Code39Ascii(string szInpara)

{
int i = 0, nPos;
string szBuffer = "";
string szSpecial = "";
string szWap = "";
szSpecial = SpecialChar(szInpara);
szInpara = szSpecial;
string szCharSet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. " + (char)240;
string szMappingSet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-.=" + (char)240;
while (i < szInpara.Length)

{
nPos = szCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szMappingSet[nPos];
else if (szInpara[i] == 0)
szBuffer += "%U";
else if (szInpara[i] == ' ') //control characters
szBuffer += '=';
else if (szInpara[i] == '/')
szBuffer += "/O";
else if (szInpara[i] == ':')
szBuffer += "/Z";
else if (szInpara[i] == 64)
szBuffer += "%V";
else if (szInpara[i] == 96)
szBuffer += "%W";
else if (szInpara[i] > 0 && szInpara[i] <= 26)

{
szBuffer += '$';
szBuffer += (char)(szInpara[i] + 'A' - 1);
}
else if (szInpara[i] > 32 && szInpara[i] <= 46)

{
szBuffer += '/';
szBuffer += (char)((szInpara[i] % 32) + 'A' - 1);
}
else if (szInpara[i] >= 97 && szInpara[i] <= 122)

{
szBuffer += '+';
szBuffer += (char)((szInpara[i] % 32) + 'A' - 1);
}
else if (szInpara[i] >= 27 && szInpara[i] <= 31)

{
szBuffer += '%';
szBuffer += (char)(szInpara[i] - 27 + 'A');
}
else if (szInpara[i] >= 59 && szInpara[i] <= 63)

{
szBuffer += '%';
szBuffer += (char)(szInpara[i] - 59 + 'F');
}
else if (szInpara[i] >= 91 && szInpara[i] <= 95)

{
szBuffer += '%';
szBuffer += (char)(szInpara[i] - 91 + 'K');
}
else if (szInpara[i] >= 123 && szInpara[i] <= 127)

{
szBuffer += '%';
szBuffer += (char)(szInpara[i] - 123 + 'P');
}
i = i + 1;
}

//replace NULL char
i = 0;
while (i < szBuffer.Length)

{
if (szBuffer[i] == 240)
szWap += "%U";
else
szWap += szBuffer[i];
i++;
}

return '[' + szWap + ']';
}

/**//*---------------------------------Code39Extended------------------------------------*/

/**//*Converts the input text into a Code39 extended symbol. It accepts any ASCII */

/**//*characters as input. The only difference from function Code39Ascii is the former */

/**//*is designed to work with Morovia Code39(Full ASCII) font and the latter is designed*/

/**//*to work with Morovia Code39 font.*/

/**//*-----------------------------------------------------------------------------------*/
public string Code39Extended(string szInpara)

{
int i = 0; char ch;
string szSwap = "";
string szSpecial = "";
string szOutPut = "";
szSpecial = SpecialChar(szInpara);
szSwap = szSpecial;

for (i = 0; i < szSwap.Length; i++)

{
ch = szSwap[i];
if (ch == 240)
szOutPut += (char)0xC0;
else if (ch > 0 && ch <= 0x1F)
szOutPut += (char)(0xC0 + ch);
else if (ch == ' ') //space is mapped to equal sign
szOutPut += '=';
else if (ch == '*')
szOutPut += (char)0xF4;
else if (ch == '=')
szOutPut += (char)0xF0;
else if (ch == '[')
szOutPut += (char)0xF1;
else if (ch == ']')
szOutPut += (char)0xF2;
else if (ch == 0x7F)
szOutPut += (char)0xE0;
else
szOutPut += ch;
}

szOutPut = '[' + szOutPut + ']';
return szOutPut;
}

/**//*--------------------------------Code93-----------------------------------------------*/

/**//*Converts the input text into a Code93 symbol. It accepts any ASCII character input,*/

/**//*taking care of the check character calculation and adding start/stop characters into*/

/**//*the string.*/

/**//*------------------------------------------------------------------------------------*/
public string Code93(string szInpara)

{
int i = 0, nPos, nStrLen;
string szBuffer = "";
int nWeightC, nWeightK;
int nCheckSumC, nCheckSumK;
char cCheckDigitC, cCheckDigitK;
string szCharSet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%@#^&";
string szMappingSet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-.=$/+%@#^&";
string szSpecial = "";

szSpecial = SpecialChar(szInpara);
szInpara = szSpecial;

while (i < szInpara.Length)

{
nPos = szCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szMappingSet[nPos];
else if (szInpara[i] == 240)
szBuffer += "#U";
else if (szInpara[i] == ' ') //control characters
szBuffer += '=';
else if (szInpara[i] == '/')
szBuffer += "^O";
else if (szInpara[i] == ':')
szBuffer += "^Z";
else if (szInpara[i] == 64)
szBuffer += "#V";
else if (szInpara[i] == 96)
szBuffer += "#W";
else if (szInpara[i] > 0 && szInpara[i] <= 26)

{
szBuffer += '@';
szBuffer += (char)(szInpara[i] + 'A' - 1);
}
else if (szInpara[i] > 32 && szInpara[i] <= 46)

{
szBuffer += '^';
szBuffer += (char)((szInpara[i] % 32) + 'A' - 1);
}
else if (szInpara[i] >= 97 && szInpara[i] <= 122)

{
szBuffer += '&';
szBuffer += (char)(szInpara[i] % 32 + 'A' - 1);
}
else if (szInpara[i] >= 27 && szInpara[i] <= 31)

{
szBuffer += '#';
szBuffer += (char)(szInpara[i] - 27 + 'A');
}
else if (szInpara[i] >= 59 && szInpara[i] <= 63)

{
szBuffer += '#';
szBuffer += (char)(szInpara[i] - 59 + 'F');
}
else if (szInpara[i] >= 91 && szInpara[i] <= 95)

{
szBuffer += '#';
szBuffer += (char)(szInpara[i] - 91 + 'K');
}
else if (szInpara[i] >= 123 && szInpara[i] <= 127)

{
szBuffer += '#';
szBuffer += (char)(szInpara[i] - 123 + 'P');
}
i = i + 1;
}

i = 0;
nStrLen = szBuffer.Length;
nCheckSumC = 0;
while (i < szBuffer.Length)

{
nWeightC = (i + 1) % 20;
nPos = szMappingSet.IndexOf(szBuffer[nStrLen - i - 1]);
nCheckSumC = nCheckSumC + nWeightC * nPos;
i = i + 1;
}
nCheckSumC = nCheckSumC % 47;
cCheckDigitC = szMappingSet[nCheckSumC];
szBuffer += cCheckDigitC;

i = 0;
nStrLen = szBuffer.Length;
nCheckSumK = 0;
while (i < nStrLen)

{
nWeightK = (i + 1) % 15;
nPos = szCharSet.IndexOf(szBuffer[nStrLen - i - 1]);
nCheckSumK = nCheckSumK + nWeightK * nPos;
i = i + 1;
}
nCheckSumK = nCheckSumK % 47;
cCheckDigitK = szMappingSet[nCheckSumK];
szBuffer += cCheckDigitK;
return '[' + szBuffer + "]|";
}

private char getUPCCheck(string pszInpara)

{
int nCheckSum = 0, nStrlen;
nStrlen = pszInpara.Length;
for (int i = 0; i < nStrlen; i++)

{
if (i % 2 == 0)
nCheckSum = nCheckSum + 3 * (pszInpara[nStrlen - i - 1] - '0');
else
nCheckSum = nCheckSum + (pszInpara[nStrlen - i - 1] - '0');
}
nCheckSum = nCheckSum % 10;
if (nCheckSum != 0)
nCheckSum = 10 - nCheckSum;
return (char)('0' + nCheckSum);
}

private char textonly(char cDigit)

{
int nDigit = cDigit - '0';
if (nDigit >= 0 && nDigit <= 9)
return (char)(192 + nDigit);
return (char)0;
}

private char convertSetAText(char cChar)

{
int i;
string szCode = "0123456789";
string szDecode = "0123456789";
i = szCode.IndexOf(cChar);
if (i >= 0)
return szDecode[i];
return (char)0;
}

private char convertSetANoText(char cChar)

{
int i;
string szCode = "1234567890";
string szDecode = "!@#$%^&*()";
i = szCode.IndexOf(cChar);
if (i >= 0)
return szDecode[i];
return (char)0;
}

private char convertSetBText(char cChar)

{
int i;
string szCode = "1234567890";
string szDecode = "qwertyuiop";
i = szCode.IndexOf(cChar);
if (i >= 0)
return szDecode[i];
return (char)0;
}

private char convertSetBNoText(char cChar)

{
int i;
string szCode = "1234567890";
string szDecode = "QWERTYUIOP";
i = szCode.IndexOf(cChar);
if (i >= 0)
return szDecode[i];
return (char)0;
}

private char convertSetCText(char cChar)

{
int i;
string szCode = "1234567890";
string szDecode = "asdfghjkl;";
i = szCode.IndexOf(cChar);
if (i >= 0)
return szDecode[i];
return (char)0;
}

private char convertSetCNoText(char cChar)

{
int i;
string szCode = "1234567890";
string szDecode = "ASDFGHJKL:";
i = szCode.IndexOf(cChar);
if (i >= 0)
return szDecode[i];
return (char)0;
}
private string Parity5(int nDigit)

{
string pParity = "";
switch (nDigit)

{
case 0:
pParity = "00111";
break;
case 1:
pParity = "01011";
break;
case 2:
pParity = "01101";
break;
case 3:
pParity = "01110";
break;
case 4:
pParity = "10011";
break;
case 5:
pParity = "11001";
break;
case 6:
pParity = "11100";
break;
case 7:
pParity = "10101";
break;
case 8:
pParity = "10110";
break;
case 9:
pParity = "11010";
break;
}
return pParity;
}
private char LefthandEncoding(int nDigit, int nParity)

{
switch (nDigit)

{
case 0:
if (nParity == 1)
return '/';
else if (nParity == 0)
return '?';
break;
case 1:
if (nParity == 1)
return 'z';
else if (nParity == 0)
return 'Z';
break;
case 2:
if (nParity == 1)
return 'x';
else if (nParity == 0)
return 'X';
break;
case 3:
if (nParity == 1)
return 'c';
else if (nParity == 0)
return 'C';
break;
case 4:
if (nParity == 1)
return 'v';
else if (nParity == 0)
return 'V';
break;
case 5:
if (nParity == 1)
return 'b';
else if (nParity == 0)
return 'B';
break;
case 6:
if (nParity == 1)
return 'n';
else if (nParity == 0)
return 'N';
break;
case 7:
if (nParity == 1)
return 'm';
else if (nParity == 0)
return 'M';
break;
case 8:
if (nParity == 1)
return ',';
else if (nParity == 0)
return '<';
break;
case 9:
if (nParity == 1)
return '.';
else if (nParity == 0)
return '>';
break;
}
return (char)0;
}

private string UPC5SUPP(string szInpara)

{
int i = 0, nCheckSum = 0;
string szBuffer = "";
string szParity = "";
nCheckSum = 3 * (szInpara[0] - '0') + 9 * (szInpara[1] - '0') + 3 * (szInpara[2] - '0') + 9 * (szInpara[3] - '0') + 3 * (szInpara[4] - '0');
szParity = Parity5(nCheckSum % 10);
szBuffer += '{';
for (i = 0; i < 5; i++)

{
szBuffer += LefthandEncoding(szInpara[i] - '0', szParity[i] - '0');
if (i < 4)
szBuffer += '\\';
}
return szBuffer;

}

private string UPC2SUPP(string szInpara)

{
int i = 0;
string szBuffer = "";
int nNum = 0;
int nParity1 = 0, nParity2 = 0;

while (i < szInpara.Length)

{
nNum = 10 * nNum + szInpara[i] - '0';
i = i + 1;
}
nNum = nNum % 4;
switch (nNum)

{
case 0:
nParity1 = 1;
nParity2 = 1;
break;
case 1:
nParity1 = 1;
nParity2 = 0;
break;
case 2:
nParity1 = 0;
nParity2 = 1;
break;
case 3:
nParity1 = 0;
nParity2 = 0;
break;
}
szBuffer += '{';
szBuffer += LefthandEncoding(szInpara[0] - '0', nParity1);
szBuffer += '\\';
szBuffer += LefthandEncoding(szInpara[1] - '0', nParity2);
return szBuffer;
}

private string UPC25SUPP(string szInpara)

{
int i = 0, nStrLen;
string szBuffer = "";
string szSwap = "";

while (i < szInpara.Length)

{
if (szInpara[i] >= '0' && szInpara[i] <= '9')
szBuffer += szInpara[i];
i = i + 1;
}

nStrLen = szBuffer.Length;
if (nStrLen == 0)
szSwap = "";
else if (nStrLen == 1)

{
szBuffer += '0';
szSwap = UPC2SUPP(szBuffer);
}
else if (nStrLen == 2)
szSwap = UPC2SUPP(szBuffer);
else if (nStrLen == 3)

{
szBuffer += "00";
szSwap = UPC5SUPP(szBuffer);
}
else if (nStrLen == 4)

{
szBuffer += "0";
szSwap = UPC5SUPP(szBuffer);
}
else if (nStrLen == 5)
szSwap = UPC5SUPP(szBuffer);
else if (nStrLen > 5)

{
szBuffer = szBuffer.Substring(0, 5);
szSwap = UPC5SUPP(szBuffer);
}

return szSwap;
}

/**//*------------------------------------------EAN13-----------------------------------------*/

/**//*Converts the input text into an EAN barcode. Accepts input of 12 digits of numeric data.*/

/**//*----------------------------------------------------------------------------------------*/
public string EAN13(string szInpara)

{
int i, nStrlen, nCharPos;
string szBuffer = "";
string szSwap = "", szTemp = "", szSUPP = "";
string szParity = "";
char cCheckDigit;
string pszSupplement = "";

nStrlen = szInpara.Length;
for (i = 0; i < nStrlen; i++)

{
if (szInpara[i] >= '0' && szInpara[i] <= '9' || szInpara[i] == '|')
szTemp += szInpara[i];
}
nCharPos = szTemp.IndexOf('|');
if (nCharPos >= 0)

{
pszSupplement = szTemp.Substring(nCharPos + 1, szTemp.Length - nCharPos - 1);
szSUPP = UPC25SUPP(pszSupplement);
szTemp = szTemp.Substring(0, nCharPos);
}

nStrlen = szTemp.Length;
if (nStrlen > 12)
szTemp = szTemp.Substring(0, 12);
else if (nStrlen < 12)

{
while (nStrlen < 12)

{
szTemp += '0';
nStrlen++;
}
}

switch (szTemp[0])

{
case '0':
szParity = "AAAAAA";
break;
case '1':
szParity = "AABABB";
break;
case '2':
szParity = "AABBAB";
break;
case '3':
szParity = "AABBBA";
break;
case '4':
szParity = "ABAABB";
break;
case '5':
szParity = "ABBAAB";
break;
case '6':
szParity = "ABBBAA";
break;
case '7':
szParity = "ABABAB";
break;
case '8':
szParity = "ABABBA";
break;
case '9':
szParity = "ABBABA";
break;
}

for (i = 1; i < 7; i++)

{
if (szParity[i - 1] == 'A')
szBuffer += convertSetAText(szTemp[i]);
else if (szParity[i - 1] == 'B')
szBuffer += convertSetBText(szTemp[i]);
}
szBuffer += '|';
for (i = 7; i < 12; i++)
szBuffer += convertSetCText(szTemp[i]);
cCheckDigit = getUPCCheck(szTemp);

szSwap += textonly(szTemp[0]);
szSwap += '[';
szSwap += szBuffer;
szSwap += convertSetCText(cCheckDigit);
szSwap += ']';

if (szSUPP != "")

{
szSwap += ' ';
szSwap += szSUPP;
}
return szSwap;
}

/**//*--------------------------------------EAN8----------------------------------------------*/

/**//*Converts the input text into an EAN-8 barcode. Accepts input of 7 digits of numeric data.*/

/**//*----------------------------------------------------------------------------------------*/
public string EAN8(string szInpara)

{
int i, nStrlen, nCharPos;
string szBuffer = "";
string szSwap = "", szTemp = "", szSUPP = "";
char cCheckDigit;
string pszSupplement;

nStrlen = szInpara.Length;
for (i = 0; i < nStrlen; i++)

{
if (szInpara[i] >= '0' && szInpara[i] <= '9' || szInpara[i] == '|')
szTemp += szInpara[i];
}
nCharPos = szTemp.IndexOf('|');
if (nCharPos >= 0)

{
pszSupplement = szTemp.Substring(nCharPos + 1, szTemp.Length - nCharPos - 1);
szSUPP = UPC25SUPP(pszSupplement);
szTemp = szTemp.Substring(0, nCharPos);
}

nStrlen = szTemp.Length;
if (nStrlen > 7)
szTemp = szTemp.Substring(0, 7);
else if (nStrlen < 7)

{
while (nStrlen < 7)

{
szTemp += '0';
nStrlen++;
}
}

for (i = 0; i < 4; i++)
szBuffer += convertSetAText(szTemp[i]);
szBuffer += '|';
for (i = 4; i < 7; i++)
szBuffer += convertSetCText(szTemp[i]);
cCheckDigit = getUPCCheck(szTemp);

szSwap += '[';
szSwap += szBuffer;
szSwap += convertSetCText(cCheckDigit);
szSwap += ']';

if (szSUPP != "")

{
szSwap += ' ';
szSwap += szSUPP;
}
return szSwap;
}

/**//*-------------------------------------UPC_A----------------------------------------------*/

/**//*Converts the input text into a UPC-A barcode. Accepts input of 11 digits of numeric data.*/

/**//*----------------------------------------------------------------------------------------*/
public string UPC_A(string szInpara)

{
int i, nStrlen, nCharPos;
string szBuffer = "";
string szSwap = "", szTemp = "", szSUPP = "";
char cCheckDigit;
string pszSupplement;

nStrlen = szInpara.Length;
for (i = 0; i < nStrlen; i++)

{
if (szInpara[i] >= '0' && szInpara[i] <= '9' || szInpara[i] == '|')
szTemp += szInpara[i];
}
nCharPos = szTemp.IndexOf('|');
if (nCharPos >= 0)

{
pszSupplement = szTemp.Substring(nCharPos + 1, szTemp.Length - nCharPos - 1);
szSUPP = UPC25SUPP(pszSupplement);
szTemp = szTemp.Substring(0, nCharPos);
}

nStrlen = szTemp.Length;
if (nStrlen > 11)
szTemp = szTemp.Substring(0, 11);
else if (nStrlen < 11)

{
while (nStrlen < 11)

{
szTemp += '0';
nStrlen++;
}
}

for (i = 1; i < 6; i++)
szBuffer += convertSetAText(szTemp[i]);
szBuffer += '|';
for (i = 6; i < 11; i++)
szBuffer += convertSetCText(szTemp[i]);
cCheckDigit = getUPCCheck(szTemp);

szSwap = "" + textonly(szTemp[0]);
szSwap += '[';
szSwap += convertSetANoText(szTemp[0]);
szSwap += szBuffer;
szSwap += convertSetCNoText(cCheckDigit);
szSwap += ']';
szSwap += textonly(cCheckDigit);

if (szSUPP != "")

{
szSwap += ' ';
szSwap += szSUPP;
}
return szSwap;
}

private string upce2upca(string szInpara)

{
string szBuffer = "";
if (szInpara[0] != '0' || szInpara.Length != 7)
return "";
switch (szInpara[6])

{
case '0':
case '1':
case '2':
szBuffer += szInpara[0] + szInpara[1] + szInpara[2] + szInpara[6] + "0000" + szInpara[3] + szInpara[4] + szInpara[5];
break;
case '3':
if (szInpara[3] == '0' || szInpara[3] == '1' || szInpara[3] == '2')
return "";
szBuffer += szInpara[0] + szInpara[1] + szInpara[2] + szInpara[3] + "00000" + szInpara[4] + szInpara[5];
break;
case '4':
szBuffer += szInpara[0] + szInpara[1] + szInpara[2] + szInpara[3] + szInpara[4] + "00000" + szInpara[5];
break;
case '5':
case '6':
case '7':
case '8':
case '9':
szBuffer += szInpara[0] + szInpara[1] + szInpara[2] + szInpara[3] + szInpara[4] + szInpara[5] + "0000" + szInpara[6];
break;
}
return szBuffer;

}

/**//*------------------------------------UPC_E-----------------------------------------------*/

/**//*Converts the input text into a UPC-E barcode. Accepts input of 6 digits of numeric data.*/

/**//*----------------------------------------------------------------------------------------*/
public string UPC_E(string szInpara)

{
int i, nStrlen, nCharPos;
string szBuffer = "";
string szSwap = "", szTemp = "", szSUPP = "";
string szParity = "";
char cCheckDigit;
string pszSupplement;

nStrlen = szInpara.Length;
for (i = 0; i < nStrlen; i++)

{
if (szInpara[i] >= '0' && szInpara[i] <= '9' || szInpara[i] == '|')
szTemp += szInpara[i];
}
nCharPos = szTemp.IndexOf('|');
if (nCharPos >= 0)

{
pszSupplement = szTemp.Substring(nCharPos + 1, szTemp.Length - nCharPos - 1);
szSUPP = UPC25SUPP(pszSupplement);
szTemp = szTemp.Substring(0, nCharPos);
}

nStrlen = szTemp.Length;
if (nStrlen > 6)
szTemp = szTemp.Substring(0, 6);
else if (nStrlen < 6)

{
while (nStrlen < 6)

{
szTemp += '0';
nStrlen++;
}
}

szTemp = '0' + szTemp;
szSwap = upce2upca(szTemp);
cCheckDigit = getUPCCheck(szSwap);

switch (cCheckDigit)

{
case '0':
szParity = "BBBAAA";
break;
case '1':
szParity = "BBABAA";
break;
case '2':
szParity = "BBAABA";
break;
case '3':
szParity = "BBAAAB";
break;
case '4':
szParity = "BABBAA";
break;
case '5':
szParity = "BAABBA";
break;
case '6':
szParity = "BAAABB";
break;
case '7':
szParity = "BABABA";
break;
case '8':
szParity = "BABAAB";
break;
case '9':
szParity = "BAABAB";
break;
}

for (i = 1; i < 7; i++)

{
if (szParity[i - 1] == 'A')
szBuffer += convertSetAText(szTemp[i]);
else if (szParity[i - 1] == 'B')
szBuffer += convertSetBText(szTemp[i]);
}

szSwap = "";
szSwap += textonly('0');
szSwap += '[';
szSwap += szBuffer;
szSwap += '\'';
szSwap += textonly(cCheckDigit);

if (szSUPP != "")

{
szSwap += ' ';
szSwap += szSUPP;
}
return szSwap;
}

/**//*------------------------------------------Codabar---------------------------------------*/

/**//*Converts the input into a valid Codabar symbol. The default start/stop characters are 揂?/
/*and 揃?*/

/**//*----------------------------------------------------------------------------------------*/
public string Codabar(string szInpara)

{
int i = 0, nPos;
string szBuffer = "A";
string szCharSet = "0123456789-$:/.+";
while (i < szInpara.Length)

{
nPos = szCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szInpara[i];
i = i + 1;
}
szBuffer += 'B';
return szBuffer;
}

/**//*--------------------------------------Code25--------------------------------------------*/

/**//*Converts the input into a valid Code25 symbol. No check character appended.*/

/**//*----------------------------------------------------------------------------------------*/
public string Code25(string szInpara)

{
int i = 0, nPos;
string szBuffer = "[";
string szCharSet = "0123456789";
while (i < szInpara.Length)

{
nPos = szCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szInpara[i];
i = i + 1;
}
szBuffer += ']';
return szBuffer;
}

/**//*----------------------------------Code25Check-------------------------------------------*/

/**//*Converts the input into a valid Code25 symbol. Append a check digit.*/

/**//*----------------------------------------------------------------------------------------*/
public string Code25Check(string szInpara)

{
int i = 0, nCheckSum = 0, nStrLen;
string szBuffer = "";
string szSwap = "";
char cCheckDigit;

while (i < szInpara.Length)

{
if (szInpara[i] >= '0' && szInpara[i] <= '9')
szBuffer += szInpara[i];
i = i + 1;
}

i = 0;
nStrLen = szBuffer.Length;
while (i < szBuffer.Length)

{
if (i % 2 == 0)
nCheckSum = nCheckSum + 3 * (szBuffer[nStrLen - i - 1] - '0');
else
nCheckSum = nCheckSum + szBuffer[nStrLen - i - 1] - '0';
i = i + 1;
}
nCheckSum = nCheckSum % 10;
if (nCheckSum != 0)
nCheckSum = 10 - nCheckSum;
cCheckDigit = (char)('0' + nCheckSum);

szSwap += '[';
szSwap += szBuffer;
szSwap += cCheckDigit;
szSwap += ']';
return szSwap;
}

/**//*----------------------Bookland--------------------------*/

/**//*Converts an ISBN string into a valid Bookland barcode. */

/**//*--------------------------------------------------------*/
public string Bookland(string szInpara)

{
int i = 0, nPos, nStrlen, nCharPos;
string szBuffer = "";
string szSwap = "";
string szLeft = "";
string szRight = "";
string szCharSet = "0123456789";

nStrlen = szInpara.Length;
nCharPos = szInpara.IndexOf('|');
if (nCharPos > -1)

{
for (i = 0; i < nCharPos; i++)
szLeft += szInpara[i];
for (i = nCharPos + 1; i < nStrlen; i++)
szRight += szInpara[i];
}
else
szLeft = szInpara;

i = 0;
while (i < szLeft.Length)

{
nPos = szCharSet.IndexOf(szLeft[i]);
if (nPos >= 0)
szBuffer += szLeft[i];
i = i + 1;
}
nStrlen = szBuffer.Length;
if (nStrlen > 10)
szBuffer = szBuffer.Substring(0, 10);
else if (nStrlen < 10)

{
while (nStrlen < 10)

{
szBuffer += '0';
nStrlen++;
}
}

szSwap = "978";
for (i = 0; i < 9; i++)
szSwap += szBuffer[i];
szBuffer = "";
szBuffer = EAN13(szSwap);

szSwap = "";
if (nCharPos > -1)

{
szSwap += ' ';
szSwap += UPC25SUPP(szRight);
}
return szBuffer + szSwap;
}

/**//*-------------------------------------------Code11---------------------------------------*/

/**//*Converts the input into a valid Code11 symbol. Check digit as well start/stop characters*/

/**//*are added into the input.*/

/**//*----------------------------------------------------------------------------------------*/
public string Code11(string szInpara)

{
int i = 0, nPos, nCheckSumC = 0, nCheckSumK = 0, nStrLen;
string szBuffer = "";
string szSwap = "";
char cCheckDigitC, cCheckDigitK;
string szCharSet = "0123456789-";

while (i < szInpara.Length)

{
nPos = szCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szInpara[i];
i = i + 1;
}

nStrLen = szBuffer.Length;
for (i = 0; i < nStrLen; i++)

{
nPos = szCharSet.IndexOf(szBuffer[nStrLen - i - 1]);
if (nPos >= 0)
nCheckSumC = nCheckSumC + ((i + 1) % 10) * nPos;
}
nCheckSumC = nCheckSumC % 11;
cCheckDigitC = szCharSet[nCheckSumC];
szBuffer += cCheckDigitC;

nStrLen = szBuffer.Length;
if (nStrLen > 11)

{
i = 0;
while (i < szBuffer.Length)

{
nPos = szCharSet.IndexOf(szBuffer[nStrLen - i - 1]);
if (nPos >= 0)
nCheckSumK = nCheckSumK + ((i + 1) % 9) * nPos;
i = i + 1;
}
nCheckSumK = nCheckSumK % 11;
cCheckDigitK = szCharSet[nCheckSumK];
szBuffer += cCheckDigitK;
}

szSwap += '[';
szSwap += szBuffer;
szSwap += ']';
return szSwap;
}

/**//*--------------------------------------MSIMod10------------------------------------------*/

/**//*Converts the input into a valid MSI/Plessey symbol. Check digit is calculated based on */

/**//*Modulo 10 algorithm.*/

/**//*----------------------------------------------------------------------------------------*/
public string MSIMod10(string szInpara)

{
int i = 0, nCheckSum = 0, nStrLen;
string szBuffer = "";
string szSwap = "";
string szNewNo = "";
char cCheckDigit;
int nChoice, nNewNo = 0;

while (i < szInpara.Length)

{
if (szInpara[i] >= '0' && szInpara[i] <= '9')
szBuffer += szInpara[i];
i = i + 1;
}

i = 0;
nStrLen = szBuffer.Length;
nChoice = nStrLen % 2;
while (i < szBuffer.Length)

{
if (i % 2 == nChoice)
nCheckSum = nCheckSum + szBuffer[i] - '0';
else
szNewNo += szBuffer[i];
i = i + 1;
}

i = 0;
nStrLen = szNewNo.Length;
while (i < szNewNo.Length)

{
nNewNo = 10 * nNewNo + szNewNo[i] - '0';
i = i + 1;
}
nNewNo = 2 * nNewNo;
szNewNo = "";
while (nNewNo > 0)

{
szNewNo = (char)((nNewNo % 10) + '0') + szNewNo;
nNewNo = nNewNo / 10;
i = i + 1;
}
i = 0;
while (i < szNewNo.Length)

{
nCheckSum = nCheckSum + szNewNo[i] - '0';
i = i + 1;
}
nCheckSum = nCheckSum % 10;
if (nCheckSum != 0)
nCheckSum = 10 - nCheckSum;
cCheckDigit = (char)(nCheckSum + '0');
szBuffer += cCheckDigit;

szSwap += '[';
szSwap += szBuffer;
szSwap += ']';
return szSwap;
}
private string code128aCharSet()

{
string pSet = "";
int i;
for (i = 32; i <= 95; i++)
pSet += (char)i;
pSet += (char)240;
for (i = 1; i < 32; i++)
pSet += (char)i;
for (i = 193; i < 200; i++)
pSet += (char)i;
return pSet;
}

private string code128bCharSet()

{
string pSet = "";
int i;
for (i = 32; i < 128; i++)
pSet += (char)i;
for (i = 193; i < 200; i++)
pSet += (char)i;
return pSet;
}

private string code128cCharSet()

{
string pSet = "";
int i;
for (i = 0; i < 10; i++)
pSet += (char)(i + '0');
for (i = 192; i < 200; i++)
pSet += (char)i;
return pSet;
}

private string code128MappingSet()

{
string pSet = "";
int i;
pSet += (char)204;
for (i = 33; i < 127; i++)
pSet += (char)i;
for (i = 192; i < 203; i++)
pSet += (char)i;
return pSet;
}

/**//*------------------------------------------ Code128A-------------------------------------*/

/**//*Accepts the input of character set A. Code128 character set consists of capital letters */

/**//*and control characters.*/

/**//*----------------------------------------------------------------------------------------*/
public string Code128A(string szInpara)

{
int i = 0, nPos, nCheckSum = 0;
string szBuffer = "";
string szSwap = "";
char cCheckDigit;
string szCharSet = "", szMappingSet = "";
string szSpecial = "";

szSpecial = SpecialChar(szInpara);
szInpara = szSpecial;

szCharSet = code128aCharSet();
szMappingSet = code128MappingSet();
while (i < szInpara.Length)

{
nPos = szCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szInpara[i];
i = i + 1;
}
nCheckSum = 103;
i = 0;
while (i < szBuffer.Length)

{
nPos = szCharSet.IndexOf(szBuffer[i]);
if (nPos >= 0)

{
szSwap += szMappingSet[nPos];
nCheckSum = nCheckSum + (i + 1) * nPos;
}
i = i + 1;
}
nCheckSum = nCheckSum % 103;
cCheckDigit = szMappingSet[nCheckSum];

szBuffer = "";
szBuffer += (char)200;
szBuffer += szSwap;
szBuffer += cCheckDigit;
szBuffer += (char)203;
szBuffer += (char)205;
return szBuffer;
}

/**//*----------------------------------------Code128B----------------------------------------*/

/**//*Accepts the input of character set B. Code128 character set consist of all printable */

/**//*character s in the ASCII table.*/

/**//*----------------------------------------------------------------------------------------*/
public string Code128B(string szInpara)

{
int i = 0, nPos, nCheckSum = 0;
string szBuffer = "";
string szSwap = "";
char cCheckDigit;
string szCharSet = "", szMappingSet = "\0";

szCharSet = code128bCharSet();
szMappingSet = code128MappingSet();
while (i < szInpara.Length)

{
nPos = szCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szInpara[i];
i = i + 1;
}
nCheckSum = 104;
i = 0;
while (i < szBuffer.Length)

{
nPos = szCharSet.IndexOf(szBuffer[i]);
if (nPos >= 0)

{
szSwap += szMappingSet[nPos];
nCheckSum = nCheckSum + (i + 1) * nPos;
}
i = i + 1;
}
nCheckSum = nCheckSum % 103;
cCheckDigit = szMappingSet[nCheckSum];

szBuffer = "";
szBuffer += (char)201;
szBuffer += szSwap;
szBuffer += cCheckDigit;
szBuffer += (char)203;
szBuffer += (char)205;
return szBuffer;
}

/**//*-------------------------------------------Code128C-------------------------------------*/

/**//*Code128 character set C only contains numeric characters. Used when the encoded data */

/**//*containing only numbers.*/

/**//*----------------------------------------------------------------------------------------*/
public string Code128C(string szInpara)

{
int i = 0, nPos, nStrLen, nCheckSum = 0;
string szBuffer = "";
string szSwap = "";
string szTemp = "";
char cCheckDigit;
string szCharSet = "", szMappingSet = "";

szCharSet = code128cCharSet();
szMappingSet = code128MappingSet();
while (i < szInpara.Length)

{
nPos = szCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szInpara[i];
i = i + 1;
}
nCheckSum = 105;
nStrLen = szBuffer.Length;
if (nStrLen % 2 == 1)
szTemp += '0';
szTemp += szBuffer;

i = 0;
while (i < nStrLen)

{
nPos = 10 * (szTemp[i] - '0') + szTemp[i + 1] - '0';
if (nPos >= 0)
szSwap += szMappingSet[nPos];
i = i + 2;
}
i = 0;
while (i < szSwap.Length)

{
if (szSwap[i] == (char)204)
;
else if (szSwap[i] >= 33 && szSwap[i] < 127)
nCheckSum = nCheckSum + (i + 1) * (szSwap[i] - 32);
else if (szSwap[i] >= 192)
nCheckSum = nCheckSum + (i + 1) * (szSwap[i] - 97);
i = i + 1;
}
nCheckSum = nCheckSum % 103;
cCheckDigit = szMappingSet[nCheckSum];

szBuffer = "";
szBuffer += (char)202;
szBuffer += szSwap;
szBuffer += cCheckDigit;
szBuffer += (char)203;
szBuffer += (char)205;
return szBuffer;
}

/**//*------------------------------------------Code128Auto-----------------------------------*/

/**//*Encode any ASCII characters. It automatically shift to another character set when the */

/**//*encoded character is not found in the current character set.*/

/**//*----------------------------------------------------------------------------------------*/
public string Code128Auto(string szInpara)

{
int i = 0, nPos, nStrLen, nCheckSum = 0;
string szBuffer = "";
string szSwap = "";
char cCheckDigit;
string szCharASet = "", szCharBSet = "", szCharCSet = "", szMappingSet = "";
int nvalue, nWeight;
string pCurCharSet = "";
string szSpecial = "";

szSpecial = SpecialChar(szInpara);
szInpara = szSpecial;

szCharASet = code128aCharSet();
szCharBSet = code128bCharSet();
szCharCSet = code128cCharSet();
szMappingSet = code128MappingSet();
nStrLen = szInpara.Length;
if (szInpara[0] <= 31) pCurCharSet = szCharASet;
if (szInpara[0] >= 32 && szInpara[0] <= 126) pCurCharSet = szCharBSet;
if (nStrLen > 4)

{
i = 0;
while (i < 4)

{
if (szInpara[0] < '0' || szInpara[0] > '9')
break;
i = i + 1;
}
if (i == 4)
pCurCharSet = szCharCSet;
}
if (pCurCharSet == szCharASet)
szBuffer += (char)200;
else if (pCurCharSet == szCharBSet)
szBuffer += (char)201;
else if (pCurCharSet == szCharCSet)
szBuffer += (char)202;

i = 0;
while (i < szInpara.Length)

{
if (szInpara[i] == (char)199)
szBuffer += (char)199;
else if ((i < nStrLen - 4) && IsNumeric(szInpara.Substring(i, 4)) || ((pCurCharSet == szCharCSet) && (i < nStrLen - 1) &&
(IsNumeric(szInpara.Substring(i, 2)))))

{
if (pCurCharSet != szCharCSet)

{
szBuffer += (char)196;
pCurCharSet = szCharCSet;
}
nPos = 10 * (szInpara[i] - '0') + szInpara[i + 1] - '0';
szBuffer += szMappingSet[nPos];
i = i + 1;
}
else if (((i < nStrLen) && (szInpara[i] < 31 || szInpara[i] == 240)) ||
((pCurCharSet == szCharASet) && (szInpara[i] > 32 && szInpara[i] < 96)))

{
if (pCurCharSet != szCharASet)

{
szBuffer += (char)198;
pCurCharSet = szCharASet;
}
nPos = pCurCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szMappingSet[nPos];
}
else if (i < nStrLen && szInpara[i] > 31 && szInpara[i] < 127)

{
if (pCurCharSet != szCharBSet)

{
szBuffer += (char)197;
pCurCharSet = szCharBSet;
}
nPos = pCurCharSet.IndexOf(szInpara[i]);
if (nPos >= 0)
szBuffer += szMappingSet[nPos];
}
i = i + 1;
}

i = 0;
nvalue = 0;
while (i < szBuffer.Length)

{
if (szBuffer[i] == 204)
nvalue = 0;
else if (szBuffer[i] >= 33 && szBuffer[i] <= 126)
nvalue = szBuffer[i] - 32;
else if (szBuffer[i] >= 192)
nvalue = szBuffer[i] - 97;
if (i > 1)
nWeight = i;
else
nWeight = 1;
nCheckSum = nCheckSum + nvalue * nWeight;
i = i + 1;
}
nCheckSum = nCheckSum % 103;
cCheckDigit = szMappingSet[nCheckSum];

szSwap += szBuffer;
szSwap += cCheckDigit;
szSwap += (char)203;
szSwap += (char)205;
return szSwap;
}

/**//*---------------------------------------USPS_EAN128--------------------------------------*/

/**//*Used for 22 digit USPS special services labels such as delivery confirmation in EAN128. */

/**//*This function takes 19 digit input which is made up of the three parts: 2 digit service */

/**//*code, 9 digit customer ID and 8 digit sequential package ID. This function calculates the*/

/**//*check digit (Mod10), add the application identifier 91 as required by the USPS standard,*/

/**//*and format the data with EAN128 standard. */

/**//*----------------------------------------------------------------------------------------*/
public string USPS_EAN128(string szInpara)

{
int i = 0, nLen, charVal = 0, checkSum = 0, weight = 0;
string szTemp = "", szEAN128 = "";
char checkDigit;
while (i < szInpara.Length)

{
if (char.IsNumber(szInpara[i]))
szTemp += szInpara[i];
i++;
}
nLen = szTemp.Length;
if (nLen >= 19)

{
for (i = 0; i < 19; i++)
szEAN128 += szTemp[i];
}
else if (nLen < 19)
szEAN128 = "0000000000000000000";
szEAN128 = "91" + szEAN128;
nLen = szEAN128.Length;
if (nLen != 21)

{
return "";
}

for (i = 0; i < nLen; i++)

{
charVal = szEAN128[nLen - i - 1] - '0';
if ((i + 1) % 2 == 1)
weight = 3;
else
weight = 1;
checkSum = checkSum + charVal * weight;
}
checkSum = checkSum % 10;
if (checkSum == 0)
checkDigit = '0';
else
checkDigit = (char)(10 - checkSum + '0');
return Code128C(szEAN128 + checkDigit);
}

public string USPS_USS128(string szInpara)

{
int i = 0, nLen, charVal = 0, checkSum = 0, weight = 0;
string szTemp = "", szUSS128 = "";
char checkDigit;
while (i < szInpara.Length)

{
if (char.IsNumber(szInpara[i]))
szTemp += szInpara[i];
i++;
}
nLen = szTemp.Length;
if (nLen == 20)

{
for (i = 0; i < 19; i++)
szUSS128 += szTemp[i];
}
else
posted on
2006-08-25 13:01
Vinson
阅读(
969)
评论()
收藏
举报