|
public static Inflate ( |
||
| rect | ||
| x | float | |
| y | float | |
| return | ||
static public void DrawNode(ICanvas canvas, UnitPoint nodepoint)
{
RectangleF r = new RectangleF(canvas.ToScreen(nodepoint), new SizeF(0, 0));
r.Inflate(3, 3);
if (r.Right < 0 || r.Left > canvas.ClientRectangle.Width)
return;
if (r.Top < 0 || r.Bottom > canvas.ClientRectangle.Height)
return;
canvas.Graphics.FillRectangle(Brushes.White, r);
r.Inflate(1, 1);
canvas.Graphics.DrawRectangle(Pens.Black, ScreenUtils.ConvertRect(r));
}
/// <summary>
/// Draw a preview of the <see cref="ColorPair"/>
/// </summary>
/// <param name="e">The paint event args providing the <see cref="Graphics"/> and bounding
/// rectangle</param>
public override void PaintValue(PaintValueEventArgs e)
{
ColorPair colorPair = (ColorPair)e.Value ;
using ( SolidBrush b = new SolidBrush(colorPair.Background)) {
e.Graphics.FillRectangle(b, e.Bounds);
}
// Draw the text "ab" using the Foreground/Background values from the ColorPair
using(SolidBrush b = new SolidBrush(colorPair.Foreground)) {
using(Font f = new Font("Arial",6)) {
RectangleF temp = new RectangleF(e.Bounds.Left,e.Bounds.Top,e.Bounds.Height,e.Bounds.Width) ;
temp.Inflate(-2,-2) ;
// Set up how we want the text drawn
StringFormat format = new StringFormat(StringFormatFlags.FitBlackBox | StringFormatFlags.NoWrap) ;
format.Trimming = StringTrimming.EllipsisCharacter ;
format.Alignment = StringAlignment.Center ;
format.LineAlignment = StringAlignment.Center ;
// save the Smoothing mode of the Graphics object so we can restore it
SmoothingMode saveMode = e.Graphics.SmoothingMode ;
e.Graphics.SmoothingMode = SmoothingMode.AntiAlias ;
e.Graphics.DrawString("ab",f,b,temp,format) ;
e.Graphics.SmoothingMode = saveMode ;
}
}
}
void TestStringWithOrigin(Graphics g)
{
for (int multiline = 0; multiline <= 1; ++multiline)
{
for (int h = (int)StringAlignment.Near; h <= (int)StringAlignment.Far; ++h)
{
for (int v = (int)StringAlignment.Near; v <= (int)StringAlignment.Far; ++v)
{
var fmt = new StringFormat((StringAlignment)h, (StringAlignment)v);
PointF origin = new PointF(10 + multiline * 250 + h * 100, 10 + v * 100);
var txt = "test";
if (multiline == 1)
{
txt += "\nfoo bar";
}
var sz = g.MeasureString(txt, font);
var measuredBox = new RectangleF(origin, sz);
measuredBox.X -= h * sz.Width / 2;
measuredBox.Y -= v * sz.Height / 2;
g.FillRectangle(measuredBoxBrush, measuredBox);
g.DrawString(txt, font, textBrush, origin, fmt);
NSColor.Red.SetFill();
var originRect = new RectangleF(origin, new SD.SizeF());
originRect.Inflate(2, 2);
NSBezierPath.FillRect(originRect);
}
}
}
}
public override bool Hit(Point p)
{
Point p1,p2, s;
RectangleF r1, r2;
float o,u;
p1 = From.Point; p2 = To.Point;
// p1 must be the leftmost point.
if (p1.X > p2.X) { s = p2; p2 = p1; p1 = s; }
r1 = new RectangleF(p1.X, p1.Y, 0, 0);
r2 = new RectangleF(p2.X, p2.Y, 0, 0);
r1.Inflate(3, 3);
r2.Inflate(3, 3);
//this is like a topological neighborhood
//the connection is shifted left and right
//and the point under consideration has to be in between.
if (RectangleF.Union(r1, r2).Contains(p))
{
if (p1.Y < p2.Y) //SWNE
{
o = r1.Left + (((r2.Left - r1.Left) * (p.Y - r1.Bottom)) / (r2.Bottom - r1.Bottom));
u = r1.Right + (((r2.Right - r1.Right) * (p.Y - r1.Top)) / (r2.Top - r1.Top));
return ((p.X > o) && (p.X < u));
}
else //NWSE
{
o = r1.Left + (((r2.Left - r1.Left) * (p.Y - r1.Top)) / (r2.Top - r1.Top));
u = r1.Right + (((r2.Right - r1.Right) * (p.Y - r1.Bottom)) / (r2.Bottom - r1.Bottom));
return ((p.X > o) && (p.X < u));
}
}
return false;
}
public static Drawing.Bitmap BuildIcon(string tag, Guid componentId, int width = 24, int height = 24)
{
var bitmap = new Drawing.Bitmap(width, height);
using (var g = Drawing.Graphics.FromImage(bitmap))
{
var textBrush = Drawing.Brushes.Black;
if (Grasshopper.Instances.ComponentServer.EmitObjectIcon(componentId) is Drawing.Bitmap icon)
{
textBrush = Drawing.Brushes.White;
g.DrawImage(icon, Drawing.Point.Empty);
}
else
{
var iconBounds = new Drawing.RectangleF(0, 0, width, height);
iconBounds.Inflate(-0.5f, -0.5f);
using (var capsule = Grasshopper.GUI.Canvas.GH_Capsule.CreateCapsule(iconBounds, Grasshopper.GUI.Canvas.GH_Palette.Transparent))
capsule.Render(g, false, false, false);
}
DrawIconTag(g, textBrush, tag, width, height);
}
return(bitmap);
}
public void Draw(System.Drawing.Graphics g, System.Drawing.RectangleF innerArea)
{
innerArea.Inflate(_shadowLength / 2, _shadowLength / 2); // Padding
RectangleF outerArea = innerArea;
outerArea.Inflate(_shadowLength, _shadowLength);
_brush.Rectangle = outerArea;
g.FillRectangle(_brush, outerArea);
SolidBrush twhite = new SolidBrush(Color.FromArgb(128, 255, 255, 255));
g.FillPolygon(twhite, new PointF[] {
new PointF(outerArea.Left, outerArea.Top), // upper left point
new PointF(outerArea.Right, outerArea.Top), // go to the right
new PointF(innerArea.Right, innerArea.Top), // go 45 deg left down in the upper right corner
new PointF(innerArea.Left, innerArea.Top), // upper left corner of the inner rectangle
new PointF(innerArea.Left, innerArea.Bottom), // lower left corner of the inner rectangle
new PointF(outerArea.Left, outerArea.Bottom) // lower left corner
});
SolidBrush tblack = new SolidBrush(Color.FromArgb(128, 0, 0, 0));
g.FillPolygon(tblack, new PointF[] {
new PointF(outerArea.Right, outerArea.Bottom),
new PointF(outerArea.Right, outerArea.Top),
new PointF(innerArea.Right, innerArea.Top),
new PointF(innerArea.Right, innerArea.Bottom), // upper left corner of the inner rectangle
new PointF(innerArea.Left, innerArea.Bottom), // lower left corner of the inner rectangle
new PointF(outerArea.Left, outerArea.Bottom) // lower left corner
});
}
public System.Drawing.RectangleF MeasureItem(System.Drawing.Graphics g, System.Drawing.RectangleF innerArea)
{
innerArea.Inflate(_shadowLength / 2, _shadowLength / 2);
innerArea.Width += _shadowLength;
innerArea.Height += _shadowLength;
return(innerArea);
}
protected override void OnPaintBackground(PaintEventArgs pevent)
{
base.OnPaintBackground(pevent);
pevent.Graphics.Clear(Color.FromArgb(0));
foreach (TabPage tab in this.TabPages)
{
Rectangle tabRect = GetTabRect(this.TabPages.IndexOf(tab));
using (StringFormat sf = new StringFormat(StringFormatFlags.NoWrap))
{
sf.Alignment = StringAlignment.Center;
sf.LineAlignment = StringAlignment.Center;
SizeF textSize = pevent.Graphics.MeasureString(tab.Text, this.Font);
RectangleF rc = new RectangleF(tabRect.Left + ((tabRect.Width / 2) - (textSize.Width / 2)), tabRect.Top + tabRect.Height / 2 - textSize.Height / 2, textSize.Width, textSize.Height);
rc.Inflate(4, 5);
GraphicsPath path = new GraphicsPath();
path.AddRectangle(rc);
using (PathGradientBrush brush = new PathGradientBrush(path))
{
brush.CenterColor = Color.FromArgb(192, tab == this.SelectedTab ? Color.Red : Color.Black);
brush.SurroundColors = new Color[] { Color.Black };
pevent.Graphics.FillRectangle(brush,rc);
}
var tc = new SolidBrush(Color.FromArgb(tab.ForeColor.A, tab.ForeColor.R, tab.ForeColor.G, tab.ForeColor.B));
pevent.Graphics.DrawString(tab.Text, this.Font, tc, rc, sf);
}
}
}
/// <summary>
/// Inflate Shared Method
/// </summary>
///
/// <remarks>
/// Produces a new RectangleF by inflating an existing
/// RectangleF by the specified coordinate values.
/// </remarks>
public static RectangleF Inflate (RectangleF rect,
float x, float y)
{
RectangleF ir = new RectangleF (rect.X, rect.Y, rect.Width, rect.Height);
ir.Inflate (x, y);
return ir;
}
GetRectangleTransformation
(
RectangleF rectangle1,
RectangleF rectangle2
)
{
Debug.Assert(rectangle1.Width >= 0);
Debug.Assert(rectangle1.Height >= 0);
Debug.Assert(rectangle2.Width >= 0);
Debug.Assert(rectangle2.Height >= 0);
// Handle collapsed rectangles, which can result, for example, when a
// graph contains only one vertex.
if (rectangle1.Width == 0)
{
rectangle1.Inflate(1, 0);
}
if (rectangle1.Height == 0)
{
rectangle1.Inflate(0, 1);
}
if (rectangle2.Width == 0)
{
rectangle2.Inflate(1, 0);
}
if (rectangle2.Height == 0)
{
rectangle2.Inflate(0, 1);
}
Matrix oMatrix = new Matrix(
rectangle1,
new PointF [] {
rectangle2.Location,
new PointF(rectangle2.Right, rectangle2.Top),
new PointF(rectangle2.Left, rectangle2.Bottom)
}
);
return (oMatrix);
}
public override bool Hit(System.Drawing.PointF p)
{
bool join = false;
// points = new PointF[2+insertionPoints.Count];
// points[0] = p1;
// points[2+insertionPoints.Count-1] = p2;
// for(int m=0; m<insertionPoints.Count; m++)
// {
// points[1+m] = (PointF) insertionPoints[m];
// }
PointF[] points = mPoints;
PointF p1 = this.mConnection.From.AdjacentPoint;
PointF p2 = this.mConnection.To.AdjacentPoint;
PointF s;
float o, u;
RectangleF r1=RectangleF.Empty, r2=RectangleF.Empty, r3=RectangleF.Empty;
//Tomas Kuchar wrote
if (points == null)
return join;
for(int v = 0; v<points.Length-1; v++)
{
//this is the usual segment test
//you can do this because the PointF object is a value type!
p1 = points[v]; p2 = points[v+1];
// p1 must be the leftmost point.
if (p1.X > p2.X) { s = p2; p2 = p1; p1 = s; }
r1 = new RectangleF(p1.X, p1.Y, 0, 0);
r2 = new RectangleF(p2.X, p2.Y, 0, 0);
r1.Inflate(3, 3);
r2.Inflate(3, 3);
//this is like a topological neighborhood
//the connection is shifted left and right
//and the point under consideration has to be in between.
if (RectangleF.Union(r1, r2).Contains(p))
{
if (p1.Y < p2.Y) //SWNE
{
o = r1.Left + (((r2.Left - r1.Left) * (p.Y - r1.Bottom)) / (r2.Bottom - r1.Bottom));
u = r1.Right + (((r2.Right - r1.Right) * (p.Y - r1.Top)) / (r2.Top - r1.Top));
join |= ((p.X > o) && (p.X < u));
}
else //NWSE
{
o = r1.Left + (((r2.Left - r1.Left) * (p.Y - r1.Top)) / (r2.Top - r1.Top));
u = r1.Right + (((r2.Right - r1.Right) * (p.Y - r1.Bottom)) / (r2.Bottom - r1.Bottom));
join |= ((p.X > o) && (p.X < u));
}
}
}
return join;
}
public DetectedFrame(RECTF r, float rs, DateTime t, Score s)
{
Region = r;
Time = t;
Score = s;
Region.Inflate(rs, rs);
}
private RectangleF GetOurRectangle()
{
RectangleF rectF = new RectangleF(this.Location, new SizeF(0, 0));
float ratio = 1.0f / (float)OwnerList.ScaleFactor.Ratio;
float ourSize = UI.ScaleWidth(size);
rectF.Inflate(ratio * ourSize, ratio * ourSize);
return rectF;
}
public override void DrawUserHeader(IGUIContext gfx, System.Drawing.RectangleF rect, string UserName)
{
gfx.DrawGrayButton(rect);
if (rect.Width > 4)
{
rect.Offset(2, 1);
rect.Inflate(-2, 0);
gfx.DrawString(UserName, BaseFont, SummerGUI.Theme.Brushes.Base03, rect, m_UserHeaderFormat);
}
}
protected override void Render(RectangleF sourceBounds, Matrix transform, Graphics g)
{
g.SmoothingMode = SmoothingMode.AntiAlias;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.Transform = transform;
sourceBounds.Inflate(1, 1); // allow for pen widths
g.SetClip(sourceBounds);
foreach (IPrintingAdapter printingAdapter in m_viewingContext.Control.AsAll<IPrintingAdapter>())
printingAdapter.Print(this, g);
}
/// <summary>
/// Shortens the height or narrows the width of a rectangle to match the specified aspect ratio.
/// </summary>
/// <param name="rectangle"></param>
/// <param name="aspectRatio"></param>
/// <returns></returns>
public static RectangleF ToAspectRatioB(RectangleF rectangle, float aspectRatio)
{
float projectedAspect = ((float)rectangle.Width / (float)rectangle.Height);
if (aspectRatio > projectedAspect)
{
#if !PocketPC
rectangle.Inflate(0, (rectangle.Width / aspectRatio - rectangle.Height) * .5f);
#else
return RectangleFHelper.Inflate(rectangle, 0, (rectangle.Width / aspectRatio - rectangle.Height) * .5f);
#endif
}
else if (aspectRatio < projectedAspect)
{
#if !PocketPC
rectangle.Inflate((aspectRatio * rectangle.Height - rectangle.Width) * .5f, 0);
#else
return RectangleFHelper.Inflate(rectangle, (aspectRatio * rectangle.Height - rectangle.Width) * .5f, 0);
#endif
}
return rectangle;
}
public override void DrawGlyph(PaintEventArgs e, Rectangle bounds)
{
GraphicsPath path;
int num = Math.Max(0, (bounds.Width - bounds.Height) / 2);
int num2 = Math.Max(0, (bounds.Height - bounds.Width) / 2);
bounds.Inflate(-num, -num2);
if ((bounds.Width % 2) == 1)
{
bounds.Width--;
}
if ((bounds.Height % 2) == 1)
{
bounds.Height--;
}
if (bounds.Width > bounds.Height)
{
bounds.Width = bounds.Height;
}
if (bounds.Height > bounds.Width)
{
bounds.Height = bounds.Width;
}
bounds.Inflate(-2, -2);
int width = bounds.Width;
int num4 = width / 3;
int num5 = width / 4;
int num6 = bounds.X + (bounds.Width / 2);
float x = bounds.X + (0.5f * (bounds.Width + 3));
float num8 = x - 3f;
SmoothingMode smoothingMode = e.Graphics.SmoothingMode;
e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
using (path = new GraphicsPath())
{
Point[] points = new Point[] { new Point(bounds.Left + num4, bounds.Bottom), new Point(bounds.Right - num4, bounds.Bottom), new Point(bounds.Right, bounds.Bottom - num4), new Point(bounds.Right, bounds.Top + num4), new Point(bounds.Right - num4, bounds.Top), new Point(bounds.Left + num4, bounds.Top), new Point(bounds.Left, bounds.Top + num4), new Point(bounds.Left, bounds.Bottom - num4) };
path.AddLines(points);
path.CloseAllFigures();
e.Graphics.FillPath(Brushes.Red, path);
e.Graphics.DrawPath(Pens.DarkGray, path);
}
using (path = new GraphicsPath())
{
PointF[] tfArray = new PointF[] { new PointF(num8, (float) ((bounds.Top + num5) - 1)), new PointF(x, (float) ((bounds.Top + num5) - 1)), new PointF(num6 + 1.2f, (-0.5f + bounds.Top) + ((bounds.Height * 2f) / 3f)), new PointF(num6 - 1.2f, (-0.5f + bounds.Top) + ((bounds.Height * 2f) / 3f)) };
path.AddLines(tfArray);
path.CloseAllFigures();
e.Graphics.FillPath(Brushes.White, path);
}
RectangleF rect = new RectangleF((float) num6, (float) (bounds.Bottom - num5), 0f, 0f);
rect.Inflate(1.5f, 1.5f);
e.Graphics.FillEllipse(Brushes.White, rect);
e.Graphics.SmoothingMode = smoothingMode;
}
public static Drawing.Bitmap BuildIcon(string tag, int width = 24, int height = 24)
{
var bitmap = new Drawing.Bitmap(width, height);
using (var g = Drawing.Graphics.FromImage(bitmap))
{
var iconBounds = new Drawing.RectangleF(0, 0, width, height);
iconBounds.Inflate(-0.5f, -0.5f);
using (var capsule = Grasshopper.GUI.Canvas.GH_Capsule.CreateCapsule(iconBounds, Grasshopper.GUI.Canvas.GH_Palette.Transparent))
capsule.Render(g, false, false, false);
g.SmoothingMode = Drawing.Drawing2D.SmoothingMode.AntiAlias;
g.InterpolationMode = Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
g.PixelOffsetMode = Drawing.Drawing2D.PixelOffsetMode.HighQuality;
var rect = new Drawing.RectangleF(0.5f, 1.0f, width, height);
var format = new Drawing.StringFormat()
{
Alignment = Drawing.StringAlignment.Center,
LineAlignment = Drawing.StringAlignment.Center,
Trimming = Drawing.StringTrimming.Character,
FormatFlags = Drawing.StringFormatFlags.NoWrap
};
float emSize = ((float)(width) / ((float)tag.Length));
if (width == 24)
{
switch (tag.Length)
{
case 1: emSize = 20.0f; break;
case 2: emSize = 13.0f; break;
case 3: emSize = 11.0f; break;
case 4: emSize = 8.0f; break;
default: emSize = 7.0f; break;
}
}
// Avoid using ClearType rendering on icons that the user can zoom in like icons on Grashopper components.
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
using (var Calibri = new System.Drawing.Font("Calibri", emSize, Drawing.GraphicsUnit.Pixel))
g.DrawString(tag, Calibri, Drawing.Brushes.Black, rect, format);
}
return(bitmap);
}
public override void Draw(ICanvas canvas, RectangleF unitrect)
{
Color color = Color;
Pen pen = canvas.CreatePen(color, Width);
if (Highlighted || Selected)
{
pen = Canvas.DrawTools.DrawUtils.SelectedPen;
//if (m_p1.IsEmpty == false) Canvas.DrawTools.DrawUtils.DrawNode(canvas, m_p1);
}
pen = new Pen(pen.Color, (float)6);
unitrect.Inflate(3, 3);
canvas.DrawArc(canvas,pen,m_p1,(float)0.05,0,360);
}
public Maze(Size size)
{
MapSize = new Size(MazeSettings.CurrentRowSize, MazeSettings.CurrentColSize);
MapRowData = new byte[MapSize.Width, MapSize.Height - 1]; // 横向门 --
MapColData = new byte[MapSize.Width - 1, MapSize.Height]; // 纵向门 ||
MapRect = new Rectangle(Point.Empty, MapSize);
MzSize = size;
MzBitmap = new Bitmap(size.Width, size.Height);
MzGraphics = Graphics.FromImage(MzBitmap);
MapRectF = new RectangleF(Point.Empty, MzSize);
MapRectF.Inflate(-MazeSettings.CurrentBorderSize, -MazeSettings.CurrentBorderSize);
PtStart = Point.Empty;
PtEnd = new Point(MapSize.Width - 1, MapSize.Height - 1);
GenerateGridLines();
GenerateMaze();
}
public static Drawing.Bitmap BuildIcon(string tag, int width = 24, int height = 24)
{
var bitmap = new Drawing.Bitmap(width, height);
using (var g = Drawing.Graphics.FromImage(bitmap))
{
var iconBounds = new Drawing.RectangleF(0, 0, width, height);
iconBounds.Inflate(-0.5f, -0.5f);
using (var capsule = Grasshopper.GUI.Canvas.GH_Capsule.CreateCapsule(iconBounds, Grasshopper.GUI.Canvas.GH_Palette.Transparent))
capsule.Render(g, false, false, false);
DrawIconTag(g, Drawing.Brushes.Black, tag, width, height);
}
return(bitmap);
}
public RectangleF PaintSymbol(System.Drawing.Graphics g, System.Drawing.RectangleF bounds)
{
if (Shape != XYPlotScatterStyles.Shape.NoSymbol)
{
GraphicsState gs = g.Save();
g.TranslateTransform(bounds.X + 0.5f * bounds.Width, bounds.Y + 0.5f * bounds.Height);
Paint(g);
g.Restore(gs);
if (this.SymbolSize > bounds.Height)
{
bounds.Inflate(0, this.SymbolSize - bounds.Height);
}
}
return(bounds);
}
public RectangleF PaintSymbol(System.Drawing.Graphics g, System.Drawing.RectangleF bounds)
{
if (_scatterSymbol is NoSymbol)
{
return(bounds);
}
var cachedPathData = new CachedPathData();
var cachedBrushData = new CachedBrushData();
var scatterSymbol = CalculateOverriddenScatterSymbol();
CalculatePaths(scatterSymbol, _symbolSize, ref cachedPathData);
CalculateBrushes(scatterSymbol, _color, cachedPathData, ref cachedBrushData);
GraphicsState gs = g.Save();
g.TranslateTransform(bounds.X + 0.5f * bounds.Width, bounds.Y + 0.5f * bounds.Height);
if (null != cachedPathData.InsetPath)
{
g.FillPath(cachedBrushData.InsetBrush, cachedPathData.InsetPath);
}
if (null != cachedPathData.FillPath)
{
g.FillPath(cachedBrushData.FillBrush, cachedPathData.FillPath);
}
if (null != cachedPathData.FramePath)
{
g.FillPath(cachedBrushData.FrameBrush, cachedPathData.FramePath);
}
cachedBrushData.Clear();
cachedPathData.Clear();
g.Restore(gs);
if (SymbolSize > bounds.Height)
{
bounds.Inflate(0, (float)(SymbolSize - bounds.Height));
}
return(bounds);
}
public ChartCanvas(RectangleF rect)
: base(rect)
{
ContentMode = UIViewContentMode.Redraw;
this.AutoresizingMask = UIViewAutoresizing.All;
this.BackColor = Color.Wheat;
var panelRect = new RectangleF(rect.X,rect.Y,rect.Width,rect.Height-20 / UIScreen.MainScreen.Scale);
panelRect.Inflate(-20 / UIScreen.MainScreen.Scale,-20 / UIScreen.MainScreen.Scale);
panel1 = new PlotPanel(panelRect);
panel1.BackColor = Color.AliceBlue;
this.AddSubview(panel1);
// Subscribing to a paint eventhandler to drawingPanel:
panel1.Paint +=
new PaintEventHandler(PlotPanelPaint);
}
public override void Render(Graphics graphics, Map mapBox)
{
if (string.IsNullOrEmpty(Text))
return;
var measure = graphics.MeasureString(Text, SystemFonts.DefaultFont);
var x = 25f;
var y = (mapBox.Size.Height - measure.Height) - 20;
var rectangle = new RectangleF(x, y, measure.Width, measure.Height); //25 from the bottom
rectangle.Inflate(5, 3);
graphics.FillRectangle(BgBrush, rectangle);
//graphics.DrawRectangle(Pens.Black, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
graphics.DrawString(Text, SystemFonts.DefaultFont, Brushes.Black, x, y);
}
public override void PaintValue(PaintValueEventArgs e)
{
MindFusion.FlowChartX.ShapeTemplate shape =
e.Value as MindFusion.FlowChartX.ShapeTemplate;
if (shape == null)
return;
// Draw the shape
RectangleF rect = new RectangleF(
(float)e.Bounds.Left, (float)e.Bounds.Top,
(float)e.Bounds.Width - 1, (float)e.Bounds.Height - 1);
rect.Inflate(-2, -2);
MindFusion.FlowChartX.ShapeTemplate.PathData data =
shape.initData(rect, 0);
System.Drawing.Brush brush =
new System.Drawing.SolidBrush(Color.LightSteelBlue);
System.Drawing.Pen pen =
new System.Drawing.Pen(Color.Black);
System.Drawing.Drawing2D.SmoothingMode mode =
e.Graphics.SmoothingMode;
e.Graphics.SmoothingMode =
System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
System.Drawing.Drawing2D.GraphicsPath path =
shape.getPath(data, 0);
e.Graphics.FillPath(brush, path);
e.Graphics.DrawPath(pen, path);
path.Dispose();
path = shape.getDecorationPath(data, 0);
if (path != null)
{
e.Graphics.DrawPath(pen, path);
path.Dispose();
}
e.Graphics.SmoothingMode = mode;
pen.Dispose();
brush.Dispose();
}
public override void Draw(ICanvas canvas, RectangleF unitrect)
{
Brush B = Brushes.Black;
Color color = Color;
Pen pen = canvas.CreatePen(color, Width);
if (Highlighted || Selected)
{
pen = Canvas.DrawTools.DrawUtils.SelectedPen;
B = Brushes.Magenta;
//if (m_p1.IsEmpty == false) Canvas.DrawTools.DrawUtils.DrawNode(canvas, m_p1);
}
pen = new Pen(pen.Color, (float)6);
unitrect.Inflate(3, 3);
canvas.DrawArc(canvas, pen, m_p1, (float)0.03, 0, 360);
float size = (canvas.ToScreen(new UnitPoint(m_p1.X + 1, m_p1.Y)).X - canvas.ToScreen(m_p1).X)/10;
Font m_font = new System.Drawing.Font("Arial Black", size, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
canvas.Graphics.DrawString("Line Config", m_font, B, canvas.ToScreen(new UnitPoint(m_p1.X - 0.4, m_p1.Y + 0.2)).X, canvas.ToScreen(new UnitPoint(m_p1.X - 0.3, m_p1.Y + 0.2)).Y);
}
public void Draw(System.Drawing.Graphics g, System.Drawing.RectangleF innerArea)
{
if (null == _cachedShadowBrush)
{
SetCachedBrushes();
}
innerArea.Inflate(_shadowLength / 2, _shadowLength / 2);
// please note: m_Bounds is already extended to the shadow
// first the shadow
_cachedShadowBrush.Rectangle = innerArea;
g.TranslateTransform(_shadowLength, _shadowLength);
g.FillRectangle(_cachedShadowBrush, innerArea);
g.TranslateTransform(-_shadowLength, -_shadowLength);
_brush.Rectangle = innerArea;
g.FillRectangle(_brush, innerArea);
g.DrawRectangle(Pens.Black, innerArea.Left, innerArea.Top, innerArea.Width, innerArea.Height);
}
public override void Decorate(ImageDecoratorContext context)
{
Bitmap polaroidBorder = ResourceHelper.LoadAssemblyResourceBitmap("PostHtmlEditing.ImageEditing.Images.PolaroidBorder2.png");
DropShadowBorderDecoratorSettings settings = new DropShadowBorderDecoratorSettings(context);
Size originalSize = context.Image.Size;
float scaleX = originalSize.Width / (float)PORTAL_RECT.Width;
float scaleY = originalSize.Height / (float)PORTAL_RECT.Height;
Size finalSize = new Size((int)(polaroidBorder.Width * scaleX), (int)(polaroidBorder.Height * scaleY));
Bitmap output = new Bitmap(finalSize.Width, finalSize.Height);
using (Graphics g = Graphics.FromImage(output))
{
using (SolidBrush b = new SolidBrush(settings.BackgroundColor))
g.FillRectangle(b, 0, 0, output.Width, output.Height);
g.CompositingMode = CompositingMode.SourceOver;
g.CompositingQuality = CompositingQuality.HighQuality;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
RectangleF realPortal = new RectangleF(
PORTAL_RECT.X * scaleX,
PORTAL_RECT.Y * scaleY,
PORTAL_RECT.Width * scaleX,
PORTAL_RECT.Height * scaleY);
realPortal.Inflate(1, 1);
g.DrawImage(context.Image, realPortal, new RectangleF(0, 0, originalSize.Width, originalSize.Height), GraphicsUnit.Pixel);
g.DrawImage(polaroidBorder, 0, 0, output.Width, output.Height);
}
context.Image = output;
context.BorderMargin = new ImageBorderMargin(
output.Width - originalSize.Width, output.Height - originalSize.Height,
new BorderCalculation(output.Width / (float)originalSize.Width, output.Height / (float)originalSize.Height));
HideHtmlBorder(context);
}
/// <summary>
/// Handles mouse movement
/// </summary>
/// <param name="e"></param>
protected override void OnMouseMove(MouseEventArgs e)
{
_highlightTimer.Stop();
// Activate buttons only if the mouse is over them. Inactivate them otherwise.
bool invalid = UpdateHighlight(e.Location);
// Sliders
RectangleF area = new RectangleF();
if (HorizontalSlider.IsDragging)
{
area = HorizontalSlider.Bounds;
PointF loc = HorizontalSlider.Position;
loc.X = e.X;
HorizontalSlider.Position = loc;
area = RectangleF.Union(area, HorizontalSlider.Bounds);
}
area.Inflate(10F, 10F);
if(invalid == false) Invalidate(new Region(area));
if (VerticalSlider.IsDragging)
{
area = VerticalSlider.Bounds;
PointF loc = VerticalSlider.Position;
loc.Y = e.Y;
VerticalSlider.Position = loc;
area = RectangleF.Union(area, VerticalSlider.Bounds);
}
area.Inflate(10F, 10F);
if(invalid == false) Invalidate(new Region(area));
if (invalid) Invalidate();
base.OnMouseMove(e);
_highlightTimer.Start();
}
public void UpdateBoundingBox()
{
this.CenterPoint.X = TopLeftCorner.X + Width / 2;
this.CenterPoint.Y = TopLeftCorner.Y + Height / 2;
inflatedBox = new RectangleF(TopLeftCorner.X, TopLeftCorner.Y, Width, Height);
inflatedBox.Inflate(View.ViewFactory.EdgeBoxWidth / 2, View.ViewFactory.EdgeBoxWidth / 2);
RecomputeEdgePoints();
}
public override void Draw(Graphics g)
{
//Show only if its collidable
if (!HasPegInfo) {
if (Level.ShowCollision && !Collision)
return;
}
base.Draw(g);
//Get the circle image
Image circleImage = GetCircleImage();
//Set the location
PointF location = DrawLocation;
//Set the draw bounds
RectangleF drawbounds = new RectangleF(location.X - mRadius, location.Y - mRadius, mRadius * 2, mRadius * 2);
if (Level.ShowCollision || (!HasPegInfo && circleImage == null)) {
if (!Level.ShowPreview) {
//Draw the collision white circle
g.FillEllipse(Brushes.White, drawbounds);
}
} else {
if (HasPegInfo) {
//Draw the PeggleEdit style peg
g.FillEllipse(new SolidBrush(PegInfo.GetOuterColour()), drawbounds);
drawbounds.Inflate(-2, -2);
g.FillEllipse(new SolidBrush(PegInfo.GetInnerColour()), drawbounds);
} else {
//Draw the circle image
g.DrawImage(circleImage, location.X - (circleImage.Width / 2), location.Y - (circleImage.Height / 2), circleImage.Width, circleImage.Height);
}
}
}
internal override RectangleF getRepaintRect(bool connected)
{
RectangleF result = new RectangleF(0, 0, 0, 0);
if (!connected)
result = getBoundingRect();
else
{
RectangleF rc = getBoundingRect();
InvalidAreaUpdater inv = new InvalidAreaUpdater(rc, false);
visitHierarchy(inv);
result = inv.getInvalidRect();
}
result.Inflate(flowChart.SelHandleSize, flowChart.SelHandleSize);
if (selectedBoxes.Count > 0)
{
// some boxes might be rotated and their rotation handles
// be quite outside the selection rectangle
float infl = 6 * Constants.getMillimeter(flowChart.MeasureUnit);
result.Inflate(infl, infl);
}
return result;
}
// draws a single char to the graphics object within specified rectangle
// can be used with any graphical object
public void DrawChar(ulong bits, Graphics g, Rectangle rect)
{
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
float size = rect.Height / VSEGMENTS; // height and width makes a square
float space = (size * segmentSpace) / 2; // space between segments
using (SolidBrush segmentBrush = new SolidBrush(ForeColor))
{
for (int y = 0; y < VSEGMENTS; y++) // vertical row
{
for (int x = 0; x < HSEGMENTS; x++) // horizontal row
{
if ((bits & 1) != 0) // if bit 1 is set, fill segment
{
RectangleF segmentRect = new RectangleF(rect.X + x * size, y * size, size, size);
if ((space * 2) < size) // don't inflate to zero
segmentRect.Inflate(-space, -space);
g.FillEllipse(segmentBrush, segmentRect);
}
bits = bits >> 1; // roll bits to the right
}
}
}
}
/// <returns>true, if the selection should continue in the background of the bar.</returns>
public bool MouseDown(MouseEventArgs e, Size parentControlSize, Vector2 clickPos)
{
_selectionMode = SelectionMode.None;
_overallDelta = 0;
// check if the mouse click was in the bar area
RectangleF barArea = getBarArea(parentControlSize);
RectangleF selectionArea = barArea;
selectionArea.Inflate(10.0f, _selectionMaxPixelDistanceForMove * 0.8f);
if (!selectionArea.Contains(e.Location))
{
return(true);
}
switch (e.Button)
{
case MouseButtons.Left:
// check if the mouse click was on one of the two sliders
float distanceToSelectedLimit0 = Math.Abs(e.Y - ToVisualY(barArea, _selectedLimit0));
float distanceToSelectedLimit1 = Math.Abs(e.Y - ToVisualY(barArea, _selectedLimit1));
if (distanceToSelectedLimit0 < distanceToSelectedLimit1)
{
if (distanceToSelectedLimit0 < _selectionMaxPixelDistanceForMove)
{
_selectionMode = SelectionMode.SelectedLimit0;
}
}
else
{
if (distanceToSelectedLimit1 < _selectionMaxPixelDistanceForMove)
{
_selectionMode = SelectionMode.SelectedLimit1;
}
}
// check if a the click happend on a room
if (barArea.Contains(e.Location) && _selectionMode == SelectionMode.None)
{
for (int groupIndex = 0; groupIndex < GroupCount; ++groupIndex)
{
RectangleF groupArea = groupGetArea(barArea, groupIndex);
if (groupArea.Contains(e.Location))
{
_groupMouseClicked = groupIndex;
float mouseDepth = FromVisualY(barArea, e.Y);
List <List <RelevantRoom> > roomSequences = groupBuildRoomSequences(clickPos, groupIndex);
float sequenceWidth = groupArea.Width / roomSequences.Count;
for (int i = 0; i < roomSequences.Count; ++i)
{
float posX0 = groupArea.X + sequenceWidth * i;
float posX1 = groupArea.X + sequenceWidth * (i + 1);
if (e.X >= posX0 && e.X <= posX1)
{
for (int j = roomSequences[i].Count - 1; j >= 0; --j)
{
if (mouseDepth <= roomSequences[i][j].MaxDepth && mouseDepth >= roomSequences[i][j].MinDepth)
{
_roomMouseClicked = roomSequences[i][j].Room;
_roomMouseOffset = mouseDepth - _roomMouseClicked.Position.Y;
// If multiple rooms are selected, don't reset selection.
if (_editor.SelectedRooms.Count <= 1 || !_editor.SelectedRooms.Contains(_roomMouseClicked))
{
SelectedRoom?.Invoke(new[] { _roomMouseClicked });
}
InvalidateParent?.Invoke();
_selectionMode = SelectionMode.RoomMove;
return(false);
}
}
}
}
break;
}
}
selectionArea.Y = ToVisualY(barArea, Math.Max(_selectedLimit0, _selectedLimit1));
selectionArea.Height = Math.Abs(ToVisualY(barArea, _selectedLimit0) - ToVisualY(barArea, _selectedLimit1));
if (selectionArea.Contains(e.Location))
{
_barMouseOffset = distanceToSelectedLimit0;
_selectionMode = SelectionMode.SelectedLimitBoth;
}
}
break;
case MouseButtons.Middle:
case MouseButtons.XButton1:
case MouseButtons.XButton2:
for (int groupIndex = 0; groupIndex < DepthProbes.Count; ++groupIndex)
{
RectangleF groupArea = groupGetArea(barArea, groupIndex);
if (groupArea.Contains(e.Location))
{
DepthProbes.RemoveAt(groupIndex);
InvalidateParent?.Invoke();
break;
}
}
break;
}
return(false);
}
public override bool IsClicked(Point pos)
{
// Create an array containing all the points in the path
Point[] pathPoints = new Point[points.Count + 1];
pathPoints[0] = location;
Array.Copy(points.ToArray(), 0, pathPoints, 1, points.Count);
// Loop through all the line segments and check if `pos` is close enough to one of them
for(int i = 0; i < pathPoints.Length - 1; ++i)
{
RectangleF bounds = new RectangleF(
new Point(Math.Min(pathPoints[i].X, pathPoints[i + 1].X), Math.Min(pathPoints[i].Y, pathPoints[i + 1].Y)),
new Size(Math.Abs(pathPoints[i].X - pathPoints[i + 1].X), Math.Abs(pathPoints[i].Y - pathPoints[i + 1].Y)));
bounds.Inflate(ALLOWED_ERROR + penWidth / 2, ALLOWED_ERROR + penWidth / 2);
if(bounds.Contains(pos) && LayerLine.DistanceToLine(pathPoints[i], pathPoints[i + 1], pos) < ALLOWED_ERROR + penWidth / 2)
return true;
}
// No line segment found that is close enough, so we return false
return false;
}
public async Task MemoryRenderTarget_2DInitError()
{
await TestUtilities.InitializeWithGraphicsAsync();
// Ensure that any async disposal is done before we create a new GraphicsCore
await GraphicsCore.Current.MainLoop !.WaitForNextPassedLoopAsync();
await GraphicsCore.Current.MainLoop !.WaitForNextPassedLoopAsync();
GDI.Bitmap?screenshot = null;
using (TestUtilities.FailTestOnInternalExceptions())
using (GraphicsCore.AutomatedTest_NewTestEnvironment())
{
await GraphicsCore.Loader
.ConfigureLoading(settings => settings.ThrowD2DInitDeviceError = true)
.LoadAsync();
Assert.IsTrue(GraphicsCore.IsLoaded);
Assert.IsFalse(GraphicsCore.Current.DefaultDevice !.Supports2D);
using (var solidBrush = new SolidBrushResource(Color4.Gray))
using (var textFormat = new TextFormatResource("Arial", 36))
using (var textBrush = new SolidBrushResource(Color4.RedColor))
using (var memRenderTarget = new MemoryRenderTarget(1024, 1024))
{
memRenderTarget.ClearColor = Color4.CornflowerBlue;
// Get and configure the camera
var camera = (PerspectiveCamera3D)memRenderTarget.Camera;
camera.Position = new Vector3(0f, 5f, -7f);
camera.Target = new Vector3(0f, 0f, 0f);
camera.UpdateCamera();
// 2D rendering is made here
var d2dDrawingLayer = new Custom2DDrawingLayer(graphics =>
{
var d2dRectangle = new GDI.RectangleF(10, 10, 236, 236);
graphics.Clear(Color4.LightBlue);
graphics.FillRoundedRectangle(
d2dRectangle, 30, 30,
solidBrush);
d2dRectangle.Inflate(-10, -10);
graphics.DrawText("Hello Direct2D!", textFormat, d2dRectangle, textBrush);
});
// Define scene
await memRenderTarget.Scene.ManipulateSceneAsync(manipulator =>
{
var resD2DTexture = manipulator.AddResource(
_ => new Direct2DTextureResource(d2dDrawingLayer, 256, 256));
var resD2DMaterial = manipulator.AddStandardMaterialResource(resD2DTexture);
var resGeometry = manipulator.AddResource(
_ => new GeometryResource(new CubeGeometryFactory()));
var newMesh = manipulator.AddMeshObject(resGeometry, resD2DMaterial);
newMesh.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f);
newMesh.Scaling = new Vector3(2f, 2f, 2f);
});
// Take screenshot
await memRenderTarget.AwaitRenderAsync();
screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync();
// TestUtilities.DumpToDesktop(screenshot, "Blub.png");
}
}
// Calculate and check difference
Assert.IsNotNull(screenshot);
var isNearEqual = BitmapComparison.IsNearEqual(
screenshot, TestUtilities.LoadBitmapFromResource("ErrorHandling", "SimpleObject.png"));
Assert.IsTrue(isNearEqual, "Difference to reference image is to big!");
}
public System.Drawing.RectangleF MeasureItem(System.Drawing.Graphics g, System.Drawing.RectangleF innerArea)
{
innerArea.Inflate(3.0f * _shadowLength / 2, 3.0f * _shadowLength / 2);
return(innerArea);
}
public void Paint(ChartPaintEventArgs e)
{
var g = e.Graphics;
var chart = e.Chart;
// dragging outline / trail
if (DraggedRect != RectangleF.Empty)
g.DrawRectangle(Pens.Red, DraggedRect);
// insertion indicator line
if (Row != int.MinValue)
{
float y = e.Chart._ChartRowToChartCoord(Row) + e.Chart.BarHeight / 2.0f;
g.DrawLine(Pens.CornflowerBlue, new PointF(0, y), new PointF(e.Chart.Width, y));
}
// tool tip
if (_mToolTipMouse != Point.Empty && _mToolTipText != string.Empty)
{
var size = g.MeasureString(_mToolTipText, chart.Font).ToSize();
var tooltiprect = new RectangleF(_mToolTipMouse, size);
tooltiprect.Offset(0, -tooltiprect.Height);
var textstart = new PointF(tooltiprect.Left, tooltiprect.Top);
tooltiprect.Inflate(5, 5);
g.FillRectangle(Brushes.LightYellow, tooltiprect);
g.DrawString(_mToolTipText, chart.Font, Brushes.Black, textstart);
}
}
private void Page_Load(object sender, System.EventArgs e)
{
if (!ServiceConfiguration.CheckEnabled("jumpmap", Response))
{
return;
}
// NOTE: This (re)initializes a static data structure used for
// resolving names into sector locations, so needs to be run
// before any other objects (e.g. Worlds) are loaded.
ResourceManager resourceManager = new ResourceManager(Server, Cache);
//
// Jump
//
int jump = Util.Clamp(GetIntOption("jump", 6), 0, 12);
//
// Content & Coordinates
//
Selector selector;
Location loc;
if (Request.HttpMethod == "POST")
{
Sector sector;
try
{
sector = GetPostedSector();
}
catch (Exception ex)
{
SendError(400, "Invalid request", ex.Message);
return;
}
if (sector == null)
{
SendError(400, "Invalid request", "Either file or data must be supplied in the POST data.");
return;
}
int hex = GetIntOption("hex", Astrometrics.SectorCentralHex);
loc = new Location(new Point(0, 0), hex);
selector = new HexSectorSelector(resourceManager, sector, loc.HexLocation, jump);
}
else
{
SectorMap map = SectorMap.FromName(SectorMap.DefaultSetting, resourceManager);
if (HasOption("sector") && HasOption("hex"))
{
string sectorName = GetStringOption("sector");
int hex = GetIntOption("hex", 0);
loc = new Location(map.FromName(sectorName).Location, hex);
}
else if (HasOption("sx") && HasOption("sy") && HasOption("hx") && HasOption("hy"))
{
int sx = GetIntOption("sx", 0);
int sy = GetIntOption("sy", 0);
int hx = GetIntOption("hx", 0);
int hy = GetIntOption("hy", 0);
loc = new Location(map.FromLocation(sx, sy).Location, hx * 100 + hy);
}
else if (HasOption("x") && HasOption("y"))
{
loc = Astrometrics.CoordinatesToLocation(GetIntOption("x", 0), GetIntOption("y", 0));
}
else
{
loc = new Location(map.FromName("Spinward Marches").Location, 1910);
}
selector = new HexSelector(map, resourceManager, loc, jump);
}
//
// Scale
//
double scale = Util.Clamp(GetDoubleOption("scale", 64), MinScale, MaxScale);
//
// Options & Style
//
MapOptions options = MapOptions.BordersMajor | MapOptions.BordersMinor | MapOptions.ForceHexes;
Stylesheet.Style style = Stylesheet.Style.Poster;
ParseOptions(ref options, ref style);
//
// Border
//
bool border = GetBoolOption("border", defaultValue: true);
//
// Clip
//
bool clip = GetBoolOption("clip", defaultValue: true);
//
// What to render
//
RectangleF tileRect = new RectangleF();
Point coords = Astrometrics.LocationToCoordinates(loc);
tileRect.X = coords.X - jump - 1;
tileRect.Width = jump + 1 + jump;
tileRect.Y = coords.Y - jump - 1;
tileRect.Height = jump + 1 + jump;
// Account for jagged hexes
tileRect.Y += (coords.X % 2 == 0) ? 0 : 0.5f;
tileRect.Inflate(0.35f, 0.15f);
Size tileSize = new Size((int)Math.Floor(tileRect.Width * scale * Astrometrics.ParsecScaleX), (int)Math.Floor(tileRect.Height * scale * Astrometrics.ParsecScaleY));
// Construct clipping path
List<Point> clipPath = new List<Point>(jump * 6 + 1);
Point cur = coords;
for (int i = 0; i < jump; ++i)
{
// Move J parsecs to the upper-left (start of border path logic)
cur = Astrometrics.HexNeighbor(cur, 1);
}
clipPath.Add(cur);
for (int dir = 0; dir < 6; ++dir)
{
for (int i = 0; i < jump; ++i)
{
cur = Astrometrics.HexNeighbor(cur, (dir + 3) % 6); // Clockwise from upper left
clipPath.Add(cur);
}
}
Stylesheet styles = new Stylesheet(scale, options, style);
// If any names are showing, show them all
if (styles.worldDetails.HasFlag(WorldDetails.KeyNames))
{
styles.worldDetails |= WorldDetails.AllNames;
}
// Compute path
float[] edgeX, edgeY;
RenderUtil.HexEdges(styles.microBorderStyle == MicroBorderStyle.Square ? PathUtil.PathType.Square : PathUtil.PathType.Hex,
out edgeX, out edgeY);
PointF[] boundingPathCoords;
byte[] boundingPathTypes;
PathUtil.ComputeBorderPath(clipPath, edgeX, edgeY, out boundingPathCoords, out boundingPathTypes);
Render.RenderContext ctx = new Render.RenderContext();
ctx.resourceManager = resourceManager;
ctx.selector = selector;
ctx.tileRect = tileRect;
ctx.scale = scale;
ctx.options = options;
ctx.styles = styles;
ctx.tileSize = tileSize;
ctx.border = border;
ctx.clipPath = clip ? new XGraphicsPath(boundingPathCoords, boundingPathTypes, XFillMode.Alternate) : null;
ProduceResponse("Jump Map", ctx, tileSize, transparent: clip);
}
public void draw(Graphics g, PointF autoScrollPosition)
{
Pen pen;
Brush brush;
if (selected)
{
pen = tabela.ItemBorderSelectedPen;
brush = tabela.ItemTextSelectedBrush;
}
else
{
pen = tabela.ItemBorderPen;
brush = tabela.ItemTextBrush;
}
Font f = tabela.ItemFont;
Font fBold = tabela.ItemBoldFont;
Font fVrednostPreskoka = tabela.VrednostPreskokaFont;
RectangleF rect = new RectangleF(location, size);
rect.Offset(autoScrollPosition.X, autoScrollPosition.Y);
g.FillRectangle(tabela.ItemBackroundBrush, rect);
string number = broj.ToString() + '.';
if (cutted)
{
g.DrawRectangle(tabela.EraseBorderPen, rect.X, rect.Y, rect.Width, rect.Height);
DashStyle style = pen.DashStyle;
pen.DashStyle = DashStyle.Dot;
g.DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height);
pen.DashStyle = style;
}
else
{
g.DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height);
}
g.DrawString(number, f, brush, (RectangleF)rect);
if (element != null)
{
string naziv = element.Naziv;
if (naziv != "")
naziv += '\n';
naziv += element.EngleskiNaziv;
string nazivGim = element.NazivPoGimnasticaru;
float nazivHeigth = 0.0f;
// TODO2: Probaj da razdvojis srpski i engleski naziv (linijom ili malim razmakom)
if (naziv != "")
{
float xNaziv = rect.X + g.MeasureString(number + new String(' ', 3), f).Width;
nazivHeigth = g.MeasureString(
naziv, f, new SizeF(rect.Right - xNaziv, rect.Height)).Height;
RectangleF nazivRect = new RectangleF(xNaziv, rect.Y,
rect.Right - xNaziv, nazivHeigth);
g.DrawString(naziv, f, brush, nazivRect);
}
float nazivGimHeigth = 0.0f;
if (nazivGim != "")
{
nazivGim = "(" + nazivGim + ")";
nazivGimHeigth = g.MeasureString(nazivGim, fBold, rect.Size).Height;
nazivGimHeigth *= 2;
RectangleF nazivGimRect = new RectangleF(rect.X, rect.Y + nazivHeigth,
rect.Width, nazivGimHeigth);
StringFormat fmt = new StringFormat();
fmt.Alignment = StringAlignment.Center;
fmt.LineAlignment = StringAlignment.Center;
g.DrawString(nazivGim, fBold, brush, nazivGimRect, fmt);
}
if (Image != null)
{
float textHeigth = nazivHeigth + nazivGimHeigth;
PointF imageTopLeft = new PointF(rect.Left, rect.Top + textHeigth);
SizeF imageSize = new SizeF(rect.Width, rect.Height - textHeigth);
RectangleF imageRect = new RectangleF(imageTopLeft, imageSize);
float hRedukcija =
imageRect.Width - imageRect.Width * Slika.ProcenatRedukcije / 100f;
float vRedukcija =
imageRect.Height - imageRect.Height * Slika.ProcenatRedukcije / 100f;
imageRect.Inflate(- hRedukcija / 2, - vRedukcija / 2);
imageRect.Inflate(-Math.Max(imageRect.Width / 50, 1),
-Math.Max(imageRect.Height / 50, 1));
if (selected)
PictureBoxPlus.scaleImageIsotropically(g, SelectedImage, imageRect);
else
PictureBoxPlus.scaleImageIsotropically(g, Image, imageRect);
}
RectangleF vaRect = RectangleF.Empty;
if (element.Sprava == Sprava.Preskok && element.VrednostPreskoka != null)
{
string vrednost = element.VrednostPreskoka.ToString();
SizeF vrednostSize = g.MeasureString(vrednost, fVrednostPreskoka);
PointF vrednostLoc = new PointF(rect.X, rect.Bottom - vrednostSize.Height);
vaRect = new RectangleF(vrednostLoc, vrednostSize);
//g.DrawRectangle(pen, vaRect.X, vaRect.Y, vaRect.Width, vaRect.Height);
g.DrawString(vrednost, fVrednostPreskoka, brush, vaRect);
}
if (element.Varijante.Count > 0)
{
string va = "VA";
SizeF vaSize = g.MeasureString(va, f);
PointF vaLoc;
if (vaRect != RectangleF.Empty)
vaLoc = new PointF(vaRect.Right, rect.Bottom - vaSize.Height);
else
vaLoc = new PointF(rect.X, rect.Bottom - vaSize.Height);
vaRect = new RectangleF(vaLoc, vaSize);
g.DrawRectangle(pen, vaRect.X, vaRect.Y, vaRect.Width, vaRect.Height);
g.DrawString(va, f, brush, vaRect);
}
if (element.VideoKlipovi.Count > 0)
{
string vi = "VI";
SizeF viSize = g.MeasureString(vi, f);
PointF viLoc;
if (vaRect != RectangleF.Empty)
viLoc = new PointF(vaRect.Right, rect.Bottom - viSize.Height);
else
viLoc = new PointF(rect.X, rect.Bottom - viSize.Height);
RectangleF viRect = new RectangleF(viLoc, viSize);
g.DrawRectangle(pen, viRect.X, viRect.Y, viRect.Width, viRect.Height);
g.DrawString(vi, f, brush, viRect);
}
}
}
public void DrawArc(ICanvas canvas, Pen pen, UnitPoint center, float radius, float startAngle, float sweepAngle)
{
PointF p1 = ToScreen(center);
radius = (float)Math.Round(ToScreen(radius));
RectangleF r = new RectangleF(p1, new SizeF());
r.Inflate(radius, radius);
if (radius > 0 && radius < 1e8f )
canvas.Graphics.DrawArc(pen, r, -startAngle, -sweepAngle);
}
public override void DrawDateTimePicker(Graphics dc, Rectangle clip_rectangle, DateTimePicker dtp)
{
if (!clip_rectangle.IntersectsWith (dtp.ClientRectangle))
return;
// draw the outer border
Rectangle button_bounds = dtp.ClientRectangle;
DateTimePickerDrawBorder (dtp, dc, clip_rectangle);
// deflate by the border width
if (clip_rectangle.IntersectsWith (dtp.drop_down_arrow_rect)) {
button_bounds.Inflate (-2,-2);
if (!dtp.ShowUpDown) {
DateTimePickerDrawDropDownButton (dtp, dc, clip_rectangle);
} else {
ButtonState up_state = dtp.is_up_pressed ? ButtonState.Pushed : ButtonState.Normal;
ButtonState down_state = dtp.is_down_pressed ? ButtonState.Pushed : ButtonState.Normal;
Rectangle up_bounds = dtp.drop_down_arrow_rect;
Rectangle down_bounds = dtp.drop_down_arrow_rect;
up_bounds.Height = up_bounds.Height / 2;
down_bounds.Y = up_bounds.Height;
down_bounds.Height = dtp.Height - up_bounds.Height;
if (down_bounds.Height > up_bounds.Height)
{
down_bounds.Y += 1;
down_bounds.Height -= 1;
}
up_bounds.Inflate (-1, -1);
down_bounds.Inflate (-1, -1);
ControlPaint.DrawScrollButton (dc, up_bounds, ScrollButton.Up, up_state);
ControlPaint.DrawScrollButton (dc, down_bounds, ScrollButton.Down, down_state);
}
}
// render the date part
if (!clip_rectangle.IntersectsWith (dtp.date_area_rect))
return;
// fill the background
dc.FillRectangle (SystemBrushes.Window, dtp.date_area_rect);
// Update date_area_rect if we are drawing the checkbox
Rectangle date_area_rect = dtp.date_area_rect;
if (dtp.ShowCheckBox) {
Rectangle check_box_rect = dtp.CheckBoxRect;
date_area_rect.X = date_area_rect.X + check_box_rect.Width + DateTimePicker.check_box_space * 2;
date_area_rect.Width = date_area_rect.Width - check_box_rect.Width - DateTimePicker.check_box_space * 2;
ButtonState bs = dtp.Checked ? ButtonState.Checked : ButtonState.Normal;
CPDrawCheckBox(dc, check_box_rect, bs);
if (dtp.is_checkbox_selected)
CPDrawFocusRectangle (dc, check_box_rect, dtp.foreground_color, dtp.background_color);
}
// render each text part
using (StringFormat text_format = StringFormat.GenericTypographic)
{
text_format.LineAlignment = StringAlignment.Near;
text_format.Alignment = StringAlignment.Near;
text_format.FormatFlags = text_format.FormatFlags | StringFormatFlags.MeasureTrailingSpaces | StringFormatFlags.NoWrap | StringFormatFlags.FitBlackBox;
text_format.FormatFlags &= ~StringFormatFlags.NoClip;
// Calculate the rectangles for each part
if (dtp.part_data.Length > 0 && dtp.part_data[0].drawing_rectangle.IsEmpty)
{
Graphics gr = dc;
for (int i = 0; i < dtp.part_data.Length; i++)
{
DateTimePicker.PartData fd = dtp.part_data[i];
RectangleF text_rect = new RectangleF();
string text = fd.GetText(dtp.Value);
text_rect.Size = gr.MeasureString (text, dtp.Font, 250, text_format);
if (!fd.is_literal)
text_rect.Width = Math.Max (dtp.CalculateMaxWidth(fd.value, gr, text_format), text_rect.Width);
if (i > 0) {
text_rect.X = dtp.part_data[i - 1].drawing_rectangle.Right;
} else {
text_rect.X = date_area_rect.X;
}
text_rect.Y = 2;
text_rect.Inflate (1, 0);
fd.drawing_rectangle = text_rect;
}
}
// draw the text part
Brush text_brush = ResPool.GetSolidBrush (dtp.ShowCheckBox && dtp.Checked == false ?
SystemColors.GrayText : dtp.ForeColor); // Use GrayText if Checked is false
RectangleF clip_rectangleF = clip_rectangle;
for (int i = 0; i < dtp.part_data.Length; i++)
{
DateTimePicker.PartData fd = dtp.part_data [i];
string text;
if (!clip_rectangleF.IntersectsWith (fd.drawing_rectangle))
continue;
text = dtp.editing_part_index == i ? dtp.editing_text : fd.GetText (dtp.Value);
PointF text_position = new PointF ();
SizeF text_size;
RectangleF text_rect;
text_size = dc.MeasureString (text, dtp.Font, 250, text_format);
text_position.X = (fd.drawing_rectangle.Left + fd.drawing_rectangle.Width / 2) - text_size.Width / 2;
text_position.Y = (fd.drawing_rectangle.Top + fd.drawing_rectangle.Height / 2) - text_size.Height / 2;
text_rect = new RectangleF (text_position, text_size);
text_rect = RectangleF.Intersect (text_rect, date_area_rect);
if (text_rect.IsEmpty)
break;
if (text_rect.Right >= date_area_rect.Right)
text_format.FormatFlags &= ~StringFormatFlags.NoClip;
else
text_format.FormatFlags |= StringFormatFlags.NoClip;
if (fd.Selected) {
dc.FillRectangle (SystemBrushes.Highlight, text_rect);
dc.DrawString (text, dtp.Font, SystemBrushes.HighlightText, text_rect, text_format);
} else {
dc.DrawString (text, dtp.Font, text_brush, text_rect, text_format);
}
if (fd.drawing_rectangle.Right > date_area_rect.Right)
break; // the next part would be not be visible, so don't draw anything more.
}
}
}
public override void Draw(RectangleF rectB)
{
CGColorSpace cs = null;
CGContext ctx = null;
RectangleF bds;
ctx = UIGraphics.GetCurrentContext ();
cs = CGColorSpace.CreateDeviceRGB ();
if (Vertical){
ctx.TranslateCTM (0, Bounds.Height);
ctx.ScaleCTM (1, -1);
bds = Bounds;
} else {
ctx.TranslateCTM (0, Bounds.Height);
ctx.RotateCTM ((float)Math.PI/2);
bds = new RectangleF (0, 0, Bounds.Height, Bounds.Width);
}
ctx.SetFillColorSpace (cs);
ctx.SetStrokeColorSpace (cs);
if (NumLights == 0){
float currentTop = 0;
if (BgColor != null){
BgColor.SetColor ();
ctx.FillRect (bds);
}
foreach (var thisTresh in ColorThresholds){
var val = Math.Min (thisTresh.MaxValue, Level);
var rect = new RectangleF (0, bds.Height * currentTop, bds.Width, bds.Height * (val - currentTop));
thisTresh.Color.SetColor ();
ctx.FillRect (rect);
if (Level < thisTresh.MaxValue)
break;
currentTop = val;
}
if (BorderColor != null){
BorderColor.SetColor ();
bds.Inflate (-0.5f, -0.5f);
ctx.StrokeRect (bds);
}
} else {
float lightMinVal = 0;
float insetAmount, lightVSpace;
int peakLight = -1;
lightVSpace = bds.Height / (float) NumLights;
if (lightVSpace < 4)
insetAmount = 0;
else if (lightVSpace < 8)
insetAmount = 0.5f;
else
insetAmount = 1;
if (PeakLevel > 0){
peakLight = (int) PeakLevel * NumLights;
if (peakLight >= NumLights)
peakLight = NumLights-1;
}
for (int light_i = 0; light_i< NumLights; light_i++){
float lightMaxVal = (light_i + 1) / (float)NumLights;
float lightIntensity;
RectangleF lightRect;
UIColor lightColor;
if (light_i == peakLight){
lightIntensity = 1;
} else {
lightIntensity = (Level - lightMinVal) / (lightMaxVal - lightMinVal);
lightIntensity = Clamp (0, lightIntensity, 1);
if (!VariableLightIntensity && lightIntensity > 0)
lightIntensity = 1;
}
lightColor = ColorThresholds [0].Color;
int color_i = 0;
for (; color_i < ColorThresholds.Length-1; color_i++){
var thisTresh = ColorThresholds [color_i];
var nextTresh = ColorThresholds [color_i+1];
if (thisTresh.MaxValue < lightMaxVal)
lightColor = nextTresh.Color;
}
lightRect = new RectangleF (0, bds.Height * color_i / (float) NumLights,
bds.Width, bds.Height * (1f / NumLights));
lightRect.Inflate (-insetAmount, -insetAmount);
if (BgColor != null){
BgColor.SetColor ();
ctx.FillRect (lightRect);
}
if (lightIntensity == 1){
lightColor.SetColor ();
ctx.FillRect (lightRect);
} else if (lightIntensity > 0){
using (var clr = new CGColor (lightColor.CGColor, lightIntensity)){
ctx.SetFillColorWithColor (clr);
ctx.FillRect (lightRect);
}
}
if (BorderColor != null){
BorderColor.SetColor ();
lightRect.Inflate (-0.5f, -0.5f);
ctx.StrokeRect (lightRect);
}
lightMinVal = lightMaxVal;
}
}
cs.Dispose ();
}
