/// <summary>
/// Renders the matrix code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XPoint position)
{
XGraphicsState state = gfx.Save();
switch (Direction)
{
case CodeDirection.RightToLeft:
gfx.RotateAtTransform(180, position);
break;
case CodeDirection.TopToBottom:
gfx.RotateAtTransform(90, position);
break;
case CodeDirection.BottomToTop:
gfx.RotateAtTransform(-90, position);
break;
}
XPoint pos = position + CalcDistance(Anchor, AnchorType.TopLeft, Size);
if (MatrixImage == null)
MatrixImage = DataMatrixImage.GenerateMatrixImage(Text, Encoding, Rows, Columns);
if (QuietZone > 0)
{
XSize sizeWithZone = new XSize(Size.Width, Size.Height);
sizeWithZone.Width = sizeWithZone.Width / (Columns + 2 * QuietZone) * Columns;
sizeWithZone.Height = sizeWithZone.Height / (Rows + 2 * QuietZone) * Rows;
XPoint posWithZone = new XPoint(pos.X, pos.Y);
posWithZone.X += Size.Width / (Columns + 2 * QuietZone) * QuietZone;
posWithZone.Y += Size.Height / (Rows + 2 * QuietZone) * QuietZone;
gfx.DrawRectangle(XBrushes.White, pos.X, pos.Y, Size.Width, Size.Height);
gfx.DrawImage(MatrixImage, posWithZone.X, posWithZone.Y, sizeWithZone.Width, sizeWithZone.Height);
}
else
gfx.DrawImage(MatrixImage, pos.X, pos.Y, Size.Width, Size.Height);
gfx.Restore(state);
}
public BarCodeRenderInfo(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
Gfx = gfx;
Brush = brush;
Font = font;
Position = position;
}
/// <summary>
/// Renders the OMR code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
XGraphicsState state = gfx.Save();
switch (Direction)
{
case CodeDirection.RightToLeft:
gfx.RotateAtTransform(180, position);
break;
case CodeDirection.TopToBottom:
gfx.RotateAtTransform(90, position);
break;
case CodeDirection.BottomToTop:
gfx.RotateAtTransform(-90, position);
break;
}
//XPoint pt = center - size / 2;
XPoint pt = position - CodeBase.CalcDistance(AnchorType.TopLeft, Anchor, Size);
uint value;
uint.TryParse(Text, out value);
#if true
// HACK: Project Wallenwein: set LK
value |= 1;
_synchronizeCode = true;
#endif
if (_synchronizeCode)
{
XRect rect = new XRect(pt.X, pt.Y, _makerThickness, Size.Height);
gfx.DrawRectangle(brush, rect);
pt.X += 2 * _makerDistance;
}
for (int idx = 0; idx < 32; idx++)
{
if ((value & 1) == 1)
{
XRect rect = new XRect(pt.X + idx * _makerDistance, pt.Y, _makerThickness, Size.Height);
gfx.DrawRectangle(brush, rect);
}
value = value >> 1;
}
gfx.Restore(state);
}
/// <summary>
/// Multiplies a point with a matrix.
/// </summary>
public static XPoint Multiply(XPoint point, XMatrix matrix)
{
return(matrix.Transform(point));
}
/// <summary>
/// PDFsharp uses the Td operator to set the text position. Td just sets the offset of the text matrix
/// and produces lesser code as Tm.
/// </summary>
/// <param name="pos">The absolute text position.</param>
/// <param name="dy">The dy.</param>
/// <param name="adjustSkew">true if skewing for italic simulation is currently on.</param>
void AdjustTdOffset(ref XPoint pos, double dy, bool adjustSkew)
{
pos.Y += dy;
// Reference: TABLE 5.5 Text-positioning operators / Page 406
XPoint posSave = pos;
// Map from absolute to relative position.
pos = pos - new XVector(_gfxState.RealizedTextPosition.X, _gfxState.RealizedTextPosition.Y);
if (adjustSkew)
{
// In case that italic simulation is on X must be adjusted according to Y offset. Weird but works :-)
pos.X -= Const.ItalicSkewAngleSinus * pos.Y;
}
_gfxState.RealizedTextPosition = posSave;
}
// ----- DrawCurve ----------------------------------------------------------------------------
public void DrawCurve(XPen pen, XPoint[] points, double tension)
{
if (pen == null)
throw new ArgumentNullException("pen");
if (points == null)
throw new ArgumentNullException("points");
int count = points.Length;
if (count == 0)
return;
if (count < 2)
throw new ArgumentException("Not enough points", "points");
// See http://pubpages.unh.edu/~cs770/a5/cardinal.html
tension /= 3;
Realize(pen);
AppendFormat("{0:0.###} {1:0.###} m\n", points[0].X, points[0].Y);
if (count == 2)
{
// Just draws a line...
AppendCurveSegment(points[0], points[0], points[1], points[1], tension);
}
else
{
AppendCurveSegment(points[0], points[0], points[1], points[2], tension);
for (int idx = 1; idx < count - 2; idx++)
AppendCurveSegment(points[idx - 1], points[idx], points[idx + 1], points[idx + 2], tension);
AppendCurveSegment(points[count - 3], points[count - 2], points[count - 1], points[count - 1], tension);
}
AppendStrokeFill(pen, null, XFillMode.Alternate, false);
}
// --------------------------------------------------------------------------------------------
#region Transformation
public void SetPageTransform(XPageDirection direction, XPoint origion, XGraphicsUnit unit)
{
if (this.gfxStateStack.Count > 0)
throw new InvalidOperationException("PageTransformation can be modified only when the graphics stack is empty.");
throw new NotImplementedException("SetPageTransform");
}
/// <summary>
/// Transforms the specified point by this matrix and returns the result.
/// </summary>
public XPoint Transform(XPoint point)
{
double x = point.X;
double y = point.Y;
MultiplyPoint(ref x, ref y);
return new XPoint(x, y);
}
// --------------------------------------------------------------------------------------------
#region Realizing graphical state
/// <summary>
/// Initializes the default view transformation, i.e. the transformation from the user page
/// space to the PDF page space.
/// </summary>
void BeginPage()
{
if (this.gfxState.Level == GraphicsStackLevelInitial)
{
// Flip page horizontaly and mirror text.
// TODO: Is PageOriging and PageScale (== Viewport) useful? Or just public DefaultViewMatrix (like Presentation Manager has had)
this.defaultViewMatrix = new XMatrix(); //XMatrix.Identity;
if (this.gfx.PageDirection == XPageDirection.Downwards)
{
#if MIGRADOC
if (this.pdflibHack)
{
// MigraDoc 1.1 (written in C++) based on PDFlib and our RenderContext for GDI+. To keep it running
// on PDFlib (and PGL) I need this hack here in the MigraDoc build of PDFsharp.
// The new and more flexible MigraDoc Rendering (written in C#) doesn't need it anymore.
SaveState();
defaultViewMatrix.Translate(0, this.page.Height);
defaultViewMatrix.Scale(1, -1);
}
else
#endif
{
// Take TrimBox into account
double pageHeight = Size.Height;
XPoint trimOffset = new XPoint();
if (this.page != null && this.page.TrimMargins.AreSet)
{
pageHeight += this.page.TrimMargins.Top.Point + this.page.TrimMargins.Bottom.Point;
trimOffset = new XPoint(this.page.TrimMargins.Left.Point, this.page.TrimMargins.Top.Point);
}
if (this.page != null && this.page.Elements.GetInteger("/Rotate") == 90) // HACK for InDesign flyer
{
defaultViewMatrix.RotatePrepend(90);
defaultViewMatrix.ScalePrepend(1, -1);
}
else
{
// Recall that the value of Height depends on Orientation.
defaultViewMatrix.TranslatePrepend(0, pageHeight);
defaultViewMatrix.Scale(1, -1, XMatrixOrder.Prepend);
}
// Scale with page units
switch (this.gfx.PageUnit)
{
case XGraphicsUnit.Inch:
defaultViewMatrix.ScalePrepend(XUnit.InchFactor);
break;
case XGraphicsUnit.Millimeter:
defaultViewMatrix.ScalePrepend(XUnit.MillimeterFactor);
break;
case XGraphicsUnit.Centimeter:
defaultViewMatrix.ScalePrepend(XUnit.CentimeterFactor);
break;
}
if (trimOffset != new XPoint())
{
Debug.Assert(this.gfx.PageUnit == XGraphicsUnit.Point, "With TrimMargins set the page units must be Point. Ohter cases nyi.");
defaultViewMatrix.TranslatePrepend(trimOffset.x, trimOffset.y);
}
// Save initial graphic state
SaveState();
// Set page transformation
double[] cm = defaultViewMatrix.GetElements();
AppendFormat("{0:0.###} {1:0.###} {2:0.###} {3:0.###} {4:0.###} {5:0.###} cm ",
cm[0], cm[1], cm[2], cm[3], cm[4], cm[5]);
AppendFormat("-100 Tz\n");
}
}
else
{
// Scale with page units
switch (this.gfx.PageUnit)
{
case XGraphicsUnit.Inch:
defaultViewMatrix.ScalePrepend(XUnit.InchFactor);
break;
case XGraphicsUnit.Millimeter:
defaultViewMatrix.ScalePrepend(XUnit.MillimeterFactor);
break;
case XGraphicsUnit.Centimeter:
defaultViewMatrix.ScalePrepend(XUnit.CentimeterFactor);
break;
}
// Save initial graphic state
SaveState();
// Set page transformation
double[] cm = defaultViewMatrix.GetElements();
AppendFormat("{0:0.###} {1:0.###} {2:0.###} {3:0.###} {4:0.###} {5:0.###} cm ",
cm[0], cm[1], cm[2], cm[3], cm[4], cm[5]);
}
}
}
/// <summary>
/// Parse a SVG path geometry string.
/// </summary>
/// <param name="context">The geometry context.</param>
/// <param name="pathString">The path geometry string</param>
/// <param name="startIndex">The string start index.</param>
public void Parse(XGeometryContext context, string pathString, int startIndex)
{
_context = context;
_pathString = pathString;
_pathLength = pathString.Length;
_curIndex = startIndex;
_secondLastPoint = Point2.Create(0, 0);
_lastPoint = Point2.Create(0, 0);
_lastStart = Point2.Create(0, 0);
_figureStarted = false;
bool first = true;
char last_cmd = ' ';
while (ReadToken())
{
char cmd = _token;
if (first)
{
if ((cmd != 'M') && (cmd != 'm'))
{
InvalidToken();
}
first = false;
}
switch (cmd)
{
case 'm':
case 'M':
_lastPoint = ReadPoint(cmd, !_allowComma);
_context.BeginFigure(XPoint.FromPoint2(_lastPoint), _isFilled, !_isClosed);
_figureStarted = true;
_lastStart = _lastPoint;
last_cmd = 'M';
while (IsNumber(_allowComma))
{
_lastPoint = ReadPoint(cmd, !_allowComma);
_context.LineTo(XPoint.FromPoint2(_lastPoint), _isStroked, !_isSmoothJoin);
last_cmd = 'L';
}
break;
case 'l':
case 'L':
case 'h':
case 'H':
case 'v':
case 'V':
EnsureFigure();
do
{
switch (cmd)
{
case 'l':
_lastPoint = ReadPoint(cmd, !_allowComma);
break;
case 'L':
_lastPoint = ReadPoint(cmd, !_allowComma);
break;
case 'h':
_lastPoint.X += ReadNumber(!_allowComma);
break;
case 'H':
_lastPoint.X = ReadNumber(!_allowComma);
break;
case 'v':
_lastPoint.Y += ReadNumber(!_allowComma);
break;
case 'V':
_lastPoint.Y = ReadNumber(!_allowComma);
break;
}
_context.LineTo(XPoint.FromPoint2(_lastPoint), _isStroked, !_isSmoothJoin);
}while (IsNumber(_allowComma));
last_cmd = 'L';
break;
case 'c':
case 'C':
case 's':
case 'S':
EnsureFigure();
do
{
Point2 p;
if ((cmd == 's') || (cmd == 'S'))
{
if (last_cmd == 'C')
{
p = Reflect();
}
else
{
p = _lastPoint;
}
_secondLastPoint = ReadPoint(cmd, !_allowComma);
}
else
{
p = ReadPoint(cmd, !_allowComma);
_secondLastPoint = ReadPoint(cmd, _allowComma);
}
_lastPoint = ReadPoint(cmd, _allowComma);
_context.CubicBezierTo(
XPoint.FromPoint2(p),
XPoint.FromPoint2(_secondLastPoint),
XPoint.FromPoint2(_lastPoint),
_isStroked,
!_isSmoothJoin);
last_cmd = 'C';
}while (IsNumber(_allowComma));
break;
case 'q':
case 'Q':
case 't':
case 'T':
EnsureFigure();
do
{
if ((cmd == 't') || (cmd == 'T'))
{
if (last_cmd == 'Q')
{
_secondLastPoint = Reflect();
}
else
{
_secondLastPoint = _lastPoint;
}
_lastPoint = ReadPoint(cmd, !_allowComma);
}
else
{
_secondLastPoint = ReadPoint(cmd, !_allowComma);
_lastPoint = ReadPoint(cmd, _allowComma);
}
_context.QuadraticBezierTo(
XPoint.FromPoint2(_secondLastPoint),
XPoint.FromPoint2(_lastPoint),
_isStroked,
!_isSmoothJoin);
last_cmd = 'Q';
}while (IsNumber(_allowComma));
break;
case 'a':
case 'A':
EnsureFigure();
do
{
double w = ReadNumber(!_allowComma);
double h = ReadNumber(_allowComma);
double rotation = ReadNumber(_allowComma);
bool large = ReadBool();
bool sweep = ReadBool();
_lastPoint = ReadPoint(cmd, _allowComma);
_context.ArcTo(
XPoint.FromPoint2(_lastPoint),
XPathSize.Create(w, h),
rotation,
large,
sweep ? XSweepDirection.Clockwise : XSweepDirection.Counterclockwise,
_isStroked,
!_isSmoothJoin);
}while (IsNumber(_allowComma));
last_cmd = 'A';
break;
case 'z':
case 'Z':
EnsureFigure();
_context.SetClosedState(_isClosed);
_figureStarted = false;
last_cmd = 'Z';
_lastPoint = _lastStart;
break;
default:
InvalidToken();
break;
}
}
}
/// <summary>
/// Renders the bar code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
XGraphicsState state = gfx.Save();
BarCodeRenderInfo info = new BarCodeRenderInfo(gfx, brush, font, position);
InitRendering(info);
info.CurrPosInString = 0;
//info.CurrPos = info.Center - this.size / 2;
info.CurrPos = position - CodeBase.CalcDistance(AnchorType.TopLeft, this.anchor, this.size);
if (TurboBit)
RenderTurboBit(info, true);
RenderStart(info);
while (info.CurrPosInString < this.text.Length)
{
RenderNextChar(info);
RenderGap(info, false);
}
RenderStop(info);
if (TurboBit)
RenderTurboBit(info, false);
if (TextLocation != TextLocation.None)
RenderText(info);
gfx.Restore(state);
}
/// <summary>
///
/// </summary>
/// <param name="pg"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="scale"></param>
/// <returns></returns>
public static XGraphicsPath ToXGraphicsPath(this PathGeometry pg, double dx, double dy, Func <double, double> scale)
{
var gp = new XGraphicsPath()
{
FillMode = pg.FillRule == FillRule.EvenOdd ? XFillMode.Alternate : XFillMode.Winding
};
foreach (var pf in pg.Figures)
{
var startPoint = pf.StartPoint;
foreach (var segment in pf.Segments)
{
if (segment is ArcSegment)
{
#if WPF
var arcSegment = segment as ArcSegment;
var point1 = new XPoint(
scale(startPoint.X + dx),
scale(startPoint.Y + dy));
var point2 = new XPoint(
scale(arcSegment.Point.X + dx),
scale(arcSegment.Point.Y + dy));
var size = new XSize(
scale(arcSegment.Size.Width),
scale(arcSegment.Size.Height));
gp.AddArc(
point1,
point2,
size, arcSegment.RotationAngle, arcSegment.IsLargeArc,
arcSegment.SweepDirection == SweepDirection.Clockwise ? XSweepDirection.Clockwise : XSweepDirection.Counterclockwise);
startPoint = arcSegment.Point;
#else
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
//var arcSegment = segment as ArcSegment;
// TODO: Convert WPF/SVG elliptical arc segment format to GDI+ bezier curves.
//startPoint = arcSegment.Point;
#endif
}
else if (segment is CubicBezierSegment)
{
var cubicBezierSegment = segment as CubicBezierSegment;
gp.AddBezier(
scale(startPoint.X + dx),
scale(startPoint.Y + dy),
scale(cubicBezierSegment.Point1.X + dx),
scale(cubicBezierSegment.Point1.Y + dy),
scale(cubicBezierSegment.Point2.X + dx),
scale(cubicBezierSegment.Point2.Y + dy),
scale(cubicBezierSegment.Point3.X + dx),
scale(cubicBezierSegment.Point3.Y + dy));
startPoint = cubicBezierSegment.Point3;
}
else if (segment is LineSegment)
{
var lineSegment = segment as LineSegment;
gp.AddLine(
scale(startPoint.X + dx),
scale(startPoint.Y + dy),
scale(lineSegment.Point.X + dx),
scale(lineSegment.Point.Y + dy));
startPoint = lineSegment.Point;
}
else if (segment is PolyCubicBezierSegment)
{
var polyCubicBezierSegment = segment as PolyCubicBezierSegment;
if (polyCubicBezierSegment.Points.Length >= 3)
{
gp.AddBezier(
scale(startPoint.X + dx),
scale(startPoint.Y + dy),
scale(polyCubicBezierSegment.Points[0].X + dx),
scale(polyCubicBezierSegment.Points[0].Y + dy),
scale(polyCubicBezierSegment.Points[1].X + dx),
scale(polyCubicBezierSegment.Points[1].Y + dy),
scale(polyCubicBezierSegment.Points[2].X + dx),
scale(polyCubicBezierSegment.Points[2].Y + dy));
}
if (polyCubicBezierSegment.Points.Length > 3 &&
polyCubicBezierSegment.Points.Length % 3 == 0)
{
for (int i = 3; i < polyCubicBezierSegment.Points.Length; i += 3)
{
gp.AddBezier(
scale(polyCubicBezierSegment.Points[i - 1].X + dx),
scale(polyCubicBezierSegment.Points[i - 1].Y + dy),
scale(polyCubicBezierSegment.Points[i].X + dx),
scale(polyCubicBezierSegment.Points[i].Y + dy),
scale(polyCubicBezierSegment.Points[i + 1].X + dx),
scale(polyCubicBezierSegment.Points[i + 1].Y + dy),
scale(polyCubicBezierSegment.Points[i + 2].X + dx),
scale(polyCubicBezierSegment.Points[i + 2].Y + dy));
}
}
startPoint = polyCubicBezierSegment.Points.Last();
}
else if (segment is PolyLineSegment)
{
var polyLineSegment = segment as PolyLineSegment;
if (polyLineSegment.Points.Length >= 1)
{
gp.AddLine(
scale(startPoint.X + dx),
scale(startPoint.Y + dy),
scale(polyLineSegment.Points[0].X + dx),
scale(polyLineSegment.Points[0].Y + dy));
}
if (polyLineSegment.Points.Length > 1)
{
for (int i = 1; i < polyLineSegment.Points.Length; i++)
{
gp.AddLine(
scale(polyLineSegment.Points[i - 1].X + dx),
scale(polyLineSegment.Points[i - 1].Y + dy),
scale(polyLineSegment.Points[i].X + dx),
scale(polyLineSegment.Points[i].Y + dy));
}
}
startPoint = polyLineSegment.Points.Last();
}
else if (segment is PolyQuadraticBezierSegment)
{
var polyQuadraticSegment = segment as PolyQuadraticBezierSegment;
if (polyQuadraticSegment.Points.Length >= 2)
{
var p1 = startPoint;
var p2 = polyQuadraticSegment.Points[0];
var p3 = polyQuadraticSegment.Points[1];
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1 + dx),
scale(y1 + dy),
scale(x2 + dx),
scale(y2 + dy),
scale(x3 + dx),
scale(y3 + dy),
scale(x4 + dx),
scale(y4 + dy));
}
if (polyQuadraticSegment.Points.Length > 2 &&
polyQuadraticSegment.Points.Length % 2 == 0)
{
for (int i = 3; i < polyQuadraticSegment.Points.Length; i += 3)
{
var p1 = polyQuadraticSegment.Points[i - 1];
var p2 = polyQuadraticSegment.Points[i];
var p3 = polyQuadraticSegment.Points[i + 1];
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1 + dx),
scale(y1 + dy),
scale(x2 + dx),
scale(y2 + dy),
scale(x3 + dx),
scale(y3 + dy),
scale(x4 + dx),
scale(y4 + dy));
}
}
startPoint = polyQuadraticSegment.Points.Last();
}
else if (segment is QuadraticBezierSegment)
{
var quadraticBezierSegment = segment as QuadraticBezierSegment;
var p1 = startPoint;
var p2 = quadraticBezierSegment.Point1;
var p3 = quadraticBezierSegment.Point2;
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1 + dx),
scale(y1 + dy),
scale(x2 + dx),
scale(y2 + dy),
scale(x3 + dx),
scale(y3 + dy),
scale(x4 + dx),
scale(y4 + dy));
startPoint = quadraticBezierSegment.Point2;
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
if (pf.IsClosed)
{
gp.CloseFigure();
}
else
{
gp.StartFigure();
}
}
return(gp);
}
public static void AppHit(Effect effectData, EntityParent caster, List <long> effectTargetIDs, XPoint basePoint, bool isAddEffect)
{
for (int i = 0; i < effectTargetIDs.get_Count(); i++)
{
LocalBattleHitHandler.AppHit(effectData, caster, LocalAgent.GetEntityByID(effectTargetIDs.get_Item(i)), basePoint, isAddEffect);
}
}
/// <inheritdoc/>
public override void BeginFigure(XPoint startPoint, bool isFilled = true, bool isClosed = true)
{
_currentFigure = XPathFigure.Create(startPoint, isFilled, isClosed);
_geometry.Figures = _geometry.Figures.Add(_currentFigure);
}
/// <summary>
/// Calculates the data label positions specific for pie charts.
/// </summary>
internal override void CalcPositions()
{
ChartRendererInfo cri = (ChartRendererInfo)_rendererParms.RendererInfo;
XGraphics gfx = _rendererParms.Graphics;
if (cri.seriesRendererInfos.Length > 0)
{
SeriesRendererInfo sri = cri.seriesRendererInfos[0];
if (sri != null && sri._dataLabelRendererInfo != null)
{
int sectorIndex = 0;
foreach (SectorRendererInfo sector in sri._pointRendererInfos)
{
// Determine output rectangle
double midAngle = sector.StartAngle + sector.SweepAngle / 2;
double radMidAngle = midAngle / 180 * Math.PI;
XPoint origin = new XPoint(sector.Rect.X + sector.Rect.Width / 2,
sector.Rect.Y + sector.Rect.Height / 2);
double radius = sector.Rect.Width / 2;
double halfradius = radius / 2;
DataLabelEntryRendererInfo dleri = sri._dataLabelRendererInfo.Entries[sectorIndex++];
switch (sri._dataLabelRendererInfo.Position)
{
case DataLabelPosition.OutsideEnd:
// Outer border of the circle.
dleri.X = origin.X + (radius * Math.Cos(radMidAngle));
dleri.Y = origin.Y + (radius * Math.Sin(radMidAngle));
if (dleri.X < origin.X)
{
dleri.X -= dleri.Width;
}
if (dleri.Y < origin.Y)
{
dleri.Y -= dleri.Height;
}
break;
case DataLabelPosition.InsideEnd:
// Inner border of the circle.
dleri.X = origin.X + (radius * Math.Cos(radMidAngle));
dleri.Y = origin.Y + (radius * Math.Sin(radMidAngle));
if (dleri.X > origin.X)
{
dleri.X -= dleri.Width;
}
if (dleri.Y > origin.Y)
{
dleri.Y -= dleri.Height;
}
break;
case DataLabelPosition.Center:
// Centered
dleri.X = origin.X + (halfradius * Math.Cos(radMidAngle));
dleri.Y = origin.Y + (halfradius * Math.Sin(radMidAngle));
dleri.X -= dleri.Width / 2;
dleri.Y -= dleri.Height / 2;
break;
case DataLabelPosition.InsideBase:
// Aligned at the base/center of the circle
dleri.X = origin.X;
dleri.Y = origin.Y;
if (dleri.X < origin.X)
{
dleri.X -= dleri.Width;
}
if (dleri.Y < origin.Y)
{
dleri.Y -= dleri.Height;
}
break;
}
}
}
}
}
/// <summary>
/// Renders the content found in Text
/// </summary>
/// <param name="gfx">
/// XGraphics - Instance of the drawing surface
/// </param>
/// <param name="brush">
/// XBrush - Line and Color to draw the bar code
/// </param>
/// <param name="font">
/// XFont - Font to use to draw the text string
/// </param>
/// <param name="position">
/// XPoint - Location to render the bar code
/// </param>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
// Create the array to hold the values to be rendered
this.Values = this.Code128Code == Code128Type.C ? new byte[this.text.Length / 2] : new byte[this.text.Length];
String buffer = String.Empty;
for (Int32 index = 0; index < text.Length; index++)
{
switch (this.Code128Code)
{
case Code128Type.A:
if (text[index] < 32)
{
this.Values[index] = (byte)(text[index] + 64);
}
else if ((text[index] >= 32) && (text[index] < 64))
{
this.Values[index] = (byte)(text[index] - 32);
}
else
{
this.Values[index] = (byte)text[index];
}
break;
case Code128Type.B:
this.Values[index] = (byte)(text[index] - 32);
break;
case Code128Type.C:
if ((text[index] >= '0') && (text[index] <= '9'))
{
buffer += text[index];
if (buffer.Length == 2)
{
this.Values[index / 2] = byte.Parse(buffer);
buffer = String.Empty;
}
}
else
{
throw new ArgumentOutOfRangeException("Parameter text (string) can only contain numeric characters for Code 128 - Code C");
}
break;
}
}
if (this.Values == null)
{
throw new InvalidOperationException("Text or Values must be set");
}
if (this.Values.Length == 0)
{
throw new InvalidOperationException("Text or Values must have content");
}
for (int x = 0; x < this.Values.Length; x++)
{
if (this.Values[x] > 102)
{
throw new ArgumentOutOfRangeException(BcgSR.InvalidCode128(x));
}
}
XGraphicsState state = gfx.Save();
BarCodeRenderInfo info = new BarCodeRenderInfo(gfx, brush, font, position);
this.InitRendering(info);
info.CurrPosInString = 0;
info.CurrPos = position - CodeBase.CalcDistance(AnchorType.TopLeft, this.anchor, this.size);
this.RenderStart(info);
foreach (byte c in this.Values)
{
this.RenderValue(info, c);
}
this.RenderStop(info);
if (this.TextLocation != TextLocation.None)
{
this.RenderText(info);
}
gfx.Restore(state);
}
void DumpPathData(PathData pathData)
{
XPoint[] points = new XPoint[pathData.Points.Length];
for (int i = 0; i < points.Length; i++)
points[i] = new XPoint(pathData.Points[i].X, pathData.Points[i].Y);
DumpPathData(points, pathData.Types);
}
/// <summary>
/// Convert from WinForms point to core point.
/// </summary>
public static RPoint Convert(XPoint p)
{
return(new RPoint(p.X, p.Y));
}
// ----- DrawPolygon --------------------------------------------------------------------------
public void DrawPolygon(XPen pen, XBrush brush, XPoint[] points, XFillMode fillmode)
{
Realize(pen, brush);
int count = points.Length;
if (points.Length < 2)
throw new ArgumentException("points", PSSR.PointArrayAtLeast(2));
const string format = Config.SignificantFigures4;
AppendFormatPoint("{0:" + format + "} {1:" + format + "} m\n", points[0].X, points[0].Y);
for (int idx = 1; idx < count; idx++)
AppendFormatPoint("{0:" + format + "} {1:" + format + "} l\n", points[idx].X, points[idx].Y);
AppendStrokeFill(pen, brush, fillmode, true);
}
/// <summary>
/// Indicates whether the values are so close that they can be considered as equal.
/// </summary>
public static bool AreClose(XPoint point1, XPoint point2)
{
return(AreClose(point1.X, point2.X) && AreClose(point1.Y, point2.Y));
}
/// <summary>
/// Prepends a rotation of the specified angle at the specified point to this matrix.
/// </summary>
public void RotateAtPrepend(double angle, XPoint point)
{
RotateAt(angle, point, XMatrixOrder.Prepend);
}
public static void AppTheat(Effect effectData, EntityParent caster, List <long> effectTargetIDs, XPoint basePoint, int skillID, bool isAddEffect, bool isCommunicateMix)
{
if (!LocalAgent.GetEntityCalculatable(caster, isCommunicateMix))
{
return;
}
XDict <GameData.AttrType, long> effectCasterTempAttr = LocalBattleEffectCalculatorHandler.GetEffectCasterTempAttr(effectData, caster, skillID);
bool flag = isAddEffect && isCommunicateMix;
for (int i = 0; i < effectTargetIDs.get_Count(); i++)
{
EntityParent entityByID = LocalAgent.GetEntityByID(effectTargetIDs.get_Item(i));
if (LocalAgent.GetEntityIsCurable(entityByID, isCommunicateMix))
{
if (!entityByID.IsUnconspicuous || effectData.forcePickup != 0)
{
long num = BattleCalculator.CalculateTreatment(caster.BattleBaseAttrs, entityByID.BattleBaseAttrs, entityByID.IsEntitySelfType || entityByID.IsEntityPlayerType, effectCasterTempAttr, null);
if (num != 0L)
{
List <ClientDrvBuffInfo> casterBuffInfo = null;
List <ClientDrvBuffInfo> targetBuffInfo = null;
if (isCommunicateMix)
{
casterBuffInfo = LocalAgent.MakeClientDrvBuffInfo(caster.ID);
targetBuffInfo = LocalAgent.MakeClientDrvBuffInfo(effectTargetIDs.get_Item(i));
}
long num2 = LocalAgent.GetSpiritCurHp(entityByID, isCommunicateMix) + num;
if (num2 > entityByID.RealHpLmt)
{
num2 = entityByID.RealHpLmt;
}
Pos pos = null;
if (caster.Actor)
{
pos = new Pos();
pos.x = caster.Actor.FixTransform.get_position().x * 100f;
pos.y = caster.Actor.FixTransform.get_position().z * 100f;
}
LocalAgent.SetSpiritCurHp(entityByID, num2, isCommunicateMix);
if (isCommunicateMix)
{
GlobalBattleNetwork.Instance.SendClientDriveBattleEffectDamage(caster.ID, effectTargetIDs.get_Item(i), caster.Hp, num2, num, skillID, effectData.id, flag, true, casterBuffInfo, targetBuffInfo, basePoint, new List <long>(), string.Concat(new object[]
{
caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOAtk, effectCasterTempAttr),
"_",
caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOHpLmt, effectCasterTempAttr),
"_",
caster.TryAddValue(GameData.AttrType.SkillIgnoreDefenceHurt, effectCasterTempAttr)
}), false);
}
LocalBattleProtocolSimulator.SendTreat(effectTargetIDs.get_Item(i), (GameObjectType.ENUM)entityByID.WrapType, caster.ID, (GameObjectType.ENUM)caster.WrapType, BattleAction_Treat.TreatSrcType.Treat, num, num2, pos);
if (flag)
{
flag = false;
}
}
}
}
}
}
/// <summary>
/// Multiplies all points of the specified array with the this matrix.
/// </summary>
public void TransformPoints(XPoint[] points)
{
if (points == null)
throw new ArgumentNullException("points");
if (IsIdentity)
return;
int count = points.Length;
for (int idx = 0; idx < count; idx++)
{
double x = points[idx].X;
double y = points[idx].Y;
points[idx].X = x * _m11 + y * _m21 + _offsetX;
points[idx].Y = x * _m12 + y * _m22 + _offsetY;
}
}
/// <summary> /// Moving custom points /// </summary> /// <param name="point"></param> /// <param name="x"></param> /// <param name="y"></param> public void Move(ref XPoint point, int x, int y) => point = new XPoint((float)point.FormX + x, (float)point.FormY + y);
// ----- DrawLines ----------------------------------------------------------------------------
/// <summary>
/// Strokes a series of connected points.
/// </summary>
public void DrawLines(XPen pen, XPoint[] points)
{
if (pen == null)
throw new ArgumentNullException("pen");
if (points == null)
throw new ArgumentNullException("points");
int count = points.Length;
if (count == 0)
return;
Realize(pen);
AppendFormat("{0:0.###} {1:0.###} m\n", points[0].X, points[0].Y);
for (int idx = 1; idx < count; idx++)
AppendFormat("{0:0.###} {1:0.###} l\n", points[idx].X, points[idx].Y);
this.content.Append("S\n");
}
/// <summary>
/// Draws the gridlines into the plot area.
/// </summary>
internal override void Draw()
{
ChartRendererInfo cri = (ChartRendererInfo)_rendererParms.RendererInfo;
XRect plotAreaRect = cri.plotAreaRendererInfo.Rect;
if (plotAreaRect.IsEmpty)
{
return;
}
AxisRendererInfo xari = cri.xAxisRendererInfo;
AxisRendererInfo yari = cri.yAxisRendererInfo;
double xMin = xari.MinimumScale;
double xMax = xari.MaximumScale;
double yMin = yari.MinimumScale;
double yMax = yari.MaximumScale;
double xMajorTick = xari.MajorTick;
double yMajorTick = yari.MajorTick;
double xMinorTick = xari.MinorTick;
double yMinorTick = yari.MinorTick;
double xMaxExtension = xari.MajorTick;
XMatrix matrix = cri.plotAreaRendererInfo._matrix;
LineFormatRenderer lineFormatRenderer;
XGraphics gfx = _rendererParms.Graphics;
XPoint[] points = new XPoint[2];
if (xari.MinorGridlinesLineFormat != null)
{
lineFormatRenderer = new LineFormatRenderer(gfx, xari.MinorGridlinesLineFormat);
for (double x = xMin + xMinorTick; x < xMax; x += xMinorTick)
{
points[0].Y = x;
points[0].X = yMin;
points[1].Y = x;
points[1].X = yMax;
matrix.TransformPoints(points);
lineFormatRenderer.DrawLine(points[0], points[1]);
}
}
if (xari.MajorGridlinesLineFormat != null)
{
lineFormatRenderer = new LineFormatRenderer(gfx, xari.MajorGridlinesLineFormat);
for (double x = xMin; x <= xMax; x += xMajorTick)
{
points[0].Y = x;
points[0].X = yMin;
points[1].Y = x;
points[1].X = yMax;
matrix.TransformPoints(points);
lineFormatRenderer.DrawLine(points[0], points[1]);
}
}
if (yari.MinorGridlinesLineFormat != null)
{
lineFormatRenderer = new LineFormatRenderer(gfx, yari.MinorGridlinesLineFormat);
for (double y = yMin + yMinorTick; y < yMax; y += yMinorTick)
{
points[0].Y = xMin;
points[0].X = y;
points[1].Y = xMax;
points[1].X = y;
matrix.TransformPoints(points);
lineFormatRenderer.DrawLine(points[0], points[1]);
}
}
if (yari.MajorGridlinesLineFormat != null)
{
lineFormatRenderer = new LineFormatRenderer(gfx, yari.MajorGridlinesLineFormat);
for (double y = yMin; y <= yMax; y += yMajorTick)
{
points[0].Y = xMin;
points[0].X = y;
points[1].Y = xMax;
points[1].X = y;
matrix.TransformPoints(points);
lineFormatRenderer.DrawLine(points[0], points[1]);
}
}
}
// ----- DrawClosedCurve ----------------------------------------------------------------------
public void DrawClosedCurve(XPen pen, XBrush brush, XPoint[] points, double tension, XFillMode fillmode)
{
int count = points.Length;
if (count == 0)
return;
if (count < 2)
throw new ArgumentException("Not enough points", "points");
// Simply tried out. Not proofed why it is correct.
tension /= 3;
Realize(pen, brush);
AppendFormat("{0:0.####} {1:0.####} m\n", points[0].X, points[0].Y);
if (count == 2)
{
// Just draws a line...
AppendCurveSegment(points[0], points[0], points[1], points[1], tension);
}
else
{
AppendCurveSegment(points[count - 1], points[0], points[1], points[2], tension);
for (int idx = 1; idx < count - 2; idx++)
AppendCurveSegment(points[idx - 1], points[idx], points[idx + 1], points[idx + 2], tension);
AppendCurveSegment(points[count - 3], points[count - 2], points[count - 1], points[0], tension);
AppendCurveSegment(points[count - 2], points[count - 1], points[0], points[1], tension);
}
AppendStrokeFill(pen, brush, fillmode, true);
}
/// <summary>
/// Render a prepared page into a PDF document
/// </summary>
private Result <Nothing> OutputPage(PdfDocument document, DocumentPage pageToRender, XFont font, PageBacking background, int pageIndex, int pageTotal)
{
var pageDef = pageToRender.Definition;
// If we have a source PDF, and we aren't trying to render a blank page, then import the page
var shouldCopyPdfPage = background.ExistingPage != null && pageDef.RenderBackground;
var page = shouldCopyPdfPage ? document.AddPage(background.ExistingPage !) : document.AddPage(/*blank*/);
// If dimensions are silly, reset to A4
if (pageDef.WidthMillimetres < 10 || pageDef.WidthMillimetres > 1000)
{
pageDef.WidthMillimetres = 210;
}
if (pageDef.HeightMillimetres < 10 || pageDef.HeightMillimetres > 1000)
{
pageDef.HeightMillimetres = 297;
}
// Set the PDF page size (in points under the hood)
page.Width = XUnit.FromMillimeter(pageDef.WidthMillimetres);
page.Height = XUnit.FromMillimeter(pageDef.HeightMillimetres);
using var gfx = XGraphics.FromPdfPage(page);
gfx.Save();
if (shouldCopyPdfPage && background.ExistingPage !.Rotate != 0)
{
// Match visual-rotations on page
var centre = new XPoint(0, 0);
var visualRotate = background.ExistingPage !.Rotate % 360; // degrees, spec says it should be a multiple of 90.
var angle = 360.0 - visualRotate;
gfx.RotateAtTransform(angle, centre);
switch (visualRotate)
{
case 90:
gfx.TranslateTransform(-page.Height.Point, 0);
break;
case 180:
gfx.TranslateTransform(-page.Width.Point, -page.Height.Point);
break;
case 270:
gfx.TranslateTransform(-page.Height.Point / 2.0, -page.Height.Point); // this one is a guess, as I don't have an example
break;
default:
throw new Exception("Unhandled visual rotation case");
}
if (background.ExistingPage.Orientation == PageOrientation.Landscape)
{
(page.Width, page.Height) = (page.Height, page.Width);
}
}
// Draw background at full page size
_loadingTimer.Start();
if (pageDef.RenderBackground && background.BackgroundImage != null)
{
var destRect = new XRect(0, 0, (float)page.Width.Point, (float)page.Height.Point);
gfx.DrawImage(background.BackgroundImage, destRect);
}
_loadingTimer.Stop();
// Do default scaling
var fx = page.Width.Point / page.Width.Millimeter;
var fy = page.Height.Point / page.Height.Millimeter;
// If using an image, work out the bitmap -> page adjustment
if (background.BackgroundImage != null)
{
fx = page.Width.Point / background.BackgroundImage.PixelWidth;
fy = page.Height.Point / background.BackgroundImage.PixelHeight;
}
// Draw each box.
foreach (var boxDef in pageToRender.DocumentBoxes)
{
var result = RenderBox(font, boxDef, fx, fy, gfx, pageToRender, pageIndex, pageTotal);
if (result.IsFailure)
{
return(result);
}
}
gfx.Restore();
return(Result.Success());
}
/// <summary>
/// Renders the content found in Text
/// </summary>
/// <param name="gfx">
/// XGraphics - Instance of the drawing surface
/// </param>
/// <param name="brush">
/// XBrush - Line and Color to draw the bar code
/// </param>
/// <param name="font">
/// XFont - Font to use to draw the text string
/// </param>
/// <param name="position">
/// XPoint - Location to render the bar code
/// </param>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
// Create the array to hold the values to be rendered
this.Values = this.Code128Code == Code128Type.C ? new byte[this.text.Length / 2] : new byte[this.text.Length];
String buffer = String.Empty;
for (Int32 index = 0; index < text.Length; index++)
switch (this.Code128Code)
{
case Code128Type.A:
if (text[index] < 32)
this.Values[index] = (byte)(text[index] + 64);
else if ((text[index] >= 32) && (text[index] < 64))
this.Values[index] = (byte)(text[index] - 32);
else
this.Values[index] = (byte)text[index];
break;
case Code128Type.B:
this.Values[index] = (byte)(text[index] - 32);
break;
case Code128Type.C:
if ((text[index] >= '0') && (text[index] <= '9'))
{
buffer += text[index];
if (buffer.Length == 2)
{
this.Values[index / 2] = byte.Parse(buffer);
buffer = String.Empty;
}
}
else
throw new ArgumentOutOfRangeException("Parameter text (string) can only contain numeric characters for Code 128 - Code C");
break;
}
if (this.Values == null)
throw new InvalidOperationException("Text or Values must be set");
if (this.Values.Length == 0)
throw new InvalidOperationException("Text or Values must have content");
for (int x = 0; x < this.Values.Length; x++)
if (this.Values[x] > 102)
throw new ArgumentOutOfRangeException(BcgSR.InvalidCode128(x));
XGraphicsState state = gfx.Save();
BarCodeRenderInfo info = new BarCodeRenderInfo(gfx, brush, font, position);
this.InitRendering(info);
info.CurrPosInString = 0;
info.CurrPos = position - CodeBase.CalcDistance(AnchorType.TopLeft, this.anchor, this.size);
this.RenderStart(info);
foreach (byte c in this.Values)
this.RenderValue(info, c);
this.RenderStop(info);
if (this.TextLocation != TextLocation.None)
this.RenderText(info);
gfx.Restore(state);
}
/// <summary>
/// Renders the bar code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
XGraphicsState state = gfx.Save();
BarCodeRenderInfo info = new BarCodeRenderInfo(gfx, brush, font, position);
InitRendering(info);
info.CurrPosInString = 0;
//info.CurrPos = info.Center - Size / 2;
info.CurrPos = position - CodeBase.CalcDistance(AnchorType.TopLeft, Anchor, Size);
if (TurboBit)
{
RenderTurboBit(info, true);
}
RenderStart(info);
while (info.CurrPosInString < Text.Length)
{
RenderNextPair(info);
}
RenderStop(info);
if (TurboBit)
{
RenderTurboBit(info, false);
}
if (TextLocation != TextLocation.None)
{
RenderText(info);
}
gfx.Restore(state);
}
/// <summary>
/// Calculate angles for each sector.
/// </summary>
protected override void CalcSectors()
{
ChartRendererInfo cri = (ChartRendererInfo)this.rendererParms.RendererInfo;
if (cri.seriesRendererInfos.Length == 0)
{
return;
}
SeriesRendererInfo sri = cri.seriesRendererInfos[0];
double sumValues = sri.SumOfPoints;
if (sumValues == 0)
{
return;
}
double textMeasure = 0;
if (sri.dataLabelRendererInfo != null && sri.dataLabelRendererInfo.Position == DataLabelPosition.OutsideEnd)
{
foreach (DataLabelEntryRendererInfo dleri in sri.dataLabelRendererInfo.Entries)
{
textMeasure = Math.Max(textMeasure, dleri.Width);
textMeasure = Math.Max(textMeasure, dleri.Height);
}
}
XRect pieRect = cri.plotAreaRendererInfo.Rect;
if (textMeasure != 0)
{
pieRect.X += textMeasure;
pieRect.Y += textMeasure;
pieRect.Width -= 2 * textMeasure;
pieRect.Height -= 2 * textMeasure;
}
XPoint origin = new XPoint(pieRect.X + pieRect.Width / 2, pieRect.Y + pieRect.Height / 2);
XRect innerRect = new XRect();
XPoint p1 = new XPoint();
double midAngle = 0, sectorStartAngle = 0, sectorSweepAngle = 0,
deltaAngle = 2, startAngle = 270, sweepAngle = 0,
rInnerCircle = pieRect.Width / 15,
rOuterCircle = pieRect.Width / 2;
foreach (SectorRendererInfo sector in sri.pointRendererInfos)
{
if (!double.IsNaN(sector.point.value) && sector.point.value != 0)
{
sweepAngle = 360 / (sumValues / Math.Abs(sector.point.value));
midAngle = startAngle + sweepAngle / 2;
sectorStartAngle = Math.Max(0, startAngle + deltaAngle);
sectorSweepAngle = Math.Max(sweepAngle, sweepAngle - deltaAngle);
p1.X = origin.X + rInnerCircle * Math.Cos(midAngle / 180 * Math.PI);
p1.Y = origin.Y + rInnerCircle * Math.Sin(midAngle / 180 * Math.PI);
innerRect.X = p1.X - rOuterCircle + rInnerCircle;
innerRect.Y = p1.Y - rOuterCircle + rInnerCircle;
innerRect.Width = (rOuterCircle - rInnerCircle) * 2;
innerRect.Height = innerRect.Width;
sector.Rect = innerRect;
sector.StartAngle = sectorStartAngle;
sector.SweepAngle = sectorSweepAngle;
startAngle += sweepAngle;
}
else
{
sector.StartAngle = double.NaN;
sector.SweepAngle = double.NaN;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="img"></param>
/// <param name="path"></param>
/// <param name="exportItem"></param>
/// <returns>byte[]</returns>
private byte[] createPdf(Image img, MapExportItem exportItem, string fontName)
{
PdfDocument document = new PdfDocument();
PdfPage page = document.AddPage();
page.Size = GetPageSize(exportItem);
page.Orientation = exportItem.orientation == "L" ? PdfSharp.PageOrientation.Landscape : PdfSharp.PageOrientation.Portrait;
XGraphics gfx = XGraphics.FromPdfPage(page);
int scale = int.Parse(exportItem.scale);
double length = (1.0 / scale);
double unitLength = (length * 2.82e3);
Dictionary <int, string> scaleBarTexts = new Dictionary <int, string>()
{
{ 250, "25 m" },
{ 500, "50 m" },
{ 1000, "50 m" },
{ 2500, "100 m" },
{ 5000, "200 m" },
{ 10000, "500 m" },
{ 25000, "1 km" },
{ 50000, "2 km" },
{ 100000, "5 km" },
{ 250000, "10 km" }
};
Dictionary <int, int> scaleBarLengths = new Dictionary <int, int>()
{
{ 250, 25 },
{ 500, 50 },
{ 1000, 50 },
{ 2500, 100 },
{ 5000, 200 },
{ 10000, 500 },
{ 25000, 1000 },
{ 50000, 2000 },
{ 100000, 5000 },
{ 250000, 10000 }
};
int displayLength = GetDisplayLength(unitLength, scaleBarLengths, scale);
string displayText = GetDisplayText(unitLength, scaleBarTexts, scale);
// adding support for different layouts
int layout = ConfigurationManager.AppSettings["exportLayout"] != null?int.Parse(ConfigurationManager.AppSettings["exportLayout"]) : 1;
if (layout == 1)//original layout
{
//origina code from github
this.drawImage(gfx, img, 0, 0, page);
List <string> copyrights = new List <string>();
if (ConfigurationManager.AppSettings["exportCopyrightText"] != null)
{
copyrights = ConfigurationManager.AppSettings["exportCopyrightText"].Split(',').ToList();
}
string infoText = String.Empty;
if (ConfigurationManager.AppSettings["exportInfoText"] != null)
{
infoText = ConfigurationManager.AppSettings["exportInfoText"];
}
int height = 45 + copyrights.Count * 10;
XPoint[] points = new XPoint[]
{
new XPoint(12, 12),
new XPoint(12, height),
new XPoint(55 + displayLength, height),
new XPoint(55 + displayLength, 12),
new XPoint(12, 12)
};
gfx.DrawPolygon(XBrushes.White, points, XFillMode.Winding);
this.drawText(gfx, fontName, String.Format("Skala 1:{0}", exportItem.scale), 15, 25);
gfx.DrawLine(XPens.Black, new XPoint(15, 32), new XPoint(15 + displayLength, 32));
gfx.DrawLine(XPens.Black, new XPoint(15, 28), new XPoint(15, 36));
gfx.DrawLine(XPens.Black, new XPoint(15 + displayLength, 28), new XPoint(15 + displayLength, 36));
this.drawText(gfx, fontName, displayText, 20 + displayLength, 35);
var y = (int)page.Height.Point - 15;
this.drawText(gfx, fontName, infoText, 15, y);
int i = 0;
copyrights.ForEach(copyright =>
{
int start = 50;
this.drawText(gfx, fontName, String.Format("© {0}", copyright), 15, start + i * 10);
i++;
});
XImage logo = XImage.FromFile(Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "assets", "logo.png"));
gfx.DrawImage(logo, (gfx.PageSize.Width - logo.PixelWidth / 2) - 12, 12, logo.PixelWidth / 2, logo.PixelHeight / 2);
byte[] bytes;
using (MemoryStream ms = new MemoryStream())
{
document.Save(ms);
bytes = ReadFully(ms);
}
return(bytes);
}
else if (layout == 2)//new layout
{
// x and y 0 0(top left corner?)-> change
this.drawImage(gfx, img, 33, 33, page);
List <string> copyrights = new List <string>();
if (ConfigurationManager.AppSettings["exportCopyrightText"] != null)
{
copyrights = ConfigurationManager.AppSettings["exportCopyrightText"].Split(',').ToList();
}
string infoText = String.Empty;
if (ConfigurationManager.AppSettings["exportInfoText"] != null)
{
infoText = ConfigurationManager.AppSettings["exportInfoText"];
}
int height = 1;
XPoint[] points = new XPoint[]
{
new XPoint(12, 12),
new XPoint(12, height),
new XPoint(55 + displayLength, height),
new XPoint(55 + displayLength, 12),
new XPoint(12, 12)
};
gfx.DrawPolygon(XBrushes.White, points, XFillMode.Winding);
// x y
this.drawText(gfx, fontName, String.Format("Skala 1:{0}", exportItem.scale), 33, (int)page.Height.Point - 23, 8);
gfx.DrawLine(XPens.Black, new XPoint(33, (int)page.Height.Point - 18), new XPoint(33 + displayLength, (int)page.Height.Point - 18));
gfx.DrawLine(XPens.Black, new XPoint(33, (int)page.Height.Point - 15), new XPoint(33, (int)page.Height.Point - 21));
gfx.DrawLine(XPens.Black, new XPoint(33 + displayLength / 2, (int)page.Height.Point - 17), new XPoint(33 + displayLength / 2, (int)page.Height.Point - 19));
gfx.DrawLine(XPens.Black, new XPoint(33 + displayLength, (int)page.Height.Point - 15), new XPoint(33 + displayLength, (int)page.Height.Point - 21));
this.drawText(gfx, fontName, displayText, 38 + displayLength, (int)page.Height.Point - 16, 8);
var y = (int)page.Height.Point - 2;
this.drawText(gfx, fontName, infoText, 33, y, 8);
int i = 0;
copyrights.ForEach(copyright =>
{
int start = (int)page.Height.Point - 15;
this.drawText(gfx, fontName, String.Format("© {0}", copyright), (int)page.Width.Point - 100, start + i * 10, 8);
i++;
});
XImage logo = XImage.FromFile(Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "assets", "logo.png"));
gfx.DrawImage(logo, (gfx.PageSize.Width - logo.PixelWidth / 5) - 33, 3.5, logo.PixelWidth / 5, logo.PixelHeight / 5);
byte[] bytes;
using (MemoryStream ms = new MemoryStream())
{
document.Save(ms);
bytes = ReadFully(ms);
}
return(bytes);
}
else if (layout == 3)
{
List <string> copyrights = new List <string>();
if (ConfigurationManager.AppSettings["exportCopyrightText"] != null)
{
copyrights = ConfigurationManager.AppSettings["exportCopyrightText"].Split(',').ToList();
}
string infoText = String.Empty;
if (ConfigurationManager.AppSettings["exportInfoText"] != null)
{
infoText = ConfigurationManager.AppSettings["exportInfoText"];
}
// Get logoimage
XImage logo = XImage.FromFile(Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "assets", "logo.png"));
// Set positions, areas, brushes and pens
XRect margins = new XRect(33, 33, 33, 33);
XSize stampSize = new XSize(200, 120);
// Calculate positions and areas
XRect drawingArea = new XRect(margins.Left, margins.Top, page.Width - (margins.Left + margins.Width), page.Height - (margins.Top + margins.Height));
XRect stampArea = new XRect(new XPoint(drawingArea.Left + 15, drawingArea.Bottom - stampSize.Height - 15), stampSize);
XRect logoArea = new XRect(new XPoint(stampArea.Left + 10, stampArea.Top + 10), new XPoint(stampArea.Right - 10, stampArea.Top + 50));
XPoint signingLine = new XPoint(stampArea.Left + 10, logoArea.Bottom + 30);
XPoint copyrightPosition = new XPoint(drawingArea.Right - 3, drawingArea.Bottom - 3);
XPoint scalLegendPosition = new XPoint(stampArea.Left + 10, signingLine.Y + 20);
double scaling;
var scalingY = logo.PointHeight / logoArea.Height;
var scalingX = logo.PointWidth / logoArea.Width;
if (scalingX < scalingY)
{
scaling = scalingX;
}
else
{
scaling = scalingY;
}
// Pens, Brushes and colors
XColor mainColor = XColor.FromArgb(0, 119, 188);
XPen thickPen = new XPen(mainColor, 1);
XPen thinPen = new XPen(mainColor, 0.5);
// Draw map
this.drawImage(gfx, img, drawingArea.Left, drawingArea.Top, page);
// Put a border around map
gfx.DrawRectangle(thickPen, drawingArea);
// Draw a white "stamparea"
gfx.DrawRectangle(thickPen, XBrushes.White, stampArea);
// Draw logo
gfx.DrawImage(logo, logoArea.Left, logoArea.Top, logo.PointWidth / scaling, logo.PointHeight / scaling);
// Draw "signing line"
gfx.DrawLine(thinPen, signingLine, new XPoint(stampArea.Right - 10, signingLine.Y));
// Draw scale legend
gfx.DrawLine(XPens.Black, new XPoint(scalLegendPosition.X, scalLegendPosition.Y), new XPoint(scalLegendPosition.X + displayLength, scalLegendPosition.Y));
gfx.DrawLine(XPens.Black, new XPoint(scalLegendPosition.X, scalLegendPosition.Y - 3), new XPoint(scalLegendPosition.X, scalLegendPosition.Y + 3));
gfx.DrawLine(XPens.Black, new XPoint(scalLegendPosition.X + displayLength / 2, scalLegendPosition.Y - 2), new XPoint(scalLegendPosition.X + displayLength / 2, scalLegendPosition.Y + 2));
gfx.DrawLine(XPens.Black, new XPoint(scalLegendPosition.X + displayLength, scalLegendPosition.Y - 3), new XPoint(scalLegendPosition.X + displayLength, scalLegendPosition.Y + 3));
XFont font = new XFont(fontName, 6);
gfx.DrawString(String.Format("Skala 1:{0}", exportItem.scale), font, XBrushes.Black, new XRect(new XPoint(scalLegendPosition.X, scalLegendPosition.Y - 12), new XPoint(scalLegendPosition.X + displayLength, scalLegendPosition.Y - 2)), XStringFormats.TopLeft);
gfx.DrawString(displayText, font, XBrushes.Black, (int)scalLegendPosition.X + displayLength + 10, (int)scalLegendPosition.Y + 2);
// Draw infotext
this.drawText(gfx, fontName, infoText, (int)stampArea.Left + 10, (int)stampArea.Bottom - 5, 5);
// Draw copyright notes
int i = 0;
copyrights.ForEach(copyright =>
{
if (i > 0)
{
copyrightPosition.Offset(0, -10);
}
gfx.DrawString(String.Format("© {0}", copyright), font, XBrushes.Black, copyrightPosition, XStringFormats.BottomRight);
i++;
});
byte[] bytes;
using (MemoryStream ms = new MemoryStream())
{
document.Save(ms);
bytes = ReadFully(ms);
}
return(bytes);
}
return(null);
}
/// <summary>
/// Convert a point from Windows world space to PDF world space.
/// </summary>
internal XPoint WorldToView(XPoint point)
{
// If EffectiveCtm is not yet realized InverseEffectiveCtm is invalid.
Debug.Assert(_gfxState.UnrealizedCtm.IsIdentity, "Somewhere a RealizeTransform is missing.");
#if true
// See in #else case why this is correct.
XPoint pt = _gfxState.WorldTransform.Transform(point);
return _gfxState.InverseEffectiveCtm.Transform(new XPoint(pt.X, PageHeightPt / DefaultViewMatrix.M22 - pt.Y));
#else
// Get inverted PDF world transform matrix.
XMatrix invers = _gfxState.EffectiveCtm;
invers.Invert();
// Apply transform in Windows world space.
XPoint pt1 = _gfxState.WorldTransform.Transform(point);
#if true
// Do the transformation (see #else case) in one step.
XPoint pt2 = new XPoint(pt1.X, PageHeightPt / DefaultViewMatrix.M22 - pt1.Y);
#else
// Replicable version
// Apply default transformation.
pt1.X = pt1.X * DefaultViewMatrix.M11;
pt1.Y = pt1.Y * DefaultViewMatrix.M22;
// Convert from Windows space to PDF space.
XPoint pt2 = new XPoint(pt1.X, PageHeightPt - pt1.Y);
pt2.X = pt2.X / DefaultViewMatrix.M11;
pt2.Y = pt2.Y / DefaultViewMatrix.M22;
#endif
XPoint pt3 = invers.Transform(pt2);
return pt3;
#endif
}
/// <summary>
/// Calculates the position, width and height of each bar of all series.
/// </summary>
protected override void CalcBars()
{
ChartRendererInfo cri = (ChartRendererInfo)_rendererParms.RendererInfo;
if (cri.seriesRendererInfos.Length == 0)
{
return;
}
double xMax = cri.xAxisRendererInfo.MaximumScale;
double yMin = cri.yAxisRendererInfo.MinimumScale;
double yMax = cri.yAxisRendererInfo.MaximumScale;
int pointCount = 0;
foreach (SeriesRendererInfo sri in cri.seriesRendererInfos)
{
pointCount += sri._series._seriesElements.Count;
}
// Space shared by one clustered bar.
double groupWidth = cri.xAxisRendererInfo.MajorTick;
// Space used by one bar.
double columnWidth = groupWidth * 0.75 / cri.seriesRendererInfos.Length;
int seriesIdx = 0;
XPoint[] points = new XPoint[2];
foreach (SeriesRendererInfo sri in cri.seriesRendererInfos)
{
// Set x to first clustered bar for each series.
double x = xMax - groupWidth / 2;
// Offset for bars of a particular series from the start of a clustered bar.
double dx = (columnWidth * seriesIdx) - (columnWidth / 2 * cri.seriesRendererInfos.Length);
double y0 = yMin;
foreach (ColumnRendererInfo column in sri._pointRendererInfos)
{
if (column.Point != null)
{
double x0 = x - dx;
double x1 = x - dx - columnWidth;
double y1 = column.Point.Value;
// Draw from zero base line, if it exists.
if (y0 < 0 && yMax >= 0)
{
y0 = 0;
}
// y0 should always be lower than y1, i. e. draw bar from bottom to top.
if (y1 < 0 && y1 < y0)
{
double y = y0;
y0 = y1;
y1 = y;
}
points[0].X = y0; // upper left
points[0].Y = x0;
points[1].X = y1; // lower right
points[1].Y = x1;
cri.plotAreaRendererInfo._matrix.TransformPoints(points);
column.Rect = new XRect(points[0].X,
points[1].Y,
points[1].X - points[0].X,
points[0].Y - points[1].Y);
}
x--; // Next clustered bar.
}
seriesIdx++;
}
}
void DumpPathData(XPoint[] points, byte[] types)
{
int count = points.Length;
for (int idx = 0; idx < count; idx++)
{
string info = PdfEncoders.Format("{0:X} {1:####0.000} {2:####0.000}", types[idx], points[idx].X, points[idx].Y);
Debug.WriteLine(info, "PathData");
}
}
/// <summary>
/// Draws the horizontal X axis.
/// </summary>
internal override void Draw()
{
XGraphics gfx = _rendererParms.Graphics;
ChartRendererInfo cri = (ChartRendererInfo)_rendererParms.RendererInfo;
AxisRendererInfo xari = cri.xAxisRendererInfo;
double xMin = xari.MinimumScale;
double xMax = xari.MaximumScale;
double xMajorTick = xari.MajorTick;
double xMinorTick = xari.MinorTick;
double xMaxExtension = xari.MajorTick;
// Draw tick labels. Each tick label will be aligned centered.
int countTickLabels = (int)xMax;
double tickLabelStep = xari.Width;
if (countTickLabels != 0)
{
tickLabelStep = xari.Width / countTickLabels;
}
//XPoint startPos = new XPoint(xari.X + tickLabelStep / 2, xari.Y + /*xari.TickLabelsHeight +*/ xari.MajorTickMarkWidth);
XPoint startPos = new XPoint(xari.X + tickLabelStep / 2, xari.Y + xari.TickLabelsHeight);
if (xari.MajorTickMark != TickMarkType.None)
{
startPos.Y += xari.MajorTickMarkWidth;
}
foreach (XSeries xs in xari.XValues)
{
for (int idx = 0; idx < countTickLabels && idx < xs.Count; ++idx)
{
XValue xv = xs[idx];
if (xv != null)
{
string tickLabel = xv._value;
XSize size = gfx.MeasureString(tickLabel, xari.TickLabelsFont);
gfx.DrawString(tickLabel, xari.TickLabelsFont, xari.TickLabelsBrush, startPos.X - size.Width / 2, startPos.Y);
}
startPos.X += tickLabelStep;
}
}
// Draw axis.
// First draw tick marks, second draw axis.
double majorTickMarkStart = 0, majorTickMarkEnd = 0,
minorTickMarkStart = 0, minorTickMarkEnd = 0;
GetTickMarkPos(xari, ref majorTickMarkStart, ref majorTickMarkEnd, ref minorTickMarkStart, ref minorTickMarkEnd);
LineFormatRenderer lineFormatRenderer = new LineFormatRenderer(gfx, xari.LineFormat);
XPoint[] points = new XPoint[2];
// Minor ticks.
if (xari.MinorTickMark != TickMarkType.None)
{
int countMinorTickMarks = (int)(xMax / xMinorTick);
double minorTickMarkStep = xari.Width / countMinorTickMarks;
startPos.X = xari.X;
for (int x = 0; x <= countMinorTickMarks; x++)
{
points[0].X = startPos.X + minorTickMarkStep * x;
points[0].Y = minorTickMarkStart;
points[1].X = points[0].X;
points[1].Y = minorTickMarkEnd;
lineFormatRenderer.DrawLine(points[0], points[1]);
}
}
// Major ticks.
if (xari.MajorTickMark != TickMarkType.None)
{
int countMajorTickMarks = (int)(xMax / xMajorTick);
double majorTickMarkStep = xari.Width;
if (countMajorTickMarks != 0)
{
majorTickMarkStep = xari.Width / countMajorTickMarks;
}
startPos.X = xari.X;
for (int x = 0; x <= countMajorTickMarks; x++)
{
points[0].X = startPos.X + majorTickMarkStep * x;
points[0].Y = majorTickMarkStart;
points[1].X = points[0].X;
points[1].Y = majorTickMarkEnd;
lineFormatRenderer.DrawLine(points[0], points[1]);
}
}
// Axis.
if (xari.LineFormat != null)
{
points[0].X = xari.X;
points[0].Y = xari.Y;
points[1].X = xari.X + xari.Width;
points[1].Y = xari.Y;
if (xari.MajorTickMark != TickMarkType.None)
{
points[0].X -= xari.LineFormat.Width / 2;
points[1].X += xari.LineFormat.Width / 2;
}
lineFormatRenderer.DrawLine(points[0], points[1]);
}
// Draw axis title.
AxisTitleRendererInfo atri = xari._axisTitleRendererInfo;
if (atri != null && atri.AxisTitleText != null && atri.AxisTitleText.Length > 0)
{
XRect rect = new XRect(xari.Rect.Right / 2 - atri.AxisTitleSize.Width / 2, xari.Rect.Bottom,
atri.AxisTitleSize.Width, 0);
gfx.DrawString(atri.AxisTitleText, atri.AxisTitleFont, atri.AxisTitleBrush, rect);
}
}
// ----- DrawString ---------------------------------------------------------------------------
public void DrawString(string s, XFont font, XBrush brush, XRect rect, XStringFormat format)
{
double x = rect.X;
double y = rect.Y;
double lineSpace = font.GetHeight();
double cyAscent = lineSpace * font.CellAscent / font.CellSpace;
double cyDescent = lineSpace * font.CellDescent / font.CellSpace;
double width = _gfx.MeasureString(s, font).Width;
//bool bold = (font.Style & XFontStyle.Bold) != 0;
//bool italic = (font.Style & XFontStyle.Italic) != 0;
bool italicSimulation = (font.GlyphTypeface.StyleSimulations & XStyleSimulations.ItalicSimulation) != 0;
bool boldSimulation = (font.GlyphTypeface.StyleSimulations & XStyleSimulations.BoldSimulation) != 0;
bool strikeout = (font.Style & XFontStyle.Strikeout) != 0;
bool underline = (font.Style & XFontStyle.Underline) != 0;
Realize(font, brush, boldSimulation ? 2 : 0);
switch (format.Alignment)
{
case XStringAlignment.Near:
// nothing to do
break;
case XStringAlignment.Center:
x += (rect.Width - width) / 2;
break;
case XStringAlignment.Far:
x += rect.Width - width;
break;
}
if (Gfx.PageDirection == XPageDirection.Downwards)
{
switch (format.LineAlignment)
{
case XLineAlignment.Near:
y += cyAscent;
break;
case XLineAlignment.Center:
// TODO: Use CapHeight. PDFlib also uses 3/4 of ascent
y += (cyAscent * 3 / 4) / 2 + rect.Height / 2;
break;
case XLineAlignment.Far:
y += -cyDescent + rect.Height;
break;
case XLineAlignment.BaseLine:
// Nothing to do.
break;
}
}
else
{
switch (format.LineAlignment)
{
case XLineAlignment.Near:
y += cyDescent;
break;
case XLineAlignment.Center:
// TODO: Use CapHeight. PDFlib also uses 3/4 of ascent
y += -(cyAscent * 3 / 4) / 2 + rect.Height / 2;
break;
case XLineAlignment.Far:
y += -cyAscent + rect.Height;
break;
case XLineAlignment.BaseLine:
// Nothing to do.
break;
}
}
PdfFont realizedFont = _gfxState._realizedFont;
Debug.Assert(realizedFont != null);
realizedFont.AddChars(s);
const string format2 = Config.SignificantFigures4;
OpenTypeDescriptor descriptor = realizedFont.FontDescriptor._descriptor;
string text = null;
if (font.Unicode)
{
StringBuilder sb = new StringBuilder();
bool isSymbolFont = descriptor.FontFace.cmap.symbol;
for (int idx = 0; idx < s.Length; idx++)
{
char ch = s[idx];
if (isSymbolFont)
{
// Remap ch for symbol fonts.
ch = (char)(ch | (descriptor.FontFace.os2.usFirstCharIndex & 0xFF00)); // @@@ refactor
}
int glyphID = descriptor.CharCodeToGlyphIndex(ch);
sb.Append((char)glyphID);
}
s = sb.ToString();
byte[] bytes = PdfEncoders.RawUnicodeEncoding.GetBytes(s);
bytes = PdfEncoders.FormatStringLiteral(bytes, true, false, true, null);
text = PdfEncoders.RawEncoding.GetString(bytes, 0, bytes.Length);
}
else
{
byte[] bytes = PdfEncoders.WinAnsiEncoding.GetBytes(s);
text = PdfEncoders.ToStringLiteral(bytes, false, null);
}
// Map absolute position to PDF world space.
XPoint pos = new XPoint(x, y);
pos = WorldToView(pos);
double verticalOffset = 0;
if (boldSimulation)
{
// Adjust baseline in case of bold simulation???
// No, because this would change the center of the glyphs.
//verticalOffset = font.Size * Const.BoldEmphasis / 2;
}
#if ITALIC_SIMULATION
if (italicSimulation)
{
if (_gfxState.ItalicSimulationOn)
{
AdjustTdOffset(ref pos, verticalOffset, true);
AppendFormatArgs("{0:" + format2 + "} {1:" + format2 + "} Td\n{2} Tj\n", pos.X, pos.Y, text);
}
else
{
// Italic simulation is done by skewing characters 20° to the right.
XMatrix m = new XMatrix(1, 0, Const.ItalicSkewAngleSinus, 1, pos.X, pos.Y);
AppendFormatArgs("{0:" + format2 + "} {1:" + format2 + "} {2:" + format2 + "} {3:" + format2 + "} {4:" + format2 + "} {5:" + format2 + "} Tm\n{6} Tj\n",
m.M11, m.M12, m.M21, m.M22, m.OffsetX, m.OffsetY, text);
_gfxState.ItalicSimulationOn = true;
AdjustTdOffset(ref pos, verticalOffset, false);
}
}
else
{
if (_gfxState.ItalicSimulationOn)
{
XMatrix m = new XMatrix(1, 0, 0, 1, pos.X, pos.Y);
AppendFormatArgs("{0:" + format2 + "} {1:" + format2 + "} {2:" + format2 + "} {3:" + format2 + "} {4:" + format2 + "} {5:" + format2 + "} Tm\n{6} Tj\n",
m.M11, m.M12, m.M21, m.M22, m.OffsetX, m.OffsetY, text);
_gfxState.ItalicSimulationOn = false;
AdjustTdOffset(ref pos, verticalOffset, false);
}
else
{
AdjustTdOffset(ref pos, verticalOffset, false);
AppendFormatArgs("{0:" + format2 + "} {1:" + format2 + "} Td {2} Tj\n", pos.X, pos.Y, text);
}
}
#else
AdjustTextMatrix(ref pos);
AppendFormat2("{0:" + format2 + "} {1:" + format2 + "} Td {2} Tj\n", pos.X, pos.Y, text);
#endif
if (underline)
{
double underlinePosition = lineSpace * realizedFont.FontDescriptor._descriptor.UnderlinePosition / font.CellSpace;
double underlineThickness = lineSpace * realizedFont.FontDescriptor._descriptor.UnderlineThickness / font.CellSpace;
//DrawRectangle(null, brush, x, y - underlinePosition, width, underlineThickness);
double underlineRectY = Gfx.PageDirection == XPageDirection.Downwards
? y - underlinePosition
: y + underlinePosition - underlineThickness;
DrawRectangle(null, brush, x, underlineRectY, width, underlineThickness);
}
if (strikeout)
{
double strikeoutPosition = lineSpace * realizedFont.FontDescriptor._descriptor.StrikeoutPosition / font.CellSpace;
double strikeoutSize = lineSpace * realizedFont.FontDescriptor._descriptor.StrikeoutSize / font.CellSpace;
//DrawRectangle(null, brush, x, y - strikeoutPosition - strikeoutSize, width, strikeoutSize);
double strikeoutRectY = Gfx.PageDirection == XPageDirection.Downwards
? y - strikeoutPosition
: y + strikeoutPosition - strikeoutSize;
DrawRectangle(null, brush, x, strikeoutRectY, width, strikeoutSize);
}
}
/// <summary>
/// Init.
/// </summary>
public XTextureBrush(XImage image, XRect dstRect, XPoint translateTransformLocation)
{
this._image = image;
this._dstRect = dstRect;
this._translateTransformLocation = translateTransformLocation;
}
public void RotateAt(double angle, XPoint point)
{
throw new InvalidOperationException("Temporarily out of order.");
//RotateAt(angle, point, XMatrixOrder.Prepend);
}
/// <summary>
/// Draws the marker given through rendererInfo at the specified position. Position specifies
/// the center of the marker.
/// </summary>
internal static void Draw(XGraphics graphics, XPoint pos, MarkerRendererInfo rendererInfo)
{
#if SILVERLIGHT
return; // BUG: Code crashs Silverlight Path class.
#pragma warning disable 0162
#endif
if (rendererInfo.MarkerStyle == MarkerStyle.None)
{
return;
}
double size = rendererInfo.MarkerSize;
double size2 = size / 2;
double x0, y0, x1, y1;
double g;
XPen foreground = new XPen(rendererInfo.MarkerForegroundColor, 0.5);
XBrush background = new XSolidBrush(rendererInfo.MarkerBackgroundColor);
XGraphicsPath gp = new XGraphicsPath();
switch (rendererInfo.MarkerStyle)
{
case MarkerStyle.Square:
x0 = pos.X - size2;
y0 = pos.Y - size2;
x1 = pos.X + size2;
y1 = pos.Y + size2;
gp.AddLine(x0, y0, x1, y0);
gp.AddLine(x1, y0, x1, y1);
gp.AddLine(x1, y1, x0, y1);
gp.AddLine(x0, y1, x0, y0);
break;
case MarkerStyle.Diamond:
gp.AddLine(x1 = pos.X + size2, pos.Y, pos.X, y0 = pos.Y - size2);
gp.AddLine(pos.X, y0, x0 = pos.X - size2, pos.Y);
gp.AddLine(x0, pos.Y, pos.X, y1 = pos.Y + size2);
gp.AddLine(pos.X, y1, x1, pos.Y);
break;
case MarkerStyle.Triangle:
y0 = pos.Y + size / 2;
y1 = pos.Y - size / 2;
g = Math.Sqrt(size * size * 4 / 3) / 2;
gp.AddLine(pos.X, y1, pos.X + g, y0);
gp.AddLine(pos.X + g, y0, pos.X - g, y0);
gp.AddLine(pos.X - g, y0, pos.X, y1);
break;
case MarkerStyle.Plus:
g = size2 / 4;
gp.AddLine(pos.X - size2, pos.Y + g, pos.X - g, pos.Y + g);
gp.AddLine(pos.X - g, pos.Y + g, pos.X - g, pos.Y + size2);
gp.AddLine(pos.X - g, pos.Y + size2, pos.X + g, pos.Y + size2);
gp.AddLine(pos.X + g, pos.Y + size2, pos.X + g, pos.Y + g);
gp.AddLine(pos.X + g, pos.Y + g, pos.X + size2, pos.Y + g);
gp.AddLine(pos.X + size2, pos.Y + g, pos.X + size2, pos.Y - g);
gp.AddLine(pos.X + size2, pos.Y - g, pos.X + g, pos.Y - g);
gp.AddLine(pos.X + g, pos.Y - g, pos.X + g, pos.Y - size2);
gp.AddLine(pos.X + g, pos.Y - size2, pos.X - g, pos.Y - size2);
gp.AddLine(pos.X - g, pos.Y - size2, pos.X - g, pos.Y - g);
gp.AddLine(pos.X - g, pos.Y - g, pos.X - size2, pos.Y - g);
gp.AddLine(pos.X - size2, pos.Y - g, pos.X - size2, pos.Y + g);
break;
case MarkerStyle.Circle:
case MarkerStyle.Dot:
x0 = pos.X - size2;
y0 = pos.Y - size2;
gp.AddEllipse(x0, y0, size, size);
break;
case MarkerStyle.Dash:
x0 = pos.X - size2;
y0 = pos.Y - size2 / 3;
x1 = pos.X + size2;
y1 = pos.Y + size2 / 3;
gp.AddLine(x0, y0, x1, y0);
gp.AddLine(x1, y0, x1, y1);
gp.AddLine(x1, y1, x0, y1);
gp.AddLine(x0, y1, x0, y0);
break;
case MarkerStyle.X:
g = size / 4;
gp.AddLine(pos.X - size2 + g, pos.Y - size2, pos.X, pos.Y - g);
gp.AddLine(pos.X, pos.Y - g, pos.X + size2 - g, pos.Y - size2);
gp.AddLine(pos.X + size2 - g, pos.Y - size2, pos.X + size2, pos.Y - size2 + g);
gp.AddLine(pos.X + size2, pos.Y - size2 + g, pos.X + g, pos.Y);
gp.AddLine(pos.X + g, pos.Y, pos.X + size2, pos.Y + size2 - g);
gp.AddLine(pos.X + size2, pos.Y + size2 - g, pos.X + size2 - g, pos.Y + size2);
gp.AddLine(pos.X + size2 - g, pos.Y + size2, pos.X, pos.Y + g);
gp.AddLine(pos.X, pos.Y + g, pos.X - size2 + g, pos.Y + size2);
gp.AddLine(pos.X - size2 + g, pos.Y + size2, pos.X - size2, pos.Y + size2 - g);
gp.AddLine(pos.X - size2, pos.Y + size2 - g, pos.X - g, pos.Y);
gp.AddLine(pos.X - g, pos.Y, pos.X - size2, pos.Y - size2 + g);
break;
case MarkerStyle.Star:
{
XPoint[] points = new XPoint[10];
double radStep = 2 * Math.PI / 5;
double outerCircle = size / 2;
double innerCircle = size / 5;
// outer circle
double rad = -(Math.PI / 2); // 90°
for (int idx = 0; idx < 10; idx += 2)
{
points[idx].X = pos.X + outerCircle * Math.Cos(rad);
points[idx].Y = pos.Y + outerCircle * Math.Sin(rad);
rad += radStep;
}
// inner circle
rad = -(Math.PI / 4); // 45°
double x = innerCircle * Math.Cos(rad);
double y = innerCircle * Math.Sin(rad);
points[1].X = pos.X + x;
points[1].Y = pos.Y + y;
points[9].X = pos.X - x;
points[9].Y = pos.Y + y;
rad += radStep;
x = innerCircle * Math.Cos(rad);
y = innerCircle * Math.Sin(rad);
points[3].X = pos.X + x;
points[3].Y = pos.Y + y;
points[7].X = pos.X - x;
points[7].Y = pos.Y + y;
rad += radStep;
y = innerCircle * Math.Sin(rad);
points[5].X = pos.X;
points[5].Y = pos.Y + y;
gp.AddLines(points);
}
break;
}
gp.CloseFigure();
if (rendererInfo.MarkerStyle != MarkerStyle.Dot)
{
graphics.DrawPath(background, gp);
graphics.DrawPath(foreground, gp);
}
}
/// <summary>
/// Rotates the matrix with the specified angle at the specified point.
/// </summary>
public void RotateAt(double angle, XPoint point, XMatrixOrder order)
{
if (order == XMatrixOrder.Append)
{
angle = angle % 360.0;
this *= CreateRotationRadians(angle * Const.Deg2Rad, point.X, point.Y);
//Translate(point.X, point.Y, order);
//Rotate(angle, order);
//Translate(-point.X, -point.Y, order);
}
else
{
angle = angle % 360.0;
this = CreateRotationRadians(angle * Const.Deg2Rad, point.X, point.Y) * this;
}
DeriveMatrixType();
}
/// <summary>
/// Setups the shading from the specified brush.
/// </summary>
internal void SetupFromBrush(XLinearGradientBrush brush, XGraphicsPdfRenderer renderer)
{
if (brush == null)
{
throw new ArgumentNullException("brush");
}
PdfColorMode colorMode = _document.Options.ColorMode;
XColor color1 = ColorSpaceHelper.EnsureColorMode(colorMode, brush._color1);
XColor color2 = ColorSpaceHelper.EnsureColorMode(colorMode, brush._color2);
PdfDictionary function = new PdfDictionary();
Elements[Keys.ShadingType] = new PdfInteger(2);
if (colorMode != PdfColorMode.Cmyk)
{
Elements[Keys.ColorSpace] = new PdfName("/DeviceRGB");
}
else
{
Elements[Keys.ColorSpace] = new PdfName("/DeviceCMYK");
}
double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
if (brush._useRect)
{
XPoint pt1 = renderer.WorldToView(brush._rect.TopLeft);
XPoint pt2 = renderer.WorldToView(brush._rect.BottomRight);
switch (brush._linearGradientMode)
{
case XLinearGradientMode.Horizontal:
x1 = pt1.X;
y1 = pt1.Y;
x2 = pt2.X;
y2 = pt1.Y;
break;
case XLinearGradientMode.Vertical:
x1 = pt1.X;
y1 = pt1.Y;
x2 = pt1.X;
y2 = pt2.Y;
break;
case XLinearGradientMode.ForwardDiagonal:
x1 = pt1.X;
y1 = pt1.Y;
x2 = pt2.X;
y2 = pt2.Y;
break;
case XLinearGradientMode.BackwardDiagonal:
x1 = pt2.X;
y1 = pt1.Y;
x2 = pt1.X;
y2 = pt2.Y;
break;
}
}
else
{
XPoint pt1 = renderer.WorldToView(brush._point1);
XPoint pt2 = renderer.WorldToView(brush._point2);
x1 = pt1.X;
y1 = pt1.Y;
x2 = pt2.X;
y2 = pt2.Y;
}
const string format = Config.SignificantFigures3;
Elements[Keys.Coords] = new PdfLiteral("[{0:" + format + "} {1:" + format + "} {2:" + format + "} {3:" + format + "}]", x1, y1, x2, y2);
//Elements[Keys.Background] = new PdfRawItem("[0 1 1]");
//Elements[Keys.Domain] =
Elements[Keys.Function] = function;
//Elements[Keys.Extend] = new PdfRawItem("[true true]");
string clr1 = "[" + PdfEncoders.ToString(color1, colorMode) + "]";
string clr2 = "[" + PdfEncoders.ToString(color2, colorMode) + "]";
function.Elements["/FunctionType"] = new PdfInteger(2);
function.Elements["/C0"] = new PdfLiteral(clr1);
function.Elements["/C1"] = new PdfLiteral(clr2);
function.Elements["/Domain"] = new PdfLiteral("[0 1]");
function.Elements["/N"] = new PdfInteger(1);
}
/// <summary>
/// Transforms the specified points by this matrix.
/// </summary>
public void Transform(XPoint[] points)
{
if (points != null)
{
int count = points.Length;
for (int idx = 0; idx < count; idx++)
{
double x = points[idx].X;
double y = points[idx].Y;
MultiplyPoint(ref x, ref y);
points[idx].X = x;
points[idx].Y = y;
}
}
}
/// <summary>
/// Calculates the position, width and height of each bar of all series.
/// </summary>
protected override void CalcBars()
{
ChartRendererInfo cri = (ChartRendererInfo)_rendererParms.RendererInfo;
if (cri.seriesRendererInfos.Length == 0)
{
return;
}
double xMax = cri.xAxisRendererInfo.MaximumScale;
double xMajorTick = cri.xAxisRendererInfo.MajorTick;
int maxPoints = 0;
foreach (SeriesRendererInfo sri in cri.seriesRendererInfos)
{
maxPoints = Math.Max(maxPoints, sri._series._seriesElements.Count);
}
// Space used by one bar.
double x = xMax - xMajorTick / 2;
double columnWidth = xMajorTick * 0.75 / 2;
XPoint[] points = new XPoint[2];
for (int pointIdx = 0; pointIdx < maxPoints; ++pointIdx)
{
double yMin = 0, yMax = 0, y0 = 0, y1 = 0;
double x0 = x - columnWidth;
double x1 = x + columnWidth;
foreach (SeriesRendererInfo sri in cri.seriesRendererInfos)
{
if (sri._pointRendererInfos.Length <= pointIdx)
{
break;
}
ColumnRendererInfo column = (ColumnRendererInfo)sri._pointRendererInfos[pointIdx];
if (column.Point != null && !double.IsNaN(column.Point._value))
{
double y = column.Point._value;
if (y < 0)
{
y0 = yMin + y;
y1 = yMin;
yMin += y;
}
else
{
y0 = yMax;
y1 = yMax + y;
yMax += y;
}
points[0].Y = x0; // oben links
points[0].X = y0;
points[1].Y = x1; // unten rechts
points[1].X = y1;
cri.plotAreaRendererInfo._matrix.TransformPoints(points);
column.Rect = new XRect(points[0].X,
points[0].Y,
points[1].X - points[0].X,
points[1].Y - points[0].Y);
}
}
x--; // Next stacked column.
}
}
/// <summary>
/// Appends a Bézier curve for a cardinal spline through pt1 and pt2.
/// </summary>
void AppendCurveSegment(XPoint pt0, XPoint pt1, XPoint pt2, XPoint pt3, double tension3)
{
AppendFormat("{0:0.####} {1:0.####} {2:0.####} {3:0.####} {4:0.####} {5:0.####} c\n",
pt1.X + tension3 * (pt2.X - pt0.X), pt1.Y + tension3 * (pt2.Y - pt0.Y),
pt2.X - tension3 * (pt3.X - pt1.X), pt2.Y - tension3 * (pt3.Y - pt1.Y),
pt2.X, pt2.Y);
}
/// <summary> /// When implemented in a derived class renders the 2D code. /// </summary> protected internal abstract void Render(XGraphics gfx, XBrush brush, XPoint center, CancellationToken ct);
void AdjustTextMatrix(ref XPoint pos)
{
XPoint posSave = pos;
pos = pos - new XVector(this.gfxState.realizedTextPosition.x, this.gfxState.realizedTextPosition.y);
this.gfxState.realizedTextPosition = posSave;
}
protected List <Vector3> GetAccuratePointBySector(Vector3 curPosition, XPoint basePoint, float range, float angle, float hitRange, float casterRadius)
{
List <Vector3> list = new List <Vector3>();
SortedDictionary <float, List <Vector3> > sortedDictionary = new SortedDictionary <float, List <Vector3> >();
Vector3 vector = Vector3.get_zero();
Vector3 vector2 = Vector3.get_zero();
if (angle < 180f)
{
Vector3 vector3 = Quaternion.Euler(basePoint.rotation.get_eulerAngles().x, basePoint.rotation.get_eulerAngles().y, basePoint.rotation.get_eulerAngles().z) * Vector3.get_left();
Vector3 vector4 = Quaternion.Euler(basePoint.rotation.get_eulerAngles().x, basePoint.rotation.get_eulerAngles().y, basePoint.rotation.get_eulerAngles().z) * Vector3.get_right();
vector = basePoint.position + vector3 * (casterRadius + hitRange + this.safeDistance);
vector2 = basePoint.position + vector4 * (casterRadius + hitRange + this.safeDistance);
float num = XUtility.DistanceNoY(curPosition, vector);
float num2 = XUtility.DistanceNoY(curPosition, vector2);
if (!sortedDictionary.ContainsKey(num))
{
sortedDictionary.Add(num, new List <Vector3>());
}
sortedDictionary.get_Item(num).Add(vector);
if (!sortedDictionary.ContainsKey(num2))
{
sortedDictionary.Add(num2, new List <Vector3>());
}
sortedDictionary.get_Item(num2).Add(vector2);
if (SystemConfig.IsOpenEffectDrawLine)
{
Debug.DrawLine(curPosition, vector, Color.get_blue(), 2f);
Debug.DrawLine(curPosition, vector2, Color.get_white(), 2f);
}
}
else if (angle < 350f)
{
Vector3 vector5 = Quaternion.Euler(basePoint.rotation.get_eulerAngles().x, basePoint.rotation.get_eulerAngles().y - angle / 2f, basePoint.rotation.get_eulerAngles().z) * Vector3.get_forward();
Vector3 vector6 = Quaternion.Euler(basePoint.rotation.get_eulerAngles().x, basePoint.rotation.get_eulerAngles().y + angle / 2f, basePoint.rotation.get_eulerAngles().z) * Vector3.get_forward();
vector = basePoint.position + vector5 * (casterRadius + hitRange + this.safeDistance);
vector2 = basePoint.position + vector6 * (casterRadius + hitRange + this.safeDistance);
float num = XUtility.DistanceNoY(curPosition, vector);
float num2 = XUtility.DistanceNoY(curPosition, vector2);
if (!sortedDictionary.ContainsKey(num))
{
sortedDictionary.Add(num, new List <Vector3>());
}
sortedDictionary.get_Item(num).Add(vector);
if (!sortedDictionary.ContainsKey(num2))
{
sortedDictionary.Add(num2, new List <Vector3>());
}
sortedDictionary.get_Item(num2).Add(vector2);
}
Random random = new Random();
Vector3 vector7 = Vector3.get_zero();
using (SortedDictionary <float, List <Vector3> > .Enumerator enumerator = sortedDictionary.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <float, List <Vector3> > current = enumerator.get_Current();
List <Vector3> list2 = new List <Vector3>();
list2.AddRange(current.get_Value());
for (int i = 0; i < list2.get_Count(); i++)
{
int num3 = random.Next(i, list2.get_Count());
vector7 = list2.get_Item(i);
list2.set_Item(i, list2.get_Item(num3));
list2.set_Item(num3, vector7);
}
using (List <Vector3> .Enumerator enumerator2 = list2.GetEnumerator())
{
while (enumerator2.MoveNext())
{
Vector3 current2 = enumerator2.get_Current();
list.Add(current2);
}
}
}
}
return(list);
}
// ----- DrawBeziers --------------------------------------------------------------------------
public void DrawBeziers(XPen pen, XPoint[] points)
{
if (pen == null)
throw new ArgumentNullException("pen");
if (points == null)
throw new ArgumentNullException("points");
int count = points.Length;
if (count == 0)
return;
if ((count - 1) % 3 != 0)
throw new ArgumentException("Invalid number of points for bezier curves. Number must fulfil 4+3n.", "points");
Realize(pen);
AppendFormat("{0:0.####} {1:0.####} m\n", points[0].X, points[0].Y);
for (int idx = 1; idx < count; idx += 3)
AppendFormat("{0:0.####} {1:0.####} {2:0.####} {3:0.####} {4:0.####} {5:0.####} c\n",
points[idx].X, points[idx].Y,
points[idx + 1].X, points[idx + 1].Y,
points[idx + 2].X, points[idx + 2].Y);
AppendStrokeFill(pen, null, XFillMode.Alternate, false);
}
/// <summary>
/// Renders the OMR code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
XGraphicsState state = gfx.Save();
switch (Direction)
{
case CodeDirection.RightToLeft:
gfx.RotateAtTransform(180, position);
break;
case CodeDirection.TopToBottom:
gfx.RotateAtTransform(90, position);
break;
case CodeDirection.BottomToTop:
gfx.RotateAtTransform(-90, position);
break;
}
//XPoint pt = center - size / 2;
XPoint pt = position - CodeBase.CalcDistance(AnchorType.TopLeft, Anchor, Size);
uint value;
uint.TryParse(Text, out value);
#if true
// HACK: Project Wallenwein: set LK
value |= 1;
_synchronizeCode = true;
#endif
if (_synchronizeCode)
{
XRect rect = new XRect(pt.X, pt.Y, _makerThickness, Size.Height);
gfx.DrawRectangle(brush, rect);
pt.X += 2 * _makerDistance;
}
for (int idx = 0; idx < 32; idx++)
{
if ((value & 1) == 1)
{
XRect rect = new XRect(pt.X + idx * _makerDistance, pt.Y, _makerThickness, Size.Height);
gfx.DrawRectangle(brush, rect);
}
value = value >> 1;
}
gfx.Restore(state);
}
// ----- DrawPolygon --------------------------------------------------------------------------
public void DrawPolygon(XPen pen, XBrush brush, XPoint[] points, XFillMode fillmode)
{
Realize(pen, brush);
int count = points.Length;
if (points.Length < 2)
throw new ArgumentException("points", PSSR.PointArrayAtLeast(2));
AppendFormat("{0:0.####} {1:0.####} m\n", points[0].X, points[0].Y);
for (int idx = 1; idx < count; idx++)
AppendFormat("{0:0.####} {1:0.####} l\n", points[idx].X, points[idx].Y);
AppendStrokeFill(pen, brush, fillmode, true);
}
/// <summary>
/// Subtracts a vector from a point.
/// </summary>
public static XPoint Subtract(XPoint point, XVector vector)
{
return(new XPoint(point._x - vector.X, point._y - vector.Y));
}
// ----- DrawString ---------------------------------------------------------------------------
public void DrawString(string s, XFont font, XBrush brush, XRect rect, XStringFormat format)
{
Realize(font, brush, 0);
double x = rect.X;
double y = rect.Y;
double lineSpace = font.GetHeight(this.gfx);
//int cellSpace = font.cellSpace; // font.FontFamily.GetLineSpacing(font.Style);
//int cellAscent = font.cellAscent; // font.FontFamily.GetCellAscent(font.Style);
//int cellDescent = font.cellDescent; // font.FontFamily.GetCellDescent(font.Style);
//double cyAscent = lineSpace * cellAscent / cellSpace;
//double cyDescent = lineSpace * cellDescent / cellSpace;
double cyAscent = lineSpace * font.cellAscent / font.cellSpace;
double cyDescent = lineSpace * font.cellDescent / font.cellSpace;
double width = this.gfx.MeasureString(s, font).Width;
bool bold = (font.Style & XFontStyle.Bold) != 0;
bool italic = (font.Style & XFontStyle.Italic) != 0;
bool strikeout = (font.Style & XFontStyle.Strikeout) != 0;
bool underline = (font.Style & XFontStyle.Underline) != 0;
switch (format.Alignment)
{
case XStringAlignment.Near:
// nothing to do
break;
case XStringAlignment.Center:
x += (rect.Width - width) / 2;
break;
case XStringAlignment.Far:
x += rect.Width - width;
break;
}
if (Gfx.PageDirection == XPageDirection.Downwards)
{
switch (format.LineAlignment)
{
case XLineAlignment.Near:
y += cyAscent;
break;
case XLineAlignment.Center:
// TODO use CapHeight. PDFlib also uses 3/4 of ascent
y += (cyAscent * 3 / 4) / 2 + rect.Height / 2;
break;
case XLineAlignment.Far:
y += -cyDescent + rect.Height;
break;
case XLineAlignment.BaseLine:
// nothing to do
break;
}
}
else
{
switch (format.LineAlignment)
{
case XLineAlignment.Near:
y += cyDescent;
break;
case XLineAlignment.Center:
// TODO use CapHeight. PDFlib also uses 3/4 of ascent
y += -(cyAscent * 3 / 4) / 2 + rect.Height / 2;
break;
case XLineAlignment.Far:
y += -cyAscent + rect.Height;
break;
case XLineAlignment.BaseLine:
// nothing to do
break;
}
}
PdfFont realizedFont = this.gfxState.realizedFont;
Debug.Assert(realizedFont != null);
realizedFont.AddChars(s);
OpenTypeDescriptor descriptor = realizedFont.FontDescriptor.descriptor;
if (bold && !descriptor.IsBoldFace)
{
// TODO: emulate bold by thicker outline
}
if (italic && !descriptor.IsBoldFace)
{
// TODO: emulate italic by shearing transformation
}
if (font.Unicode)
{
string s2 = "";
for (int idx = 0; idx < s.Length; idx++)
{
char ch = s[idx];
int glyphID = 0;
if (descriptor.fontData.cmap.symbol)
{
glyphID = (int)ch + (descriptor.fontData.os2.usFirstCharIndex & 0xFF00);
glyphID = descriptor.CharCodeToGlyphIndex((char)glyphID);
}
else
glyphID = descriptor.CharCodeToGlyphIndex(ch);
s2 += (char)glyphID;
}
s = s2;
byte[] bytes = PdfEncoders.RawUnicodeEncoding.GetBytes(s);
bytes = PdfEncoders.FormatStringLiteral(bytes, true, false, true, null);
string text = PdfEncoders.RawEncoding.GetString(bytes, 0, bytes.Length);
XPoint pos = new XPoint(x, y);
AdjustTextMatrix(ref pos);
AppendFormat(
"{0:0.####} {1:0.####} Td {2} Tj\n", pos.x, pos.y, text);
//PdfEncoders.ToStringLiteral(s, PdfStringEncoding.RawEncoding, null));
}
else
{
byte[] bytes = PdfEncoders.WinAnsiEncoding.GetBytes(s);
XPoint pos = new XPoint(x, y);
AdjustTextMatrix(ref pos);
AppendFormat(
"{0:0.####} {1:0.####} Td {2} Tj\n", pos.x, pos.y,
PdfEncoders.ToStringLiteral(bytes, false, null));
}
if (underline)
{
double underlinePosition = lineSpace * realizedFont.FontDescriptor.descriptor.UnderlinePosition / font.cellSpace;
double underlineThickness = lineSpace * realizedFont.FontDescriptor.descriptor.UnderlineThickness / font.cellSpace;
DrawRectangle(null, brush, x, y - underlinePosition, width, underlineThickness);
}
if (strikeout)
{
double strikeoutPosition = lineSpace * realizedFont.FontDescriptor.descriptor.StrikeoutPosition / font.cellSpace;
double strikeoutSize = lineSpace * realizedFont.FontDescriptor.descriptor.StrikeoutSize / font.cellSpace;
DrawRectangle(null, brush, x, y - strikeoutPosition - strikeoutSize, width, strikeoutSize);
}
}
/// <summary> /// When implemented in a derived class renders the 2D code. /// </summary> protected internal abstract void Render(XGraphics gfx, XBrush brush, XPoint center);
private BPoint ReadBPoint()
{
int id = _reader.ReadInt32();
int length = _reader.ReadInt32();
var bpoint = new BPoint()
{
Id = id
};
bpoint.Connected = new int[length];
for (int i = 0; i < length; i++)
{
int connected = _reader.ReadInt32();
bpoint.Connected[i] = connected;
}
double x = _reader.ReadDouble();
double y = _reader.ReadDouble();
var point = new XPoint(x, y)
{
Id = id
};
bpoint.Point = point;
return bpoint;
}
/// <summary>
/// Adds a point and a vector.
/// </summary>
public static XPoint Add(XPoint point, XVector vector)
{
return(new XPoint(point._x + vector.X, point._y + vector.Y));
}
/// <summary>
/// Determines if the specified point is contained within this PdfRectangle.
/// </summary>
public bool Contains(XPoint pt)
{
return(Contains(pt.X, pt.Y));
}
/// <summary>
/// Subtracts a point from a point.
/// </summary>
public static XVector Subtract(XPoint point1, XPoint point2)
{
return(new XVector(point1._x - point2._x, point1._y - point2._y));
}
private static void PrepareInvoiceTop(XGraphics formGfx, XGraphicsState state, string InvoiceNumber)
{
string Headline = "Service Invoice " + InvoiceNumber + "";
string MyName = TimeConnector.Data.Variables.SelectedContractor["CmpName"];
string Phone = TimeConnector.Data.Variables.SelectedContractorContact["ConPhone"];
string MyPhone = "Phone (" + Phone.Substring(0, 3) + ") " + Phone.Substring(4, 3) + "-" + Phone.Substring(7, 4) + "";
string MyEmail = "Email: " + TimeConnector.Data.Variables.SelectedContractorContact["ConEmail"] + "";
string MyAddress = TimeConnector.Data.Variables.SelectedContractor["CmpAddress"];
string MyCityStateZip = "" + TimeConnector.Data.Variables.SelectedContractor["CmpCity"] + ", " + TimeConnector.Data.Variables.SelectedContractor["CmpState"] + " " + TimeConnector.Data.Variables.SelectedContractor["CmpZip"] + "";
string WeekEnding = TimeConnector.Data.Variables.SelectedPaydate["WeekEnd"];
string PayDate = TimeConnector.Data.Variables.SelectedPaydate["PayDate"];
string CompanyName = TimeConnector.Data.Variables.SelectedCompany["CmpName"];
string CompanyContact = "c/o " + TimeConnector.Data.Variables.SelectedContact["ConName"] + "";
string CompanyContactPhone = "" + TimeConnector.Data.Variables.SelectedContact["ConPhone"] + "";
string CompanyContactEmail = "" + TimeConnector.Data.Variables.SelectedContact["ConEmail"] + "";
string CompanyAddress = TimeConnector.Data.Variables.SelectedCompany["CmpAddress"];
string CompanyCityStateZip = "" + TimeConnector.Data.Variables.SelectedCompany["CmpCity"] + ", " + TimeConnector.Data.Variables.SelectedCompany["CmpState"] + " " + TimeConnector.Data.Variables.SelectedCompany["CmpZip"] + "";
//----- Invoice Header
XFont HeaderFont = new XFont("Imprint MT Shadow", 30, XFontStyle.Bold);
string HeaderText = "I N V O I C E";
XStringFormat format = new XStringFormat();
format.Alignment = XStringAlignment.Near;
format.LineAlignment = XLineAlignment.Near;
XColor color = default(XColor);
color = XColor.FromName("SteelBlue");
color.A = 0.5;
XBrush brush = default(XBrush);
brush = new XSolidBrush(color);
XPoint point = new XPoint(410, 20);
formGfx.DrawString(HeaderText, HeaderFont, brush, point, format);
//..... My Company Icon
state = formGfx.Save();
formGfx.DrawImage(XImage.FromFile("Images\\logo.png"), 20, 20, 65, 65);
formGfx.Restore(state);
//..... My Company Information
DrawText(MyName, formGfx, new XFont(PdfFontMyInfo, 15, XFontStyle.Bold), XBrushes.SteelBlue, 95, 20);
DrawText(MyAddress, formGfx, new XFont(PdfFontMyInfo, 7, XFontStyle.Regular), XBrushes.Black, 95, 45);
DrawText(MyCityStateZip, formGfx, new XFont(PdfFontMyInfo, 7, XFontStyle.Regular), XBrushes.Black, 95, 55);
DrawText(MyPhone, formGfx, new XFont(PdfFontMyInfo, 7, XFontStyle.Regular), XBrushes.Black, 95, 65);
DrawText(MyEmail, formGfx, new XFont(PdfFontMyInfo, 7, XFontStyle.Regular), XBrushes.Black, 95, 75);
XPen pen1 = new XPen(XColors.Maroon);
pen1.Width = 1;
//Dim pen2 As New XPen(XColors.Maroon)
XPen pen2 = new XPen(XColors.SteelBlue);
pen2.Width = 2;
//Dim pen3 As New XPen(XColors.SteelBlue)
XPen pen3 = new XPen(XColors.Maroon);
pen3.Width = 1;
formGfx.DrawBeziers(pen1, XPoint.ParsePoints("20,95 80,140 190,70 250,110"));
DrawSignature(formGfx, 531, 696, "LightGray", 1);
DrawSignature(formGfx, 530, 695, "Black", 1.5);
DrawSignature(formGfx, 530, 695, "SteelBlue", 1);
//formGfx.DrawBeziers(pen2, XPoint.ParsePoints("300,100 310,110 340,90 350,100")) 'Top
//formGfx.DrawBeziers(pen2, XPoint.ParsePoints("312,108 322,118 332,99 342,110")) 'Top Center
//formGfx.DrawBeziers(pen2, XPoint.ParsePoints("314,118 324,128 334,109 344,120")) 'Bottom Center
//formGfx.DrawBeziers(pen2, XPoint.ParsePoints("310,130 315,140 330,120 335,130")) 'Bottom
//formGfx.DrawBeziers(pen2, XPoint.ParsePoints("325,100 335,110 325,120 335,130")) 'Center
//formGfx.DrawBeziers(pen3, XPoint.ParsePoints("300,100 310,110 340,90 350,100")) 'Top
//formGfx.DrawBeziers(pen3, XPoint.ParsePoints("312,108 322,118 332,99 342,110")) 'Top Center
//formGfx.DrawBeziers(pen3, XPoint.ParsePoints("314,118 324,128 334,109 344,120")) 'Bottom Center
//formGfx.DrawBeziers(pen3, XPoint.ParsePoints("310,130 315,140 330,120 335,130")) 'Bottom
//formGfx.DrawBeziers(pen3, XPoint.ParsePoints("325,100 335,110 325,120 335,130")) 'Center
//..... ACS Company Icon
DrawText("B I L L T O :", formGfx, new XFont(PdfFont, 9, XFontStyle.Bold), XBrushes.Black, 60, 95);
state = formGfx.Save();
formGfx.DrawImage(XImage.FromFile("Images\\ACSIcon.jpg"), 20, 115, 65, 65);
formGfx.Restore(state);
//..... ACS Company Information
DrawText(CompanyName, formGfx, new XFont(PdfFontMyInfo, 15, XFontStyle.Bold), XBrushes.Green, 95, 115);
DrawText(CompanyContact, formGfx, new XFont(PdfFontMyInfo, 7, XFontStyle.Regular), XBrushes.Black, 95, 135);
DrawText(CompanyAddress, formGfx, new XFont(PdfFontMyInfo, 7, XFontStyle.Regular), XBrushes.Black, 95, 145);
DrawText(CompanyCityStateZip, formGfx, new XFont(PdfFontMyInfo, 7, XFontStyle.Regular), XBrushes.Black, 95, 155);
DrawText(CompanyContactPhone, formGfx, new XFont(PdfFontMyInfo, 7, XFontStyle.Regular), XBrushes.Black, 95, 165);
DrawText(CompanyContactEmail, formGfx, new XFont(PdfFontMyInfo, 7, XFontStyle.Regular), XBrushes.Black, 95, 175);
//..... Invoice Information
DrawLine(formGfx, 450, 590, 80, "SteelBlue", 0.5);
DrawText("Invoice #:", formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Black, 452, 71);
DrawText(InvoiceNumber, formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Maroon, 530, 71);
DrawLine(formGfx, 450, 590, 90, "SteelBlue", 0.5);
DrawText("Week Ending:", formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Black, 452, 81);
DrawText(WeekEnding, formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Black, 530, 81);
DrawLine(formGfx, 450, 590, 100, "SteelBlue", 0.5);
DrawText("Pay Date:", formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Black, 452, 91);
DrawText(PayDate, formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Black, 530, 91);
DrawLine(formGfx, 450, 590, 110, "SteelBlue", 0.5);
DrawText("Hours Worked:", formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Black, 452, 101);
DrawText(TimeConnector.Data.Invoice.FinHour, formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Black, 530, 101);
DrawLine(formGfx, 450, 590, 120, "SteelBlue", 0.5);
DrawText("Balance Due:", formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Black, 452, 111);
DrawText(TimeConnector.Data.Invoice.FinCost, formGfx, new XFont(PdfFont, 7, XFontStyle.Bold), XBrushes.Black, 530, 111);
}
/// <summary>
///
/// </summary>
/// <param name="tl"></param>
/// <param name="br"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <returns></returns>
private static Rect2 CreateRect(XPoint tl, XPoint br, double dx, double dy)
{
return(Rect2.Create(tl, br, dx, dy));
}
