private IList <IPathShape> AddMoveToShapes(IPathShape pathShape, String[] pathProperties)
{
IList <IPathShape> shapes = new List <IPathShape>();
int argumentCount = 2;
String[] shapeCoordinates = GetShapeCoordinates(pathShape, null, JavaUtil.ArraysCopyOfRange(pathProperties
, 1, 3));
zOperator = new ClosePath(pathShape.IsRelative());
zOperator.SetCoordinates(shapeCoordinates, currentPoint);
pathShape.SetCoordinates(shapeCoordinates, currentPoint);
currentPoint = pathShape.GetEndingPoint();
shapes.Add(pathShape);
IPathShape previousShape = pathShape;
if (pathProperties.Length > 3)
{
for (int index = 3; index < pathProperties.Length; index += argumentCount)
{
if (index + 2 > pathProperties.Length)
{
break;
}
pathShape = pathShape.IsRelative() ? SvgPathShapeFactory.CreatePathShape("l") : SvgPathShapeFactory.CreatePathShape
("L");
shapeCoordinates = GetShapeCoordinates(pathShape, previousShape, JavaUtil.ArraysCopyOfRange(pathProperties
, index, index + 2));
pathShape.SetCoordinates(shapeCoordinates, previousShape.GetEndingPoint());
shapes.Add(pathShape);
previousShape = pathShape;
}
}
return(shapes);
}
/// <summary>Create a list of bounding rectangles from an 8 x n array of Quadpoints.</summary>
/// <param name="quadPoints">8xn array of numbers representing 4 points</param>
/// <returns>a list of bounding rectangles for the passed quadpoints</returns>
/// <exception cref="iText.Kernel.PdfException">if the passed array's size is not a multiple of 8.</exception>
public static IList <iText.Kernel.Geom.Rectangle> CreateBoundingRectanglesFromQuadPoint(PdfArray quadPoints
)
{
IList <iText.Kernel.Geom.Rectangle> boundingRectangles = new List <iText.Kernel.Geom.Rectangle>();
if (quadPoints.Size() % 8 != 0)
{
throw new PdfException(PdfException.QuadPointArrayLengthIsNotAMultipleOfEight);
}
for (int i = 0; i < quadPoints.Size(); i += 8)
{
float[] quadPointEntry = JavaUtil.ArraysCopyOfRange(quadPoints.ToFloatArray(), i, i + 8);
PdfArray quadPointEntryFA = new PdfArray(quadPointEntry);
boundingRectangles.Add(CreateBoundingRectangleFromQuadPoint(quadPointEntryFA));
}
return(boundingRectangles);
}
/// <summary>
/// Gets the coordinates that shall be passed to
/// <see cref="iText.Svg.Renderers.Path.IPathShape.SetCoordinates(System.String[], iText.Kernel.Geom.Point)"/>
/// for the current shape.
/// </summary>
/// <param name="shape">The current shape.</param>
/// <param name="previousShape">The previous shape which can affect the coordinates of the current shape.</param>
/// <param name="pathProperties">
/// The operator and all arguments as a
/// <see>String[]</see>
/// </param>
/// <returns>
/// a
/// <see>String[]</see>
/// of coordinates that shall be passed to
/// <see cref="iText.Svg.Renderers.Path.IPathShape.SetCoordinates(System.String[], iText.Kernel.Geom.Point)"/>
/// </returns>
private String[] GetShapeCoordinates(IPathShape shape, IPathShape previousShape, String[] pathProperties)
{
if (shape is ClosePath)
{
return(null);
}
String[] shapeCoordinates = null;
String[] operatorArgs = JavaUtil.ArraysCopyOfRange(pathProperties, 1, pathProperties.Length);
if (shape is SmoothSCurveTo)
{
String[] startingControlPoint = new String[2];
if (previousShape != null)
{
Point previousEndPoint = previousShape.GetEndingPoint();
//if the previous command was a C or S use its last control point
if (((previousShape is CurveTo)))
{
Point lastControlPoint = ((CurveTo)previousShape).GetLastControlPoint();
float reflectedX = (float)(2 * previousEndPoint.GetX() - lastControlPoint.GetX());
float reflectedY = (float)(2 * previousEndPoint.GetY() - lastControlPoint.GetY());
startingControlPoint[0] = SvgCssUtils.ConvertFloatToString(reflectedX);
startingControlPoint[1] = SvgCssUtils.ConvertFloatToString(reflectedY);
}
else
{
startingControlPoint[0] = SvgCssUtils.ConvertDoubleToString(previousEndPoint.GetX());
startingControlPoint[1] = SvgCssUtils.ConvertDoubleToString(previousEndPoint.GetY());
}
}
else
{
// TODO RND-951
startingControlPoint[0] = pathProperties[1];
startingControlPoint[1] = pathProperties[2];
}
shapeCoordinates = Concatenate(startingControlPoint, operatorArgs);
}
if (shapeCoordinates == null)
{
shapeCoordinates = operatorArgs;
}
return(shapeCoordinates);
}
/// <exception cref="Org.BouncyCastle.Security.SecurityUtilityException"/>
private byte[] ComputeHash(byte[] password, byte[] salt, int saltOffset, int saltLen, byte[] userKey)
{
IDigest mdSha256 = DigestUtilities.GetDigest("SHA-256");
mdSha256.Update(password);
mdSha256.Update(salt, saltOffset, saltLen);
if (userKey != null)
{
mdSha256.Update(userKey);
}
byte[] k = mdSha256.Digest();
if (isPdf2)
{
// See 7.6.4.3.3 "Algorithm 2.B"
IDigest mdSha384 = DigestUtilities.GetDigest("SHA-384");
IDigest mdSha512 = DigestUtilities.GetDigest("SHA-512");
int userKeyLen = userKey != null ? userKey.Length : 0;
int passAndUserKeyLen = password.Length + userKeyLen;
// k1 repetition length
int k1RepLen;
int roundNum = 0;
while (true)
{
// a)
k1RepLen = passAndUserKeyLen + k.Length;
byte[] k1 = new byte[k1RepLen * 64];
Array.Copy(password, 0, k1, 0, password.Length);
Array.Copy(k, 0, k1, password.Length, k.Length);
if (userKey != null)
{
Array.Copy(userKey, 0, k1, password.Length + k.Length, userKeyLen);
}
for (int i = 1; i < 64; ++i)
{
Array.Copy(k1, 0, k1, k1RepLen * i, k1RepLen);
}
// b)
AESCipherCBCnoPad cipher = new AESCipherCBCnoPad(true, JavaUtil.ArraysCopyOf(k, 16), JavaUtil.ArraysCopyOfRange
(k, 16, 32));
byte[] e = cipher.ProcessBlock(k1, 0, k1.Length);
// c)
IDigest md = null;
BigInteger i_1 = new BigInteger(1, JavaUtil.ArraysCopyOf(e, 16));
int remainder = i_1.Remainder(BigInteger.ValueOf(3)).IntValue;
switch (remainder)
{
case 0: {
md = mdSha256;
break;
}
case 1: {
md = mdSha384;
break;
}
case 2: {
md = mdSha512;
break;
}
}
// d)
k = md.Digest(e);
++roundNum;
if (roundNum > 63)
{
// e)
int condVal = e[e.Length - 1] & 0xFF;
// interpreting last byte as unsigned integer
if (condVal <= roundNum - 32)
{
break;
}
}
}
k = k.Length == 32 ? k : JavaUtil.ArraysCopyOf(k, 32);
}
return(k);
}
/// <summary>
/// Processes an individual pathing operator and all of its arguments, converting into one or more
/// <see cref="iText.Svg.Renderers.Path.IPathShape"/>
/// objects.
/// </summary>
/// <param name="pathProperties">
/// The property operator and all arguments as a
/// <see>String[]</see>
/// </param>
/// <param name="previousShape">
/// The previous shape which can affect the positioning of the current shape. If no previous
/// shape exists
/// <see langword="null"/>
/// is passed.
/// </param>
/// <returns>
/// a
/// <see cref="System.Collections.IList{E}"/>
/// of each
/// <see cref="iText.Svg.Renderers.Path.IPathShape"/>
/// that should be drawn to represent the operator.
/// </returns>
private IList <IPathShape> ProcessPathOperator(String[] pathProperties, IPathShape previousShape)
{
IList <IPathShape> shapes = new List <IPathShape>();
if (pathProperties.Length == 0 || String.IsNullOrEmpty(pathProperties[0]) || SvgPathShapeFactory.GetArgumentCount
(pathProperties[0]) < 0)
{
return(shapes);
}
int argumentCount = SvgPathShapeFactory.GetArgumentCount(pathProperties[0]);
if (argumentCount == 0)
{
// closePath operator
if (previousShape == null)
{
throw new SvgProcessingException(SvgLogMessageConstant.INVALID_CLOSEPATH_OPERATOR_USE);
}
shapes.Add(zOperator);
currentPoint = zOperator.GetEndingPoint();
return(shapes);
}
for (int index = 1; index < pathProperties.Length; index += argumentCount)
{
if (index + argumentCount > pathProperties.Length)
{
break;
}
IPathShape pathShape = SvgPathShapeFactory.CreatePathShape(pathProperties[0]);
if (pathShape is MoveTo)
{
shapes.AddAll(AddMoveToShapes(pathShape, pathProperties));
return(shapes);
}
String[] shapeCoordinates = GetShapeCoordinates(pathShape, previousShape, JavaUtil.ArraysCopyOfRange(pathProperties
, index, index + argumentCount));
if (pathShape != null)
{
if (shapeCoordinates != null)
{
pathShape.SetCoordinates(shapeCoordinates, currentPoint);
}
currentPoint = pathShape.GetEndingPoint();
// unsupported operators are ignored.
shapes.Add(pathShape);
}
previousShape = pathShape;
}
return(shapes);
}
private byte[] SubArray(byte[] array, int beg, int end)
{
return(JavaUtil.ArraysCopyOfRange(array, beg, end + 1));
}
private static byte[] ReadImageType(byte[] bytes)
{
return(JavaUtil.ArraysCopyOfRange(bytes, 0, 8));
}
){kind=link}