shu
/
OnDoc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'bf8e19e19f'
${ noResults }
OnDoc/BarcodeLib/Barcoded/Code128Encoder.cs

717 lines
32 KiB
Raw Blame History

using System;
using System.Collections.Generic;
namespace Barcoded
{
/// <summary>
/// Code 128 & GS1-128 barcode encoder.
/// </summary>
internal class Code128Encoder : LinearEncoder
{
private Dictionary<string, int> _symbologyCharEncode;
private Dictionary<int, LinearPattern> _patternDictionary;
private int _checkDigit;
private readonly bool _suppressSubsetC;
private readonly bool _isGs1;
private Code128Subset StartSubset { get; }
public Code128Encoder(Symbology symbology) : base(symbology)
{
switch (Symbology)
{
case Symbology.Code128ABC:
_suppressSubsetC = false;
StartSubset = Code128Subset.A;
Description = "Code 128 - Subset A Prioritised & Auto Subset C Selected";
break;
case Symbology.Code128BAC:
_suppressSubsetC = false;
StartSubset = Code128Subset.B;
Description = "Code 128 - Subset B Prioritised & Auto Subset C Selected";
break;
case Symbology.Code128AB:
_suppressSubsetC = true;
StartSubset = Code128Subset.A;
Description = "Code 128 - Subset A Prioritised & Subset C Suppressed";
break;
case Symbology.Code128BA:
_suppressSubsetC = true;
StartSubset = Code128Subset.B;
Description = "Code 128 - Subset B Prioritised & Subset C Suppressed";
break;
case Symbology.GS1128:
_suppressSubsetC = false;
_isGs1 = true;
StartSubset = Code128Subset.B;
Description = "GS1-128 - Subset B Prioritised & Auto Subset C Selected";
break;
default:
_suppressSubsetC = false;
StartSubset = Code128Subset.B;
Description = "Code 128 - Subset B Prioritised & Auto Subset C Selected";
break;
}
}
internal override ILinearValidator BarcodeValidator { get; } = new Code128Validator();
protected override void Encode(string barcodeValue)
{
ZplEncode = "";
LoadCode128Symbology();
LoadSymbologyPattern();
AnalyseSection(barcodeValue, 0, Code128Subset.Null);
}
/// <summary>
/// Analyse the supplied section and determine the appropriate encoding.
/// </summary>
/// <param name="barcodeValue"></param>
/// <param name="startPosition"></param>
/// <param name="lastSubset"></param>
private void AnalyseSection(string barcodeValue, int startPosition, Code128Subset lastSubset)
{
Code128Subset currentSubset = Code128Subset.Null;
bool isNewSection = false;
for (int position = startPosition; position <= barcodeValue.Length - 1; position++)
{
isNewSection = true;
int asciiCode = barcodeValue[position];
switch (asciiCode)
{
case var code when code <= 31: // Control characters that are only supported by subset A.
if (currentSubset == Code128Subset.Null | currentSubset == Code128Subset.A)
{
currentSubset = Code128Subset.A;
}
else
{
EncodeSection(lastSubset, currentSubset, barcodeValue.Substring(startPosition, position - startPosition));
AnalyseSection(barcodeValue, position, currentSubset);
return;
}
break;
case var code when code >= 96: // Lower case characters that are only supported by subset C
if (currentSubset == Code128Subset.Null | currentSubset == Code128Subset.B)
{
currentSubset = Code128Subset.B;
}
else
{
EncodeSection(lastSubset, currentSubset, barcodeValue.Substring(startPosition, position - startPosition));
AnalyseSection(barcodeValue, position, currentSubset);
return;
}
break;
case var code when code >= 48 && code <= 57: // Numeric characters, that may benefit from using subset C.
if (_suppressSubsetC)
{
break;
}
int subsetCSequence = GetSubsetCSequenceCount(barcodeValue, position);
if (subsetCSequence >= 1)
{
if (position >= 1)
{
if (currentSubset == Code128Subset.Null)
{
currentSubset = StartSubset;
}
EncodeSection(lastSubset, currentSubset, barcodeValue.Substring(startPosition, position - startPosition));
lastSubset = currentSubset;
}
currentSubset = Code128Subset.C;
EncodeSection(lastSubset, currentSubset, barcodeValue.Substring(position, subsetCSequence));
AnalyseSection(barcodeValue, position + subsetCSequence, currentSubset);
return;
}
break;
}
}
if (isNewSection)
{
if (currentSubset == Code128Subset.Null)
{
currentSubset = StartSubset;
}
EncodeSection(lastSubset, currentSubset, barcodeValue.Substring(startPosition, barcodeValue.Length - startPosition));
}
AddCheckDigit();
AddStopSymbol();
SetMinXDimension();
SetMinBarcodeHeight();
}
/// <summary>
/// Gets the count of numeric pairs to be used in Subset-C encoding
/// </summary>
/// <param name="barcodeValue"></param>
/// <param name="startPosition"></param>
/// <returns>Number of concurrent digits.</returns>
private static int GetSubsetCSequenceCount(string barcodeValue, int startPosition)
{
int numberSequenceCount = 0;
bool startSubsetC = false;
bool endSubsetC = false;
int returnCount = 0;
for (int position = startPosition; position <= barcodeValue.Length - 1; position++)
{
if (position == 0)
{
startSubsetC = true;
}
if (position == barcodeValue.Length - 1)
{
endSubsetC = true;
}
int asciiCode = barcodeValue[position];
if (asciiCode >= 48 && asciiCode <= 57)
{
numberSequenceCount += 1;
}
else
{
break;
}
}
if (startSubsetC && endSubsetC && (numberSequenceCount % 2) == 0) // The complete barcode should be encoded as subset C
{
returnCount = numberSequenceCount;
}
else if (startSubsetC && numberSequenceCount >= 4) // The first subset to be used is subset C
{
returnCount = numberSequenceCount - (numberSequenceCount % 2);
}
else if (endSubsetC && numberSequenceCount >= 4 && (numberSequenceCount % 2) == 0) // The last subset to be used is subset C
{
returnCount = numberSequenceCount;
}
else if (numberSequenceCount >= 6 && (numberSequenceCount % 2) == 0) // Subset C should be used in-between A or B subsets
{
returnCount = numberSequenceCount;
}
return returnCount;
}
/// <summary>
/// Adds the supplied section and control characters to the encode.
/// </summary>
/// <param name="lastSubset"></param>
/// <param name="sectionSubset"></param>
/// <param name="sectionValue"></param>
public void EncodeSection(Code128Subset lastSubset, Code128Subset sectionSubset, string sectionValue)
{
// Add the subset select or change control symbol to the encode
string character = GetSubsetAsString(sectionSubset);
int symbol = _symbologyCharEncode[GetSubsetAsString(lastSubset) + GetSubsetAsString(sectionSubset)];
LinearPattern symbolPattern = _patternDictionary[symbol];
AddSymbolToEncode(character, 1, symbol, symbolPattern);
ZplEncode += GetZplFunction(GetSubsetAsString(lastSubset) + GetSubsetAsString(sectionSubset));
// Add FNC1 symbol if GS1-128 Barcode
if (lastSubset == Code128Subset.Null && _isGs1)
{
symbol = _symbologyCharEncode["FNC1"];
symbolPattern = _patternDictionary[symbol];
AddSymbolToEncode("F1", 1, symbol, symbolPattern);
ZplEncode += GetZplFunction("FNC1");
}
if (sectionSubset == Code128Subset.C) //Subset C encoder
{
for (int encodePosition = 0; encodePosition <= sectionValue.Length - 1; encodePosition += 2)
{
// Encode the current numeric pair symbol
character = sectionValue.Substring(encodePosition, 2);
symbol = Convert.ToInt32(character);
symbolPattern = _patternDictionary[symbol];
AddSymbolToEncode(character, 0, symbol, symbolPattern);
ZplEncode += character;
}
}
else
{
for (int encodePosition = 0; encodePosition <= sectionValue.Length - 1; encodePosition++)
{
character = sectionValue.Substring(encodePosition, 1);
symbol = _symbologyCharEncode[((int)sectionValue[encodePosition]).ToString()];
symbolPattern = _patternDictionary[symbol];
AddSymbolToEncode(character, 0, symbol, symbolPattern);
if (sectionSubset == Code128Subset.A)
{
string subsetACode = "0" + symbol.ToString();
ZplEncode += subsetACode.Substring(subsetACode.Length - 2, 2);
}
else
{
ZplEncode += character;
}
}
}
}
/// <summary>
/// Adds the check digit to the encode.
/// </summary>
private void AddCheckDigit()
{
// Return if no symbols have been encoded.
if (LinearEncoding.Symbols.Count == 0)
{
return;
}
_checkDigit = _checkDigit % 103;
LinearPattern symbolPattern = _patternDictionary[_checkDigit];
AddSymbolToEncode(_checkDigit.ToString(), 1, _checkDigit, symbolPattern);
}
/// <summary>
/// Adds the stop symbol to the encode.
/// </summary>
private void AddStopSymbol()
{
// Return if no symbols have been encoded.
if (LinearEncoding.Symbols.Count == 0)
{
return;
}
string character = "S";
int symbol = _symbologyCharEncode[character];
LinearPattern symbolPattern = _patternDictionary[symbol];
AddSymbolToEncode(character, 1, symbol, symbolPattern);
}
/// <summary>
/// Adds the given symbol to the encode.
/// </summary>
/// <param name="character"></param>
/// <param name="characterType"></param>
/// <param name="symbol"></param>
/// <param name="symbolPattern"></param>
private void AddSymbolToEncode(string character, int characterType, int symbol, LinearPattern symbolPattern)
{
int barcodePosition = LinearEncoding.Symbols.Count;
LinearEncoding.Add(character, characterType, symbolPattern);
if (barcodePosition == 0)
{
_checkDigit = symbol;
}
else
{
_checkDigit += (barcodePosition * symbol);
}
}
/// <summary>
/// Increases the barcode Xdimension to minimum required by symbology, if currently set lower
/// </summary>
internal override void SetMinXDimension()
{
int xDimensionOriginal = XDimension;
int minXDimension = (int)Math.Ceiling(Dpi * 0.0075);
XDimension = Math.Max(XDimension, minXDimension);
// Set flag to show xdimension was adjusted
if(xDimensionOriginal != XDimension)
{
XDimensionChanged = true;
}
}
/// <summary>
/// Increases the barcode height to minimum required by symbology, if currently set lower
/// </summary>
internal override void SetMinBarcodeHeight()
{
int barcodeHeightOriginal = BarcodeHeight;
int minBarcodeHeight = (int)Math.Ceiling(Math.Max(LinearEncoding.MinimumWidth * XDimension * 0.15, Dpi * 0.25));
BarcodeHeight = Math.Max(BarcodeHeight, minBarcodeHeight);
// Set flag to show barcode height was adjusted
if (barcodeHeightOriginal != BarcodeHeight)
{
BarcodeHeightChanged = true;
}
}
/// <summary>
/// Get the Code 128 subset as a string
/// </summary>
/// <param name="subset"></param>
/// <returns>Single character subset string</returns>
private string GetSubsetAsString(Code128Subset subset)
{
switch (subset)
{
case Code128Subset.A:
return "A";
case Code128Subset.B:
return "B";
case Code128Subset.C:
return "C";
case Code128Subset.Null:
return "";
}
throw new ArgumentException(subset + " is not a recognised Code128 subset", nameof(subset));
}
/// <summary>
/// Load the Code 128 symbology ASCII mapping into memory.
/// </summary>
private void LoadCode128Symbology()
{
if (_symbologyCharEncode != null)
{
return;
}
_symbologyCharEncode = new Dictionary<string, int>
{
{"0", 64}, // NUL
{"1", 65}, // SOH
{"2", 66}, // STX
{"3", 67}, // ETX
{"4", 68}, // EOT
{"5", 69}, // ENQ
{"6", 70}, // ACK
{"7", 71}, // BEL
{"8", 72}, // BS
{"9", 73}, // TAB
{"10", 74}, // LF
{"11", 75}, // VT
{"12", 76}, // FF
{"13", 77}, // CR
{"14", 78}, // SOH
{"15", 79}, // SI
{"16", 80}, // DLE
{"17", 81}, // DC1
{"18", 82}, // DC2
{"19", 83}, // DC3
{"20", 84}, // DC4
{"21", 85}, // NAK
{"22", 86}, // SYN
{"23", 87}, // ETB
{"24", 88}, // CAN
{"25", 89}, // EM
{"26", 90}, // SUB
{"27", 91}, // ESC
{"28", 92}, // FS
{"29", 93}, // GS
{"30", 94}, // RS
{"31", 95}, // US
{"32", 0}, // SPACE
{"33", 1}, // !
{"34", 2}, // "
{"35", 3}, // #
{"36", 4}, // $
{"37", 5}, // %
{"38", 6}, // &
{"39", 7}, // '
{"40", 8}, // (
{"41", 9}, // )
{"42", 10}, // *
{"43", 11}, // +
{"44", 12}, // ,
{"45", 13}, // -
{"46", 14}, // .
{"47", 15}, // /
{"48", 16}, // 0
{"49", 17}, // 1
{"50", 18}, // 2
{"51", 19}, // 3
{"52", 20}, // 4
{"53", 21}, // 5
{"54", 22}, // 6
{"55", 23}, // 7
{"56", 24}, // 8
{"57", 25}, // 9
{"58", 26}, // :
{"59", 27}, // ;
{"60", 28}, // <
{"61", 29}, // =
{"62", 30}, // >
{"63", 31}, // ?
{"64", 32}, // @
{"65", 33}, // A
{"66", 34}, // B
{"67", 35}, // C
{"68", 36}, // D
{"69", 37}, // E
{"70", 38}, // F
{"71", 39}, // G
{"72", 40}, // H
{"73", 41}, // I
{"74", 42}, // J
{"75", 43}, // K
{"76", 44}, // L
{"77", 45}, // M
{"78", 46}, // N
{"79", 47}, // O
{"80", 48}, // P
{"81", 49}, // Q
{"82", 50}, // R
{"83", 51}, // S
{"84", 52}, // T
{"85", 53}, // U
{"86", 54}, // V
{"87", 55}, // W
{"88", 56}, // X
{"89", 57}, // Y
{"90", 58}, // Z
{"91", 59}, // [
{"92", 60}, // \
{"93", 61}, // ]
{"94", 62}, // ^
{"95", 63}, // _
{"96", 64}, // `
{"97", 65}, // a
{"98", 66}, // b
{"99", 67}, // c
{"100", 68}, // d
{"101", 69}, // e
{"102", 70}, // f
{"103", 71}, // g
{"104", 72}, // h
{"105", 73}, // i
{"106", 74}, // j
{"107", 75}, // k
{"108", 76}, // l
{"109", 77}, // m
{"110", 78}, // n
{"111", 79}, // o
{"112", 80}, // p
{"113", 81}, // q
{"114", 82}, // r
{"115", 83}, // s
{"116", 84}, // t
{"117", 85}, // u
{"118", 86}, // v
{"119", 87}, // w
{"120", 88}, // x
{"121", 89}, // y
{"122", 90}, // z
{"123", 91}, // {
{"124", 92}, // |
{"125", 93}, // }
{"126", 94}, // ~
{"127", 95}, // DEL
{"SAB", 98}, // SHIFT B
{"SBA", 98}, // SHIFT A
{"AC", 99}, // SHIFT C
{"BC", 99}, // SHIFT C
{"AB", 100}, // SHIFT B
{"CB", 100}, // SHIFT B
{"BA", 101}, // SHIFT A
{"CA", 101}, // SHIFT A
{"FNC1", 102}, // FNC1
{"A", 103}, // START A
{"B", 104}, // START B
{"C", 105}, // START C
{"S", 106} // STOP
};
}
/// <summary>
/// Load the Code 128 character to pattern mapping into memory.
/// </summary>
private void LoadSymbologyPattern()
{
if (_patternDictionary != null)
{
return;
}
_patternDictionary = new Dictionary<int, LinearPattern>
{ // A | B | C
{0, new LinearPattern("212222", ModuleType.Bar)}, // SPACE | SPACE | 00
{1, new LinearPattern("222122", ModuleType.Bar)}, // ! | ! | 01
{2, new LinearPattern("222221", ModuleType.Bar)}, // " | " | 02
{3, new LinearPattern("121223", ModuleType.Bar)}, // # | # | 03
{4, new LinearPattern("121322", ModuleType.Bar)}, // $ | $ | 04
{5, new LinearPattern("131222", ModuleType.Bar)}, // % | % | 05
{6, new LinearPattern("122213", ModuleType.Bar)}, // & | & | 06
{7, new LinearPattern("122312", ModuleType.Bar)}, // ' | ' | 07
{8, new LinearPattern("132212", ModuleType.Bar)}, // ( | ( | 08
{9, new LinearPattern("221213", ModuleType.Bar)}, // ) | ) | 09
{10, new LinearPattern("221312", ModuleType.Bar)}, // * | * | 10
{11, new LinearPattern("231212", ModuleType.Bar)}, // + | + | 11
{12, new LinearPattern("112232", ModuleType.Bar)}, // , | , | 12
{13, new LinearPattern("122132", ModuleType.Bar)}, // - | - | 13
{14, new LinearPattern("122231", ModuleType.Bar)}, // . | . | 14
{15, new LinearPattern("113222", ModuleType.Bar)}, // / | / | 15
{16, new LinearPattern("123122", ModuleType.Bar)}, // 0 | 0 | 16
{17, new LinearPattern("123221", ModuleType.Bar)}, // 1 | 1 | 17
{18, new LinearPattern("223211", ModuleType.Bar)}, // 2 | 2 | 18
{19, new LinearPattern("221132", ModuleType.Bar)}, // 3 | 3 | 19
{20, new LinearPattern("221231", ModuleType.Bar)}, // 4 | 4 | 20
{21, new LinearPattern("213212", ModuleType.Bar)}, // 5 | 5 | 21
{22, new LinearPattern("223112", ModuleType.Bar)}, // 6 | 6 | 22
{23, new LinearPattern("312131", ModuleType.Bar)}, // 7 | 7 | 23
{24, new LinearPattern("311222", ModuleType.Bar)}, // 8 | 8 | 24
{25, new LinearPattern("321122", ModuleType.Bar)}, // 9 | 9 | 25
{26, new LinearPattern("321221", ModuleType.Bar)}, // : | : | 26
{27, new LinearPattern("312212", ModuleType.Bar)}, // ; | ; | 27
{28, new LinearPattern("322112", ModuleType.Bar)}, // < | < | 28
{29, new LinearPattern("322211", ModuleType.Bar)}, // = | = | 29
{30, new LinearPattern("212123", ModuleType.Bar)}, // > | > | 30
{31, new LinearPattern("212321", ModuleType.Bar)}, // ? | ? | 31
{32, new LinearPattern("232121", ModuleType.Bar)}, // @ | @ | 32
{33, new LinearPattern("111323", ModuleType.Bar)}, // A | A | 33
{34, new LinearPattern("131123", ModuleType.Bar)}, // B | B | 34
{35, new LinearPattern("131321", ModuleType.Bar)}, // C | C | 35
{36, new LinearPattern("112313", ModuleType.Bar)}, // D | D | 36
{37, new LinearPattern("132113", ModuleType.Bar)}, // E | E | 37
{38, new LinearPattern("132311", ModuleType.Bar)}, // F | F | 38
{39, new LinearPattern("211313", ModuleType.Bar)}, // G | G | 39
{40, new LinearPattern("231113", ModuleType.Bar)}, // H | H | 40
{41, new LinearPattern("231311", ModuleType.Bar)}, // I | I | 41
{42, new LinearPattern("112133", ModuleType.Bar)}, // J | J | 42
{43, new LinearPattern("112331", ModuleType.Bar)}, // K | K | 43
{44, new LinearPattern("132131", ModuleType.Bar)}, // L | L | 44
{45, new LinearPattern("113123", ModuleType.Bar)}, // M | M | 45
{46, new LinearPattern("113321", ModuleType.Bar)}, // N | N | 46
{47, new LinearPattern("133121", ModuleType.Bar)}, // O | O | 47
{48, new LinearPattern("313121", ModuleType.Bar)}, // P | P | 48
{49, new LinearPattern("211331", ModuleType.Bar)}, // Q | Q | 49
{50, new LinearPattern("231131", ModuleType.Bar)}, // R | R | 50
{51, new LinearPattern("213113", ModuleType.Bar)}, // S | S | 51
{52, new LinearPattern("213311", ModuleType.Bar)}, // T | T | 52
{53, new LinearPattern("213131", ModuleType.Bar)}, // U | U | 53
{54, new LinearPattern("311123", ModuleType.Bar)}, // V | V | 54
{55, new LinearPattern("311321", ModuleType.Bar)}, // W | W | 55
{56, new LinearPattern("331121", ModuleType.Bar)}, // X | X | 56
{57, new LinearPattern("312113", ModuleType.Bar)}, // Y | Y | 57
{58, new LinearPattern("312311", ModuleType.Bar)}, // Z | Z | 58
{59, new LinearPattern("332111", ModuleType.Bar)}, // [ | [ | 59
{60, new LinearPattern("314111", ModuleType.Bar)}, // \ | \ | 60
{61, new LinearPattern("221411", ModuleType.Bar)}, // ] | ] | 61
{62, new LinearPattern("431111", ModuleType.Bar)}, // ^ | ^ | 62
{63, new LinearPattern("111224", ModuleType.Bar)}, // _ | _ | 63
{64, new LinearPattern("111422", ModuleType.Bar)}, // NUL | ` | 64
{65, new LinearPattern("121124", ModuleType.Bar)}, // SOH | a | 65
{66, new LinearPattern("121421", ModuleType.Bar)}, // STX | b | 66
{67, new LinearPattern("141122", ModuleType.Bar)}, // ETX | c | 67
{68, new LinearPattern("141221", ModuleType.Bar)}, // EOT | d | 68
{69, new LinearPattern("112214", ModuleType.Bar)}, // ENQ | e | 69
{70, new LinearPattern("112412", ModuleType.Bar)}, // ACK | f | 70
{71, new LinearPattern("122114", ModuleType.Bar)}, // BEL | g | 71
{72, new LinearPattern("122411", ModuleType.Bar)}, // BS | h | 72
{73, new LinearPattern("142112", ModuleType.Bar)}, // HT | i | 73
{74, new LinearPattern("142211", ModuleType.Bar)}, // LF | j | 74
{75, new LinearPattern("241211", ModuleType.Bar)}, // VT | k | 75
{76, new LinearPattern("221114", ModuleType.Bar)}, // FF | l | 76
{77, new LinearPattern("413111", ModuleType.Bar)}, // CR | m | 77
{78, new LinearPattern("241112", ModuleType.Bar)}, // SO | n | 78
{79, new LinearPattern("134111", ModuleType.Bar)}, // SI | o | 79
{80, new LinearPattern("111242", ModuleType.Bar)}, // DLE | p | 80
{81, new LinearPattern("121142", ModuleType.Bar)}, // DC1 | q | 81
{82, new LinearPattern("121241", ModuleType.Bar)}, // DC2 | r | 82
{83, new LinearPattern("114212", ModuleType.Bar)}, // DC3 | s | 83
{84, new LinearPattern("124112", ModuleType.Bar)}, // DC4 | t | 84
{85, new LinearPattern("124211", ModuleType.Bar)}, // NAK | u | 85
{86, new LinearPattern("411212", ModuleType.Bar)}, // SYN | v | 86
{87, new LinearPattern("421112", ModuleType.Bar)}, // ETB | w | 87
{88, new LinearPattern("421211", ModuleType.Bar)}, // CAN | x | 88
{89, new LinearPattern("212141", ModuleType.Bar)}, // EM | y | 89
{90, new LinearPattern("214121", ModuleType.Bar)}, // SUB | z | 90
{91, new LinearPattern("412121", ModuleType.Bar)}, // ESC | { | 91
{92, new LinearPattern("111143", ModuleType.Bar)}, // FS | | | 92
{93, new LinearPattern("111341", ModuleType.Bar)}, // GS | } | 93
{94, new LinearPattern("131141", ModuleType.Bar)}, // RS | ~ | 94
{95, new LinearPattern("114113", ModuleType.Bar)}, // US | DEL | 95
{96, new LinearPattern("114311", ModuleType.Bar)}, // FNC 3 | FNC 3 | 96
{97, new LinearPattern("411113", ModuleType.Bar)}, // FNC 2 | FNC 2 | 97
{98, new LinearPattern("411311", ModuleType.Bar)}, // SHIFT B | SHIFT A | 98
{99, new LinearPattern("113141", ModuleType.Bar)}, // CODE C | CODE C | 99
{100, new LinearPattern("114131", ModuleType.Bar)}, // CODE B | FNC 4 | CODE B
{101, new LinearPattern("311141", ModuleType.Bar)}, // FNC 4 | CODE A | CODE A
{102, new LinearPattern("411131", ModuleType.Bar)}, // FNC 1 | FNC 1 | FNC 1
{103, new LinearPattern("211412", ModuleType.Bar)}, // START CODE A
{104, new LinearPattern("211214", ModuleType.Bar)}, // START CODE B
{105, new LinearPattern("211232", ModuleType.Bar)}, // START CODE C
{106, new LinearPattern("2331112", ModuleType.Bar)} // STOP
};
}
/// <summary>
/// Gets the ZPL string for the given control character.
/// </summary>
/// <param name="controlCharacter"></param>
/// <returns></returns>
private static string GetZplFunction(string controlCharacter)
{
switch (controlCharacter)
{
case "SAB": // START A
return ">9";
case "SBA": // START B
return ">:";
case "AC": // SHIFT A to C
return ">5";
case "BC": // SHIFT B to C
return ">5";
case "AB": // SHIFT A to B
return ">6";
case "CB": // SHIFT C to B
return ">6";
case "BA": // SHIFT B to A
return ">7";
case "CA": // SHIFT C to A
return ">7";
case "A": // START A
return ">9";
case "B": // START B
return ">:";
case "C": // START C
return ">;";
case "FNC1": // FNC1 - GS1
return ">8";
default:
return "";
}
}
}
}
Reference in new issue View Git Blame Copy Permalink