Haegwang/QRCodeLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
chi
2019-05-04 06:53:50 +09:00
commit cca9ed2bb4
277 changed files with 34473 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
util/Color.cs Normal file
View File

@@ -0,0 +1,23 @@
using System;
namespace ThoughtWorks.QRCode.Codec.Util
{
public struct Color_Fields{
public readonly static int GRAY = 0xAAAAAA;
public readonly static int LIGHTGRAY = 0xBBBBBB;
public readonly static int DARKGRAY = 0x444444;
public readonly static int BLACK = 0x000000;
public readonly static int WHITE = 0xFFFFFF;
public readonly static int BLUE = 0x8888FF;
public readonly static int GREEN = 0x88FF88;
public readonly static int LIGHTBLUE = 0xBBBBFF;
public readonly static int LIGHTGREEN = 0xBBFFBB;
public readonly static int RED = 0xFF88888;
public readonly static int ORANGE = 0xFFFF88;
public readonly static int LIGHTRED = 0xFFBBBB;
}
public interface Color
{
}
}

46
util/ConsoleCanvas.cs Normal file
View File

@@ -0,0 +1,46 @@
using System;
using Line = ThoughtWorks.QRCode.Geom.Line;
using Point = ThoughtWorks.QRCode.Geom.Point;
namespace ThoughtWorks.QRCode.Codec.Util
{
public class ConsoleCanvas : DebugCanvas
{
public void println(String str)
{
Console.WriteLine(str);
}
public void drawPoint(Point point, int color)
{
}
public void drawCross(Point point, int color)
{
}
public void drawPoints(Point[] points, int color)
{
}
public void drawLine(Line line, int color)
{
}
public void drawLines(Line[] lines, int color)
{
}
public void drawPolygon(Point[] points, int color)
{
}
public void drawMatrix(bool[][] matrix)
{
}
}
}

74
util/ContentConverter.cs Normal file
View File

@@ -0,0 +1,74 @@
using System;
namespace ThoughtWorks.QRCode.Codec.Util
{
public class ContentConverter
{
internal static char n = '\n';
public static String convert(String targetString)
{
if (targetString == null)
return targetString;
if (targetString.IndexOf("MEBKM:") > - 1)
targetString = convertDocomoBookmark(targetString);
if (targetString.IndexOf("MECARD:") > - 1)
targetString = convertDocomoAddressBook(targetString);
if (targetString.IndexOf("MATMSG:") > - 1)
targetString = convertDocomoMailto(targetString);
if (targetString.IndexOf("http\\://") > - 1)
targetString = replaceString(targetString, "http\\://", "\nhttp://");
return targetString;
}
private static String convertDocomoBookmark(String targetString)
{
targetString = removeString(targetString, "MEBKM:");
targetString = removeString(targetString, "TITLE:");
targetString = removeString(targetString, ";");
targetString = removeString(targetString, "URL:");
return targetString;
}
private static String convertDocomoAddressBook(String targetString)
{
targetString = removeString(targetString, "MECARD:");
targetString = removeString(targetString, ";");
targetString = replaceString(targetString, "N:", "NAME1:");
targetString = replaceString(targetString, "SOUND:", n + "NAME2:");
targetString = replaceString(targetString, "TEL:", n + "TEL1:");
targetString = replaceString(targetString, "EMAIL:", n + "MAIL1:");
targetString = targetString + n;
return targetString;
}
private static String convertDocomoMailto(String s)
{
String s1 = s;
char c = '\n';
s1 = removeString(s1, "MATMSG:");
s1 = removeString(s1, ";");
s1 = replaceString(s1, "TO:", "MAILTO:");
s1 = replaceString(s1, "SUB:", c + "SUBJECT:");
s1 = replaceString(s1, "BODY:", c + "BODY:");
s1 = s1 + c;
return s1;
}
private static String replaceString(String s, String s1, String s2)
{
String s3 = s;
for (int i = s3.IndexOf(s1, 0); i > - 1; i = s3.IndexOf(s1, i + s2.Length))
s3 = s3.Substring(0, (i) - (0)) + s2 + s3.Substring(i + s1.Length);
return s3;
}
private static String removeString(String s, String s1)
{
return replaceString(s, s1, "");
}
}
}

18
util/DebugCanvas.cs Normal file
View File

@@ -0,0 +1,18 @@
using System;
using Line = ThoughtWorks.QRCode.Geom.Line;
using Point = ThoughtWorks.QRCode.Geom.Point;
namespace ThoughtWorks.QRCode.Codec.Util
{
public interface DebugCanvas
{
void println(String str);
void drawPoint(Point point, int color);
void drawCross(Point point, int color);
void drawPoints(Point[] points, int color);
void drawLine(Line line, int color);
void drawLines(Line[] lines, int color);
void drawPolygon(Point[] points, int color);
void drawMatrix(bool[][] matrix);
}
}

46
util/DebugCanvasAdapter.cs Normal file
View File

@@ -0,0 +1,46 @@
using System;
using Line = ThoughtWorks.QRCode.Geom.Line;
using Point = ThoughtWorks.QRCode.Geom.Point;
namespace ThoughtWorks.QRCode.Codec.Util
{
/*
* This class must be a "edition independent" class for debug information controll.
* I think it's good idea to modify this class with a adapter pattern
*/
public class DebugCanvasAdapter : DebugCanvas
{
public virtual void println(String string_Renamed)
{
}
public virtual void drawPoint(Point point, int color)
{
}
public virtual void drawCross(Point point, int color)
{
}
public virtual void drawPoints(Point[] points, int color)
{
}
public virtual void drawLine(Line line, int color)
{
}
public virtual void drawLines(Line[] lines, int color)
{
}
public virtual void drawPolygon(Point[] points, int color)
{
}
public virtual void drawMatrix(bool[][] matrix)
{
}
}
}

104
util/QRCodeUtility.cs Normal file
View File

@@ -0,0 +1,104 @@
using System;
using System.Text;
namespace ThoughtWorks.QRCode.Codec.Util
{
/*
* This class must be modified as a adapter class for "edition dependent" methods
*/
public class QRCodeUtility
{
// Because CLDC1.0 does not support Math.sqrt(), we have to define it manually.
// faster sqrt (GuoQing Hu's FIX)
public static int sqrt(int val)
{
// using estimate method from http://www.azillionmonkeys.com/qed/sqroot.html
// Console.out.print(val + ", " + (int)Math.sqrt(val) + ", ");
int temp, g = 0, b = 0x8000, bshft = 15;
do
{
if (val >= (temp = (((g << 1) + b) << bshft--)))
{
g += b;
val -= temp;
}
}
while ((b >>= 1) > 0);
return g;
}
// for au by KDDI Profile Phase 3.0
// public static int[][] parseImage(Image image) {
// int width = image.getWidth();
// int height = image.getHeight();
// Image mutable = Image.createImage(width, height);
// Graphics g = mutable.getGraphics();
// g.drawImage(image, 0, 0, Graphics.TOP|Graphics.LEFT);
// ExtensionGraphics eg = (ExtensionGraphics) g;
// int[][] result = new int[width][height];
//
// for (int x = 0; x < width; x++) {
// for (int y = 0; y < height; y++) {
// result[x][y] = eg.getPixel(x, y);
// }
// }
// return result;
// }
//
// public static int[][] parseImage(byte[] imageData) {
// return parseImage(Image.createImage(imageData, 0, imageData.length));
// }
public static bool IsUniCode(String value)
{
byte[] ascii = AsciiStringToByteArray(value);
byte[] unicode = UnicodeStringToByteArray(value);
string value1 = FromASCIIByteArray(ascii);
string value2 = FromUnicodeByteArray(unicode);
if (value1 != value2)
return true;
return false;
}
public static bool IsUnicode(byte[] byteData)
{
string value1 = FromASCIIByteArray(byteData);
string value2 = FromUnicodeByteArray(byteData);
byte[] ascii = AsciiStringToByteArray(value1);
byte[] unicode = UnicodeStringToByteArray(value2);
if (ascii[0] != unicode[0])
return true;
return false;
}
public static String FromASCIIByteArray(byte[] characters)
{
ASCIIEncoding encoding = new ASCIIEncoding();
String constructedString = encoding.GetString(characters);
return constructedString;
}
public static String FromUnicodeByteArray(byte[] characters)
{
UnicodeEncoding encoding = new UnicodeEncoding();
String constructedString = encoding.GetString(characters);
return constructedString;
}
public static byte[] AsciiStringToByteArray(String str)
{
ASCIIEncoding encoding = new ASCIIEncoding();
return encoding.GetBytes(str);
}
public static byte[] UnicodeStringToByteArray(String str)
{
UnicodeEncoding encoding = new UnicodeEncoding();
return encoding.GetBytes(str);
}
}
}

208
util/SystemUtils.cs Normal file
View File

@@ -0,0 +1,208 @@
using System;
namespace ThoughtWorks.QRCode.Codec.Util
{
/// <summary>
/// Contains conversion support elements such as classes, interfaces and static methods.
/// </summary>
public class SystemUtils
{
/// <summary>Reads a number of characters from the current source Stream and writes the data to the target array at the specified index.</summary>
/// <param name="sourceStream">The source Stream to read from.</param>
/// <param name="target">Contains the array of characteres read from the source Stream.</param>
/// <param name="start">The starting index of the target array.</param>
/// <param name="count">The maximum number of characters to read from the source Stream.</param>
/// <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source Stream. Returns -1 if the end of the stream is reached.</returns>
public static System.Int32 ReadInput(System.IO.Stream sourceStream, sbyte[] target, int start, int count)
{
// Returns 0 bytes if not enough space in target
if (target.Length == 0)
return 0;
byte[] receiver = new byte[target.Length];
int bytesRead = sourceStream.Read(receiver, start, count);
// Returns -1 if EOF
if (bytesRead == 0)
return -1;
for (int i = start; i < start + bytesRead; i++)
target[i] = (sbyte)receiver[i];
return bytesRead;
}
/// <summary>Reads a number of characters from the current source TextReader and writes the data to the target array at the specified index.</summary>
/// <param name="sourceTextReader">The source TextReader to read from</param>
/// <param name="target">Contains the array of characteres read from the source TextReader.</param>
/// <param name="start">The starting index of the target array.</param>
/// <param name="count">The maximum number of characters to read from the source TextReader.</param>
/// <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source TextReader. Returns -1 if the end of the stream is reached.</returns>
public static System.Int32 ReadInput(System.IO.TextReader sourceTextReader, short[] target, int start, int count)
{
// Returns 0 bytes if not enough space in target
if (target.Length == 0) return 0;
char[] charArray = new char[target.Length];
int bytesRead = sourceTextReader.Read(charArray, start, count);
// Returns -1 if EOF
if (bytesRead == 0) return -1;
for (int index = start; index < start + bytesRead; index++)
target[index] = (short)charArray[index];
return bytesRead;
}
/*******************************/
/// <summary>
/// Writes the exception stack trace to the received stream
/// </summary>
/// <param name="throwable">Exception to obtain information from</param>
/// <param name="stream">Output sream used to write to</param>
public static void WriteStackTrace(System.Exception throwable, System.IO.TextWriter stream)
{
stream.Write(throwable.StackTrace);
stream.Flush();
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static int URShift(int number, int bits)
{
if (number >= 0)
return number >> bits;
else
return (number >> bits) + (2 << ~bits);
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static int URShift(int number, long bits)
{
return URShift(number, (int)bits);
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static long URShift(long number, int bits)
{
if (number >= 0)
return number >> bits;
else
return (number >> bits) + (2L << ~bits);
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static long URShift(long number, long bits)
{
return URShift(number, (int)bits);
}
/*******************************/
/// <summary>
/// Converts an array of sbytes to an array of bytes
/// </summary>
/// <param name="sbyteArray">The array of sbytes to be converted</param>
/// <returns>The new array of bytes</returns>
public static byte[] ToByteArray(sbyte[] sbyteArray)
{
byte[] byteArray = null;
if (sbyteArray != null)
{
byteArray = new byte[sbyteArray.Length];
for (int index = 0; index < sbyteArray.Length; index++)
byteArray[index] = (byte)sbyteArray[index];
}
return byteArray;
}
/// <summary>
/// Converts a string to an array of bytes
/// </summary>
/// <param name="sourceString">The string to be converted</param>
/// <returns>The new array of bytes</returns>
public static byte[] ToByteArray(String sourceString)
{
return System.Text.UTF8Encoding.UTF8.GetBytes(sourceString);
}
/// <summary>
/// Converts a array of object-type instances to a byte-type array.
/// </summary>
/// <param name="tempObjectArray">Array to convert.</param>
/// <returns>An array of byte type elements.</returns>
public static byte[] ToByteArray(System.Object[] tempObjectArray)
{
byte[] byteArray = null;
if (tempObjectArray != null)
{
byteArray = new byte[tempObjectArray.Length];
for (int index = 0; index < tempObjectArray.Length; index++)
byteArray[index] = (byte)tempObjectArray[index];
}
return byteArray;
}
/*******************************/
/// <summary>
/// Receives a byte array and returns it transformed in an sbyte array
/// </summary>
/// <param name="byteArray">Byte array to process</param>
/// <returns>The transformed array</returns>
public static sbyte[] ToSByteArray(byte[] byteArray)
{
sbyte[] sbyteArray = null;
if (byteArray != null)
{
sbyteArray = new sbyte[byteArray.Length];
for (int index = 0; index < byteArray.Length; index++)
sbyteArray[index] = (sbyte)byteArray[index];
}
return sbyteArray;
}
/*******************************/
/// <summary>
/// Converts an array of sbytes to an array of chars
/// </summary>
/// <param name="sByteArray">The array of sbytes to convert</param>
/// <returns>The new array of chars</returns>
public static char[] ToCharArray(sbyte[] sByteArray)
{
return System.Text.UTF8Encoding.UTF8.GetChars(ToByteArray(sByteArray));
}
/// <summary>
/// Converts an array of bytes to an array of chars
/// </summary>
/// <param name="byteArray">The array of bytes to convert</param>
/// <returns>The new array of chars</returns>
public static char[] ToCharArray(byte[] byteArray)
{
return System.Text.UTF8Encoding.UTF8.GetChars(byteArray);
}
}
}