private void AdjustViewport(Vector2D point)
		{
			if (viewport == Rectangle.Zero)
				viewport = new Rectangle(point, Size.Zero);
			else
				UpdateEdges(point);
		}

		public MouseHoldTrigger(Rectangle holdArea, float holdTime = DefaultHoldTime,
			MouseButton button = MouseButton.Left)
		{
			HoldArea = holdArea;
			HoldTime = holdTime;
			Button = button;
		}

 public override void DrawRectangle(Rectangle area)
 {
     Rectangle pixelRect = device.Screen.ToPixelSpace(area);
     var sharpRect = new RectangleF(pixelRect.Left, pixelRect.Top, pixelRect.Right,
         pixelRect.Bottom);
     device.RenderTarget.FillRectangle(sharpRect, solidColorBrush);
 }

		public ItemEffect(Material material, Rectangle drawArea, float duration)
			: base(material, drawArea, duration)
		{
			RenderLayer = (int)RenderLayers.Items;
			Add(new Damage { Interval = 0.25f });
			Start<DoDamage>();
		}

 public void Bottom()
 {
     var rect = new Rectangle(1, 2, 10, 20) { Bottom = 23 };
     Assert.AreEqual(3, rect.Top);
     Assert.AreEqual(23, rect.Bottom);
     Assert.AreEqual(20, rect.Height);
 }

 private void MoveSprite()
 {
     float percentage = elapsed / timeout;
     Point topLeft = Point.Lerp(startDrawArea.TopLeft, endDrawArea.TopLeft, percentage);
     Size size = Size.Lerp(startDrawArea.Size, endDrawArea.Size, percentage);
     DrawArea = new Rectangle(topLeft, size);
 }

		private bool CheckBounds(Rectangle view)
		{
			if (view.Left > DrawArea.Left) return false;
			if (view.Right < DrawArea.Right) return false;
			if (DrawArea.Top < 0) return false;
			return view.Top + 0.05f <= DrawArea.Center.Y;
		}

 public void Clip(Rectangle clippingBounds)
 {
     var line = new ClippedLine(StartPoint, EndPoint, clippingBounds);
     StartPoint = line.StartPoint;
     EndPoint = line.EndPoint;
     IsVisible = line.IsVisible;
 }

		internal Label(Theme theme, Material material, Rectangle drawArea)
			: base(theme, material, drawArea)
		{
			var fontText = new FontText(theme.Font, "", GetFontTextDrawArea());
			Add(fontText);
			AddChild(fontText);
		}

		public Polygon2D(Rectangle drawArea, Color color)
			: base(drawArea)
		{
			Color = color;
			Add(new List<Vector2D>());
			OnDraw<DrawPolygon2D>();
		}

 public void CreateFromRectangle(Type resolver)
 {
     var halfScreenRect = new Rectangle(Point.Zero, Size.Half);
     Rect box = null;
     Start(resolver, (Renderer r) => r.Add(box = new Rect(halfScreenRect, Color.Red)),
         () => Assert.AreEqual(Color.Red, box.Color));
 }

			private static void RecalculateUV(Matrix matrix, Sprite entity, float angle)
			{
				var yScaled = RecalculateYCoordinate(matrix, angle);
				var uv = new Rectangle(entity.UV.Left,
					0.25f - ((1 - entity.UV.Height)) * yScaled, entity.UV.Width,
					entity.UV.Height);
				entity.UV = uv;
			}

		private void DeriveExtremities()
		{
			float width = viewport.Width / (1 + 2 * Buffer);
			float left = viewport.Center.X - width / 2;
			float height = viewport.Height / (1 + 2 * Buffer);
			float top = viewport.Center.Y - height / 2;
			extremities = new Rectangle(left, top, width, height);
		}

		public Slider(Theme theme, Rectangle drawArea)
			: base(theme, theme.Slider, drawArea)
		{
			var data = new Data { MinValue = 0, Value = 100, MaxValue = 100 };
			Add(data);
			Add(new Picture(theme, theme.SliderPointer, Rectangle.Unused));
			AddChild(Pointer);
		}

		private static Vector2D ToQuadratic(Vector2D point, Rectangle viewport, Rectangle drawArea)
		{
			float borderWidth = viewport.Width * Graph.Border;
			float borderHeight = viewport.Height * Graph.Border;
			float x = (point.X - viewport.Left + borderWidth) / (viewport.Width + 2 * borderWidth);
			float y = (point.Y - viewport.Top + borderHeight) / (viewport.Height + 2 * borderHeight);
			return new Vector2D(drawArea.Left + x * drawArea.Width, drawArea.Bottom - y * drawArea.Height);
		}

 public ZoomingEffect(Image image, Rectangle startDrawArea, Rectangle endDrawArea,
     float timeout = 1.0f)
     : base(image, startDrawArea)
 {
     this.startDrawArea = startDrawArea;
     this.endDrawArea = endDrawArea;
     this.timeout = timeout;
 }

		private void UpdateViewportFromExtremities()
		{
			float width = extremities.Width * (1 + 2 * Buffer);
			float left = extremities.Center.X - width / 2;
			float height = extremities.Height * (1 + 2 * Buffer);
			float top = extremities.Center.Y - height / 2;
			viewport = new Rectangle(left, top, width, height);
		}

 public void CreateOutlinedRectFromRectangle(Type resolver)
 {
     var halfScreenRect = new Rectangle(Point.Zero, Size.Half);
     OutlinedRect outlinedRect = null;
     Start(resolver, (Renderer r) =>
         r.Add(outlinedRect = new OutlinedRect(halfScreenRect, Color.Red)),
         () => Assert.AreEqual(Color.Red, outlinedRect.Color));
 }

 public GradientFilledRect(Rectangle drawArea, Color startColor, Color finalColor)
     : base(drawArea)
 {
     Color = startColor;
     FinalColor = finalColor;
     UpdateCorners();
     OnDraw<GradientRectRenderer>();
 }

 public void SpawnAtRandomLocation()
 {
     int x = random.Get(2, gridSize - 2);
     int y = random.Get(2, gridSize - 2);
     var newRandomPos = new Vector2D(x * blockSize, y * blockSize);
     var newDrawArea = new Rectangle(newRandomPos, new Size(blockSize));
     DrawArea = newDrawArea;
 }