public void Main()
{
string xmlPath = TestConstants.XML_OUTPUT_FULL + TestConstants.CIRCLE_XML;
Circle circ1 = new Circle(new Point(100, 150), 50);
circ1.save(xmlPath);
Circle circ2 = Shape.load(xmlPath, typeof(Circle)) as Circle;
Assert.AreEqual(circ1.center.x, circ2.center.x);
Assert.AreEqual(circ1.center.y, circ2.center.y);
Assert.AreEqual(circ1.radius, circ2.radius);
string pngPath = TestConstants.PNG_OUTPUT_FULL + TestConstants.CIRCLE_PNG;
GraphicsWrapper gw = new GraphicsWrapper();
Graphics graphics = gw.graphics;
circ1.render(graphics);
circ1.translate(100, 100);
circ1.scale(0.5);
Assert.AreEqual(circ1.center.x, 200);
Assert.AreEqual(circ1.center.y, 250);
Assert.AreEqual(circ1.radius, 25);
Assert.AreEqual(circ1.getArea(), 1963.4954084936207);
circ1.render(graphics);
gw.saveToFile(pngPath);
Circle circ3 = new Circle(1, 2, 3);
Assert.AreEqual(circ3.center.x, 1);
Assert.AreEqual(circ3.center.y, 2);
Assert.AreEqual(circ3.radius, 3);
}
public override void DrawZones(GraphicsWrapper g, int trackIndex, int trackX, int trackY, int width, int height, Rectangle bounds)
{
DrawZone(g, trackIndex, trackX, trackY, width, height, bounds, CustomBrushes.Player1Visible, "P1 Visible", 0, 3);
DrawZone(g, trackIndex, trackX, trackY, width, height, bounds, Brushes.Red, "P1 notes special", 4, 7);
DrawZone(g, trackIndex, trackX, trackY, width, height, bounds, CustomBrushes.Player2Visible, "P2 Visible", 8, 11);
DrawZone(g, trackIndex, trackX, trackY, width, height, bounds, Brushes.Azure, "P2 notes special", 12, 15);
}
public void Main()
{
string xmlPath = TestConstants.XML_OUTPUT_FULL + TestConstants.RECTANGLE_XML;
Rectangle r1 = new Rectangle(new Point(50, 100), new Point(100, 150));
r1.save(xmlPath);
Rectangle r2 = Shape.load(xmlPath, typeof(Rectangle)) as Rectangle;
Assert.AreEqual(r1.point1.x, r2.point1.x);
Assert.AreEqual(r1.point2.x, r2.point2.x);
Assert.AreEqual(r1.point2.y, r2.point2.y);
Assert.AreEqual(r1.point2.y, r2.point2.y);
string pngPath = TestConstants.PNG_OUTPUT_FULL + TestConstants.RECTANGLE_PNG;
GraphicsWrapper gw = new GraphicsWrapper();
Graphics graphics = gw.graphics;
r1.render(graphics);
r1.translate(100, 100);
r1.scale(2);
Assert.AreEqual(r1.point1.x, 125);
Assert.AreEqual(r1.point1.y, 175);
Assert.AreEqual(r1.point2.x, 225);
Assert.AreEqual(r1.point2.y, 275);
Assert.AreEqual(r1.getArea(), 10000);
r1.render(graphics);
gw.saveToFile(pngPath);
}
public void Main()
{
string xmlPath = TestConstants.XML_OUTPUT_FULL + TestConstants.SHAPE_POINT_XML;
Point p1 = new Point(13, 22);
p1.save(xmlPath);
Point p2 = Shape.load(xmlPath, typeof(Point)) as Point;
Assert.AreEqual(p1.x, p2.x);
Assert.AreEqual(p1.y, p2.y);
string pngPath = TestConstants.PNG_OUTPUT_FULL + TestConstants.SHAPE_POINT_PNG;
GraphicsWrapper gw = new GraphicsWrapper();
Graphics graphics = gw.graphics;
p1.render(graphics);
p1.translate(100, 100);
Assert.AreEqual(p1.x, 113);
Assert.AreEqual(p1.y, 122);
p1.render(graphics);
gw.saveToFile(pngPath);
Point p3 = p1.copy();
p3.scale(100);
Assert.AreEqual(p1.x, p3.x);
Assert.AreEqual(p1.y, p3.y);
Assert.AreEqual(p3.getArea(), 0);
Assert.IsNull(p1.GetSchema());
}
public override void RenderEventData(GraphicsWrapper g, EventData eventData, Rectangle eventRectangle, int centerX, int centerY)
{
switch (eventData.EventType)
{
case EventType.Note:
{
this.RenderNote(g, eventData, eventRectangle, centerX, centerY);
}
break;
case EventType.Tempo:
{
DrawImage(g, DJMRessources.metronome, centerX - (90 / 2), centerY - (90 / 2), 90, 90);
}
break;
case EventType.Volume:
{
DrawImage(g, DJMRessources.volume, centerX - (64 / 2), centerY - (64 / 2), 64, 64);
}
break;
case EventType.Beat:
{
DrawImage(g, DJMRessources.beat, centerX - (90 / 2), centerY - (90 / 2), 90, 90);
}
break;
default:
{
DrawImage(g, DJMRessources.unknowNote, eventRectangle.X, eventRectangle.Y, 90, 90);
}
break;
}
}
public void Main()
{
string xmlPath = TestConstants.XML_OUTPUT_FULL + TestConstants.LINE_XML;
Line l1 = new Line(new Point(50, 100), new Point(100, 100));
l1.save(xmlPath);
Line l2 = Shape.load(xmlPath, typeof(Line)) as Line;
Assert.AreEqual(l1.point1.x, l2.point1.x);
Assert.AreEqual(l1.point2.x, l2.point2.x);
Assert.AreEqual(l1.point2.y, l2.point2.y);
Assert.AreEqual(l1.point2.y, l2.point2.y);
string pngPath = TestConstants.PNG_OUTPUT_FULL + TestConstants.LINE_PNG;
GraphicsWrapper gw = new GraphicsWrapper();
Graphics graphics = gw.graphics;
l1.render(graphics);
l1.translate(100, 100);
l1.scale(2);
Assert.AreEqual(l1.point1.x, 125);
Assert.AreEqual(l1.point1.y, 200);
Assert.AreEqual(l1.point2.x, 225);
Assert.AreEqual(l1.point2.y, 200);
Assert.AreEqual(l1.getArea(), 0);
l1.render(graphics);
gw.saveToFile(pngPath);
Line l3 = new Line(1, 2, 3, 4);
Assert.AreEqual(l3.point1.x, 1);
Assert.AreEqual(l3.point1.y, 2);
Assert.AreEqual(l3.point2.x, 3);
Assert.AreEqual(l3.point2.y, 4);
}
public void gameTick(GraphicsWrapper g, Panel minigamePanel, Timer minigameTimer, uint minigameTime)
{
try
{
Random random = new Random();
tet.Drop();
if (isDropped == true)
{
tet = nexttet;
nexttet = new Tetrominoe();
tet.Spawn();
isDropped = false;
score += 10;
}
int j; for (j = 0; j < 10; j++)
{
if (droppedtetrominoeLocationGrid[0, j] == 1)
{
Misc.closeGameWindow.Invoke();
}
}
Input();
ClearBlock();
}
catch (Exception ex) { if (ex.InnerException?.Message == "0717750f-3508-4bc2-841e-f3b077c676fe")
{
Misc.closeGameWindow.Invoke();
}
else
{
Console.WriteLine(ex.ToString());
} }
}
/// <summary>
///
/// </summary>
/// <param name="eval"></param>
/// <returns>Cached wrapper</returns>
public static GraphicsWrapper Wrap(this Graphics gr)
{
if (gw == null)
{
gw = new GraphicsWrapper(gr);
}
return(gw);
}
public void draw(GraphicsWrapper g, Panel minigamePanel, Timer minigameTimer, uint minigameTime)
{
for (int i = 0; i < enemies.Count; i++)
{
g.DrawRectangle(new RectangleF(enemies[i].toPointF(), new SizeF(10, 10)), Color.Red);
}
g.DrawRectangle(new RectangleF(player.toPointF(), new SizeF(10, 10)), Color.Green);
g.DrawSizedString(lives.ToString(), 7, player.toPointF(), Brushes.White, true, true);
}
public static VoxelCustomRenderer CreateDefault(GraphicsWrapper game)
{
return(new VoxelCustomRenderer(game,
game.AcquireRenderer(),
new DualContouringMeshBuilder(),
new DualContouringAlgorithm(),
new MeshRenderDataFactory(game, null,
game.AcquireRenderer().TexturePool)));
}
/// <summary>
/// Measures the bounds of the container
/// </summary>
public virtual void MeasureBounds()
{
_htmlContainer.SetBounds(this is HtmlLabel ? new SWF.Rectangle(0, 0, 10, 10) : ClientRectangle);
using (IGraphics g = new GraphicsWrapper(CreateGraphics()))
{
_htmlContainer.MeasureBounds(g);
}
AutoScrollMinSize = Size.Round(_htmlContainer.MaximumSize);
}
public override void DrawSeriesIcon(GraphicsWrapper g, Rectangle rectangle)
{
foreach (string name in _outputResultSetsPens.Keys)
{
base.DrawIcon(g, _outputResultSetsPens[name], Brushes.White, rectangle);
return;
}
// If none are available, draw a simple black and white icon.
base.DrawIcon(g, Pens.White, Brushes.Black, rectangle);
}
public void draw(GraphicsWrapper g, Panel minigamePanel, Timer minigameTimer, uint minigameTime)
{
for (int i = 0; i < enemies.Count; i++)
{
g.DrawRectangle(new RectangleF(enemies[i].toPointF(), new SizeF(10, 10)), Color.Red);
}
for (int i = 0; i < bullets.Count; i++)
{
g.DrawRectangle(new RectangleF(bullets[i].toPointF(), new SizeF(5, 5)), Color.White);
}
g.DrawRectangle(new RectangleF(player.toPointF(), new SizeF(10, 10)), Color.Green);
}
private void MinigamePanel_Paint(object sender, PaintEventArgs e)
{
using (GraphicsWrapper w = new GraphicsWrapper(e.Graphics, level.backColor, new Rectangle(Point.Empty, minigamePanel.Size)))
{
w.Clear();
level.draw(w, minigamePanel, minigameClockT, minigameTime);
if (minigameTime != minigamePrevTime)
{
level.gameTick(w, minigamePanel, minigameClockT, minigameTime);
minigamePrevTime = minigameTime;
}
}
}
private void InvadersPanel_Paint(object sender, PaintEventArgs e)
{
using (GraphicsWrapper w = new GraphicsWrapper(e.Graphics, levels[levelInd].backColor, new Rectangle(Point.Empty, minigamePanel.Size), Settings.quality == 1 ? levels[levelInd].isLowQuality : Settings.quality == 0))
{
w.Clear();
levels[levelInd].draw(w, minigamePanel, minigameClockT, minigameTime);
if (minigameTime != minigamePrevTime)
{
levels[levelInd].gameTick(w, minigamePanel, minigameClockT, minigameTime);
minigamePrevTime = minigameTime;
}
}
}
private void tutorialPanel_Paint(object sender, PaintEventArgs e)
{
using (GraphicsWrapper g = new GraphicsWrapper(e.Graphics, Color.Red, new Rectangle(Point.Empty, tutorialPanel.Size), true))
{
for (int i = 0; i < 40; i++)
{
for (int j = 0; j < 40; j++)
{
g.DrawLine(new PointF(tutorialPanel.Width / 2, tutorialPanel.Height / 2), new PointF(i * 10 + 5, j * 10 + 5), Color.DarkGray, 1, false);
}
}
g.DrawSizedString("This is " + ((timertime < 17) ? "bad" : (timertime <= 33) ? "neutral" : "you"), 10, new PointF(tutorialPanel.Width / 2, tutorialPanel.Height / 2), new SolidBrush((timertime < 17) ? Color.Red : (timertime <= 33) ? Color.White : Color.Green), true, true);
}
}
public void Main()
{
string pngPath = TestConstants.PNG_OUTPUT_FULL + TestConstants.POINT_PNG;
Point p1 = new Point(13, 22);
GraphicsWrapper gw = new GraphicsWrapper();
Graphics graphics = gw.graphics;
p1.render(graphics);
p1.translate(100, 100);
Assert.AreEqual(p1.x, 113);
Assert.AreEqual(p1.y, 122);
p1.render(graphics);
gw.saveToFile(pngPath);
}
public void draw(GraphicsWrapper g, Panel minigamePanel, Timer minigameTimer, uint minigameTime)
{
g.DrawRectangle(new Rect(player, new Vector2(10, 10), true), Color.Green);
if (lazorTime >= 0 && lazorTime <= 80)
{
float m = (float)Misc.map(0, 80, 0, minigamePanel.Height, lazorTime);
Vector2 mp = new Vector2(lazor, m);
g.DrawLine(mp, new Vector2(lazor, 0), Color.DarkGray, 2);
g.DrawLine(new Vector2(lazor, minigamePanel.Height), mp, Color.Red, 2);
}
for (int i = 0; i < platforms.Count; i++)
{
g.DrawRectangle(new Rect(platforms[i], new Vector2(100, 10), true), Color.White);
}
}
public void DrawTo(IntPtr hdc)
{
if (!this.DesignMode)
{
if (window != null)
{
GraphicsWrapper gw = GraphicsWrapper.FromHdc(hdc, true);
GdiRenderer r = ((GdiRenderer)window.Renderer);
gw.Clear(r.BackColor);
r.GraphicsWrapper = gw;
window.Renderer.Render((SvgDocument)window.Document);
r.GraphicsWrapper = null;
gw.Dispose();
}
}
}
public void Render(GraphicsWrapper g)
{
if (m_drag.Active && m_selectMode)
{
g.FillRectangle(tbrush, m_selectionRectangle);
g.DrawRectangle(Pens.LightBlue, m_selectionRectangle);
}
var eventsRenderer = m_eventsRenderer;
foreach (EventData o in m_selectedObjects)
{
Rectangle rec = eventsRenderer.GetEventRectangle(o, (int)o.TrackId * EventsRenderer.VirtualTrackheight);
g.FillRectangle(tbrush, rec);
g.DrawRectangle(selection_border, rec);
}
}
protected void DrawImage(GraphicsWrapper g, Image image, int x, int y, int width, int height)
{
Rectangle.X = x;
Rectangle.Y = y;
Rectangle.Width = width;
Rectangle.Height = height;
g.DrawImage(image,
Rectangle,
0,
0,
width,
height,
GraphicsUnit.Pixel,
null
);
}
public override void RenderNote(GraphicsWrapper g, EventData eventData, Rectangle eventRectangle, int centerX, int centerY)
{
int rectangleX = centerX - (RECTANGLE_WIDTH / 2);
int rectangleY = centerY - (RECTANGLE_HEIGHT / 2);
int rectangleWidth = RECTANGLE_WIDTH + (eventData.Duration > 6 ? eventData.VirtualDuration : 0);
int rectangleHeight = RECTANGLE_HEIGHT;
g.FillRectangle(CustomBrushes.NoteBackground, rectangleX, rectangleY, rectangleWidth, rectangleHeight);
g.DrawRectangle(Pens.Black, rectangleX, rectangleY, rectangleWidth, rectangleHeight);
string text = String.Empty;
switch (EventDisplayMode)
{
case EventDisplayMode.Attribute:
byte attribute = eventData.Attribute;
text = String.Format("Attr {0,3:000}", attribute);
break;
case EventDisplayMode.Instrument:
var instrument = eventData.Instrument;
int insNo = instrument != null ? instrument.InsNum : 0;
text = String.Format("Ins {0,3:000}", insNo);
break;
case EventDisplayMode.Duration:
ushort duration = eventData.Duration;
text = String.Format("Dur {0,3:000}", duration);
break;
case EventDisplayMode.Pan:
byte pan = eventData.Pan;
text = String.Format("Pan {0,3:000}", pan);
break;
case EventDisplayMode.Velocity:
byte vel = eventData.Vel;
text = String.Format("Vel {0,3:000}", vel);
break;
}
g.DrawString(text, this.m_textFont, Brushes.Black, centerX + SHADOW_DISTANCE, centerY + SHADOW_DISTANCE, _stringFormat);
g.DrawString(text, this.m_textFont, Brushes.White, centerX, centerY, _stringFormat);
}
public void RenderEventData(GraphicsWrapper g, EventData eventData, Rectangle bounds, int?trackY = null)
{
if (null == eventData || null == bounds)
{
return;
}
Rectangle eventRectangle = GetEventRectangle(eventData, trackY);
if (!eventRectangle.IntersectsWith(bounds))
{
return;
}
Point eventPosition = GetEventPosition(eventData);
this.RenderEventDataAtInRect(g, eventData, eventRectangle, eventPosition.X, eventPosition.Y);
}
public void Main()
{
string solDir = TestUtils.getSolutionDirectory();
string file1 = solDir + TestConstants.IMAGE_DIR + Constants.defaultImages[1];
string file2 = solDir + TestConstants.IMAGE_DIR + Constants.defaultImages[2];
GraphicsWrapper gw = new GraphicsWrapper();
Graphics graphics = gw.graphics;
Assert.NotNull(graphics);
ImageIntrinsicState imageIntrinsicState1 = new ImageIntrinsicState(file1);
ImageIntrinsicState imageIntrinsicState2 = new ImageIntrinsicState(file2);
Assert.IsTrue(imageIntrinsicState1 < imageIntrinsicState2 == imageIntrinsicState1);
Assert.IsTrue(imageIntrinsicState1 > imageIntrinsicState2 == imageIntrinsicState2);
}
void HtmlToolTip_Popup(object sender, PopupEventArgs e)
{
string text = this.GetToolTip(e.AssociatedControl);
string font = string.Format(NumberFormatInfo.InvariantInfo, "font: {0}pt {1}", e.AssociatedControl.Font.Size, e.AssociatedControl.Font.FontFamily.Name);
//Create fragment container
container = new InitialContainer("<table class=htmltooltipbackground cellspacing=5 cellpadding=0 style=\"" + font + "\"><tr><td style=border:0px>" + text + "</td></tr></table>");
container.SetBounds(new Rectangle(0, 0, 10, 10));
container.AvoidGeometryAntialias = true;
//Measure bounds of the container
using (IGraphics g = new GraphicsWrapper(e.AssociatedControl.CreateGraphics()))
{
container.MeasureBounds(g);
}
//Set the size of the tooltip
e.ToolTipSize = Size.Round(container.MaximumSize);
}
public void draw(GraphicsWrapper g, Panel minigamePanel, Timer minigameTimer, uint minigameTime)
{
for (int y = 0; y < 23; ++y)
{
for (int x = 0; x < 10; x++)
{
if (grid[y, x] == 1 | droppedtetrominoeLocationGrid[y, x] == 1)
{
g.DrawRectangle(new RectangleF(x * 10, y * 10, 10, 10), Color.White, false, false);
}
}
g.DrawLine(new Point(0, (y + 1) * 10), new Point(10 * 10, (y + 1) * 10), Color.DarkGray, 1, false);
}
for (int x = 0; x < 10; x++)
{
g.DrawLine(new Point((x + 1) * 10, 0), new Point((x + 1) * 10, 23 * 10), Color.DarkGray, 1, false);
}
g.DrawSizedString("Level " + level, 10, new PointF(150, 10), Brushes.White, false);
g.DrawSizedString("Score " + score, 10, new PointF(150, 30), Brushes.White, false);
g.DrawSizedString("LinesCleared " + linesCleared, 10, new PointF(150, 50), Brushes.White, false);
}
public LocalGame()
{
simulators = new List <ISimulator>();
game = new GraphicsWrapper();
game.InitDirectX();
var container = new DataWrapper(Rhino.Mocks.MockRepository.GenerateMock <ITraceLogger>());
physX = new PhysicsWrapper();
physX.Initialize();
//PhysicsDebugRenderer debugRenderer =
// new PhysicsDebugRenderer(game, engine.Scene);
//game.AddXNAObject(debugRenderer);
//var boxDesc = new BoxShapeDescription();
//boxDesc.Dimensions = new Vector3(100, 1, 100);
//boxDesc.LocalPosition = Vector3.Up * -1;
//var actorDesc = new ActorDescription(boxDesc);
//engine.Scene.CreateActor(actorDesc);
game.GameLoopEvent += delegate
{
foreach (var sim in simulators)
{
sim.Simulate();
}
container.ClearDirty();
physX.Update(game.Elapsed);
};
setTWGlobals(container);
}
public override void Draw(ChartPane managingPane, GraphicsWrapper g, int unitsUnification, RectangleF clippingRectangle, float itemWidth, float itemMargin)
{
if (this.Visible == false || Indicator == null)
{
return;
}
lock (Indicator.Results)
{
foreach (string name in Indicator.Results.SetsNamesUnsafe)
{
LinesChartSeries.ChartTypeEnum?chartType = Indicator.Results.GetResultSetChartType(name);
if (chartType.HasValue == false)
{// No specific value assigned means go for default.
chartType = DefaultChartType;
}
base.DrawItemSet(chartType.Value, g, _outputResultSetsPens[name], _defaultBrush,
unitsUnification, clippingRectangle, itemWidth, itemMargin, name);
}
}
foreach (string name in Indicator.Parameters.DynamicNames)
{// Render fixed lines.
if (name.Contains(FixedLinePrefix))
{
object value = Indicator.Parameters.GetDynamic(name);
if (value == null)
{
continue;
}
float floatValue = Convert.ToSingle(value);
int dashMove = 0;// ((int)x % DashSize);
g.DrawLine(_defaultDashedPen, clippingRectangle.X + dashMove, floatValue, clippingRectangle.X + clippingRectangle.Width, floatValue);
}
}
}
private void processUserInput(GraphicsWrapper game)
{
if (game.Keyboard.IsKeyDown(Key.W))
{
controller.DoMoveForward(game.Elapsed);
}
if (game.Keyboard.IsKeyDown(Key.S))
{
controller.DoMoveBackwards(game.Elapsed);
}
if (game.Keyboard.IsKeyDown(Key.A))
{
controller.DoStrafeLeft(game.Elapsed);
}
if (game.Keyboard.IsKeyDown(Key.D))
{
controller.DoStrafeRight(game.Elapsed);
}
if (game.Keyboard.IsKeyPressed(Key.Space))
{
controller.DoJump();
}
}
public override void RenderEventData(GraphicsWrapper g, EventData eventData, Rectangle eventRectangle, int centerX, int centerY)
{
//g.DrawRectangle(Pens.Red, eventRectangle);
switch (eventData.EventType)
{
case EventType.Note:
{
RenderNote(g, eventData, eventRectangle, centerX, centerY);
}
break;
case EventType.Tempo:
{
DrawImage(g, DJMRessources.metronome, centerX - (90 / 2), centerY - (90 / 2), 90, 90);
}
break;
case EventType.Volume:
{
DrawImage(g, DJMRessources.volume, centerX - (64 / 2), centerY - (64 / 2), 64, 64);
}
break;
case EventType.Beat:
{
DrawImage(g, DJMRessources.beat, centerX - (90 / 2), centerY - (90 / 2), 90, 90);
}
break;
default:
{
g.DrawImage(DJMRessources.unknowNote, eventRectangle, 0, 0, 90, 90, GraphicsUnit.Pixel, null);
}
break;
}
}
public override void Draw(GraphicsWrapper g, int unitsUnification, System.Drawing.RectangleF clippingRectangle, float itemWidth, float itemMargin)
{
base.Draw(g, unitsUnification, clippingRectangle, itemWidth, itemMargin);
}
