public sd2.LinearGradientBrush GetBrush(RectangleF rect) { var start = StartPoint; var end = EndPoint; if (wrapMode == GradientWrapMode.Pad) { // winforms does not support pad, so extend to fill entire drawing region if (transform != null) { start = transform.TransformPoint(start); end = transform.TransformPoint(end); } PointF min, max; GradientHelper.GetLinearMinMax(start, end, rect, out min, out max, true); var len = max.LengthTo(min); // find start/end pos based on entire position var startpos = min.LengthTo(start) / len; var endpos = min.LengthTo(end) / len; if (brush == null || lastStartPos != startpos) { lastStartPos = startpos; start = min; end = max; var diff = end - start; // account for innacuracies in system.drawing when nearing horizontal or vertical if (Math.Abs(diff.X) < 0.0001) end.X = start.X; if (Math.Abs(diff.Y) < 0.0001) end.Y = start.Y; brush = new sd2.LinearGradientBrush(start.ToSD(), end.ToSD(), StartColor, EndColor); brush.WrapMode = sd2.WrapMode.Tile; brush.InterpolationColors = new sd2.ColorBlend { Colors = new[] { StartColor, StartColor, EndColor, EndColor }, Positions = new[] { 0f, startpos, endpos, 1f, } }; } } else if (brush == null) { brush = new sd2.LinearGradientBrush(StartPoint.ToSD(), EndPoint.ToSD(), StartColor, EndColor); brush.WrapMode = wrapMode.ToSD(); if (transform != null) brush.MultiplyTransform(transform.ToSD()); } return brush; }
public UIView(AtlasGlobal atlas, RectangleF frame) : base(atlas) { Frame = frame; InitializeView(); }
protected override void DrawCore(RenderContext context, RenderItemCollection renderItems, int fromIndex, int toIndex) { var graphicsDevice = context.GraphicsDevice; var destination = new RectangleF(0, 0, 1, 1); spriteBatch.Begin(SpriteSortMode.FrontToBack, graphicsDevice.BlendStates.Opaque, graphicsDevice.SamplerStates.LinearClamp, graphicsDevice.DepthStencilStates.None); for(var i = fromIndex; i <= toIndex; ++i) { var background = (BackgroundComponent)renderItems[i].DrawContext; var texture = background.Texture; if (texture == null) continue; var target = CurrentRenderFrame; var imageBufferMinRatio = Math.Min(texture.ViewWidth / (float)target.Width, texture.ViewHeight / (float)target.Height); var sourceSize = new Vector2(target.Width * imageBufferMinRatio, target.Height * imageBufferMinRatio); var source = new RectangleF((texture.ViewWidth - sourceSize.X) / 2, (texture.ViewHeight - sourceSize.Y) / 2, sourceSize.X, sourceSize.Y); spriteBatch.Draw(texture, destination, source, Color.White, 0, Vector2.Zero); } spriteBatch.End(); }
public void FromLTRBTest(float left, float top, float right, float bottom) { RectangleF expected = new RectangleF(left, top, right - left, bottom - top); RectangleF actual = RectangleF.FromLTRB(left, top, right, bottom); Assert.Equal(expected, actual); }
/// <summary> /// Over de Draw /// </summary> public static void Draw (this SpriteBatch bat, Texture2D texture, RectangleF rectangle, Color color) { bat.Draw (texture, (Rectangle)rectangle, color); }
/// <summary> /// Method for creating pie chart symbols /// </summary> /// <remarks> /// <para>In this example we just create some random pie charts, /// but it probably should be based on attributes read from the row.</para> /// <para>Credits goes to gonzalo_ar for posting this in the forum</para></remarks> /// <param name="row"></param> /// <returns></returns> private static Bitmap GetPieChart(GeoAPI.Features.IFeature row) { // Replace polygon with a center point (this is where we place the symbol row.Geometry = row.Geometry.Centroid; // Just for the example I use random values int size = rand.Next(20, 35); int angle1 = rand.Next(60, 180); int angle2 = rand.Next(angle1 + 60, 300); RectangleF rect = new RectangleF(0, 0, size, size); Bitmap b = new Bitmap(size, size); using (IGraphics g = Graphics.FromImage(b).G()) { // Draw Pie g.FillPie(Brushes.LightGreen, rect, 0, angle1); g.FillPie(Brushes.Pink, rect, angle1, angle2 - angle1); g.FillPie(Brushes.PeachPuff, rect, angle2, 360 - angle2); // Draw Borders g.DrawPie(Pens.Green, rect, 0, angle1); g.DrawPie(Pens.Red, rect, angle1, angle2 - angle1); g.DrawPie(Pens.Orange, rect, angle2, 360 - angle2); } return b; }
public RenderContext Derive(RectangleF bounds, Matrix? localLayoutTransform, Matrix? localRenderTransform, Vector2? renderTransformOrigin, double localOpacity) { Matrix finalTransform = _transform.Clone(); if (localLayoutTransform.HasValue && localLayoutTransform != Matrix.Identity) { // Layout transforms don't support translations, so center the transformation matrix at the start point // of the control and apply the layout transform without translation Vector2 origin = new Vector2(bounds.X + 0.5f*bounds.Width, bounds.Y + 0.5f*bounds.Height); Matrix transform = Matrix.Translation(new Vector3(-origin.X, -origin.Y, 0)); transform *= localLayoutTransform.Value.RemoveTranslation(); transform *= Matrix.Translation(new Vector3(origin.X, origin.Y, 0)); finalTransform = transform * finalTransform; } if (localRenderTransform.HasValue && localRenderTransform != Matrix.Identity) { Vector2 origin = renderTransformOrigin.HasValue ? new Vector2( bounds.X + bounds.Width * renderTransformOrigin.Value.X, bounds.Y + bounds.Height * renderTransformOrigin.Value.Y) : new Vector2(bounds.X, bounds.Y); Matrix transform = Matrix.Translation(new Vector3(-origin.X, -origin.Y, 0)); transform *= localRenderTransform.Value; transform *= Matrix.Translation(new Vector3(origin.X, origin.Y, 0)); finalTransform = transform * finalTransform; } RenderContext result = new RenderContext(finalTransform, _opacity * localOpacity, bounds, _zOrder - 0.001f); return result; }
public QuadTree(int level, RectangleF bounds) { this.Level = level; this.Objects = new List<BaseEntity>(); this.Bounds = bounds; this.Nodes = new QuadTree[4]; }
private void ClientAreaChanged(Vector2 position, Vector2 size) { mPosition = position; mSize = size; mTargetRectangle = new RectangleF(position.X, position.Y, size.X, size.Y); }
public override void Draw(SharpDXRenderer renderer) { base.Draw(renderer); if (this.ChildControls.Count == 0) return; TabHeaders = new RectangleF[ChildControls.Count]; int idx = 0; Vector2 location = this.GetAbsoluteLocation(); foreach (SharpDXControl panel in ChildControls) { Vector2 size = renderer.MeasureString(panel.Text, this.Font); if (idx == 0) TabHeaders[idx] = new RectangleF(0, 0, (float)Math.Max(MinimumHeaderWidth, size.X + this.MarginLeft + this.MarginRight), size.Y); else TabHeaders[idx] = new RectangleF(TabHeaders[idx - 1].X + TabHeaders[idx - 1].Width, TabHeaders[idx - 1].Y, (float)Math.Max(MinimumHeaderWidth, size.X + this.MarginLeft + this.MarginRight), size.Y); Vector2 tabLocation = location + new Vector2(TabHeaders[idx].X, TabHeaders[idx].Y); renderer.FillRectangle(this.BackColor, tabLocation, new Vector2(TabHeaders[idx].Width, TabHeaders[idx].Height)); if (this.SelectedIndex == idx) renderer.FillRectangle(this.ForeColor * 0.1f, tabLocation, new Vector2(TabHeaders[idx].Width, TabHeaders[idx].Height)); renderer.DrawRectangle(this.ForeColor, tabLocation, new Vector2(TabHeaders[idx].Width, TabHeaders[idx].Height)); renderer.DrawText(panel.Text, this.ForeColor, this.Font, tabLocation + Vector2.UnitX * this.MarginLeft); idx++; } }
private void Init(float x1, float y1, Color color1, float x2, float y2, Color color2, LinearGradientMode linearGradientMode) { _gradientRectangle = new RectangleF(x1, y1, x2-x1, y2-y1); PointF [] points; switch (linearGradientMode) { case LinearGradientMode.Horizontal : Init(x1, y1, color1, x2, y1, color2, false); break; case LinearGradientMode.Vertical : Init(x1, y1, color1, x1, y2, color2, false); break; case LinearGradientMode.BackwardDiagonal : points = GetMedianeEnclosingRect(x1, y1, x2, y2, false); Init(points[0].X, points[0].Y, color2, points[1].X, points[1].Y, color1, false); break; case LinearGradientMode.ForwardDiagonal : points = GetMedianeEnclosingRect(x1, y1, x2, y2, true); Init(points[0].X, points[0].Y, color1, points[1].X, points[1].Y, color2, false); break; default : throw new ArgumentException("LinearGradientMode"); } }
/// <summary> /// Creates a new instance of this class. This constructor gets typically called from the <see cref="Derive"/> method. /// </summary> /// <param name="transform">Combined current transformation to use in this context.</param> /// <param name="opacity">Combined opacity value.</param> /// <param name="untransformedBounds">Bounds of the element currently being rendered, in local space.</param> /// <param name="zOrder">Z coordinate of the currently rendered element.</param> public RenderContext(Matrix transform, double opacity, RectangleF untransformedBounds, float zOrder) { _zOrder = zOrder; _opacity = opacity; _transform = transform; SetUntransformedContentsBounds(untransformedBounds); }
public override void Draw(RectangleF visibleRectangle) { var renderOrderFunction = GetRenderOrderFunction(); var tileLocationFunction = GetTileLocationFunction(); var firstCol = (int)Math.Floor(visibleRectangle.Left / _map.TileWidth); var firstRow = (int)Math.Floor(visibleRectangle.Top / _map.TileHeight); // +3 to cover any gaps var columns = Math.Min(_map.Width, (int)visibleRectangle.Width / _map.TileWidth) + 3; var rows = Math.Min(_map.Height, (int)visibleRectangle.Height / _map.TileHeight) + 3; _spriteBatch.Begin(blendState: BlendState.AlphaBlend, samplerState: SamplerState.PointClamp); foreach (var tile in renderOrderFunction(firstCol, firstRow, firstCol + columns, firstRow + rows)) { var region = tile != null ? _map.GetTileRegion(tile.Id) : null; if (region != null) { var point = tileLocationFunction(tile); var destinationRectangle = new Rectangle(point.X, point.Y, region.Width, region.Height); _spriteBatch.Draw(region, destinationRectangle, Color.White); } } _spriteBatch.End(); }
protected override void DrawCore(RenderContext context, RenderItemCollection renderItems, int fromIndex, int toIndex) { var graphicsDevice = context.GraphicsDevice; var destination = new RectangleF(0, 0, 1, 1); // find the last background to display with valid texture BackgroundComponent background = null; for (var i = toIndex; i >= fromIndex; --i) { background = (BackgroundComponent)renderItems[i].DrawContext; if (background.Texture != null) break; } // Abort if not valid background component if (background == null || background.Texture == null) return; var texture = background.Texture; var target = CurrentRenderFrame; var imageBufferMinRatio = Math.Min(texture.ViewWidth / (float)target.Width, texture.ViewHeight / (float)target.Height); var sourceSize = new Vector2(target.Width * imageBufferMinRatio, target.Height * imageBufferMinRatio); var source = new RectangleF((texture.ViewWidth - sourceSize.X) / 2, (texture.ViewHeight - sourceSize.Y) / 2, sourceSize.X, sourceSize.Y); spriteBatch.Parameters.Add(BackgroundEffectKeys.Intensity, background.Intensity); spriteBatch.Begin(SpriteSortMode.FrontToBack, graphicsDevice.BlendStates.Opaque, graphicsDevice.SamplerStates.LinearClamp, graphicsDevice.DepthStencilStates.None, null, backgroundEffect); spriteBatch.Draw(texture, destination, source, Color.White, 0, Vector2.Zero); spriteBatch.End(); }
public static bool Overlap(LineF line, RectangleF rect) { line.Setup(); float tmin, tmax, tymin, tymax; if (line._dx >= 0) { tmin = (rect.X - line.Start.X) * line._idx; tmax = (rect.X + rect.Width - line.Start.X) * line._idx; } else { tmin = (rect.X + rect.Width - line.Start.X) * line._idx; tmax = (rect.X - line.Start.X) * line._idx; } if (line._dy >= 0) { tymin = (rect.Y - line.Start.Y) * line._idy; tymax = (rect.Y + rect.Height - line.Start.Y) * line._idy; } else { tymin = (rect.Y + rect.Height - line.Start.Y) * line._idy; tymax = (rect.Y - line.Start.Y) * line._idy; } return !((tmin > tymax) || (tymin > tmax)); }
/// <summary> /// Calculates the signed depth of intersection between two rectangles. /// </summary> /// <returns> /// The amount of overlap between two intersecting rectangles. These /// depth values can be negative depending on which wides the rectangles /// intersect. This allows callers to determine the correct direction /// to push objects in order to resolve collisions. /// If the rectangles are not intersecting, Vector2.Zero is returned. /// </returns> public static Vector2 GetIntersectionDepth(this RectangleF rectA, RectangleF rectB) { // Calculate half sizes. float halfWidthA = rectA.Width / 2.0f; float halfHeightA = rectA.Height / 2.0f; float halfWidthB = rectB.Width / 2.0f; float halfHeightB = rectB.Height / 2.0f; // Calculate centers. Vector2 centerA = new Vector2(rectA.Left + halfWidthA, rectA.Top + halfHeightA); Vector2 centerB = new Vector2(rectB.Left + halfWidthB, rectB.Top + halfHeightB); // Calculate current and minimum-non-intersecting distances between centers. float distanceX = centerA.X - centerB.X; float distanceY = centerA.Y - centerB.Y; float minDistanceX = halfWidthA + halfWidthB; float minDistanceY = halfHeightA + halfHeightB; // If we are not intersecting at all, return (0, 0). if (Math.Abs(distanceX) >= minDistanceX || Math.Abs(distanceY) >= minDistanceY) return Vector2.Zero; // Calculate and return intersection depths. float depthX = distanceX > 0 ? minDistanceX - distanceX : -minDistanceX - distanceX; float depthY = distanceY > 0 ? minDistanceY - distanceY : -minDistanceY - distanceY; return new Vector2(depthX, depthY); }
private void InitView(RectangleF viewArea) { BackgroundColor = UIColor.FromRGB (0xFF, 0xFF, 0xFF); Frame = viewArea; ContentSize = viewArea.Size; AutoresizingMask = UIViewAutoresizing.All; }
public HazardBox( CubeGame game, World world, RectangleF rec, BodyType bodyType = BodyType.Static, float density = 1, Category categories = Constants.Categories.DEFAULT, Category killCategories = Constants.Categories.ACTORS ) : base(game, world, rec.Center.ToUnits(), 0, new HazardBoxMaker( rec.Width, rec.Height )) { mWidth = rec.Width; mHeight = rec.Height; Fixture box = FixtureFactory.AttachRectangle( mWidth.ToUnits(), mHeight.ToUnits(), density, Vector2.Zero, Body, new Flat() ); Fixture killBox = box.CloneOnto( Body ); killBox.IsSensor = true; killBox.UserData = new Hazard( "killbox" ); Body.BodyType = bodyType; Body.CollisionCategories = categories; killBox.CollidesWith = killCategories; box.CollidesWith ^= killCategories; }
/// <summary> /// Initializes a new instance of the <see cref="RectangleRenderUnit" /> class. /// </summary> /// <param name="rectangle">The rectangle.</param> /// <param name="stroke">The stroke.</param> /// <param name="fill">The fill.</param> /// <param name="thickness">The thickness.</param> public RectangleRenderUnit(RectangleF rectangle, Brush stroke, Brush fill, float thickness) { this.rectangle = rectangle; this.stroke = stroke; this.fill = fill; this.thickness = thickness; }
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 LinearGradientBrush (RectangleF rect, Color color1, Color color2, LinearGradientMode linearGradientMode) { Status status = GDIPlus.GdipCreateLineBrushFromRect (ref rect, color1.ToArgb (), color2.ToArgb (), linearGradientMode, WrapMode.Tile, out nativeObject); GDIPlus.CheckStatus (status); rectangle = rect; }
public override void AddPotentialFocusableElements(RectangleF? startingRect, ICollection<FrameworkElement> elements) { // if the focus comes from outside the ListView, then we add only the lastSelectedItem to the PotentialFocusableElements // if the focus is inside the ListViewAlreay, then act as normal if (HomeMenuModel != null) { lock (_itemsHostPanel.Children.SyncRoot) { // find ListViewItem of LastSelectedItem foreach (FrameworkElement child in _itemsHostPanel.Children) { var item = child as ListViewItem; if (item != null) { // get the real ListItem from the DataContext and check if this is the currently focused item IDataDescriptor listItem; var lastSelectedItem = HomeMenuModel.MainMenuGroupList.OfType<GroupMenuListItem>().FirstOrDefault(i => i.IsActive); if (item.DataContext.Evaluate(out listItem) && ReferenceEquals(listItem.Value, lastSelectedItem)) { // if LastSelectedItem is not currently focused, then the focus comes from the outside, and it's the focus candidate then if (!ReferenceEquals(item, Screen.FocusedElement)) { elements.Add(item); return; } break; } } } } } base.AddPotentialFocusableElements(startingRect, elements); }
/// <summary> /// returns all objects in cells that the bounding box intersects /// </summary> /// <returns>The neighbors.</returns> /// <param name="bounds">Bounds.</param> /// <param name="layerMask">Layer mask.</param> public HashSet<Collider> aabbBroadphase( ref RectangleF bounds, Collider excludeCollider, int layerMask ) { _tempHashset.Clear(); var p1 = cellCoords( bounds.x, bounds.y ); var p2 = cellCoords( bounds.right, bounds.bottom ); for( var x = p1.X; x <= p2.X; x++ ) { for( var y = p1.Y; y <= p2.Y; y++ ) { var cell = cellAtPosition( x, y ); if( cell == null ) continue; // we have a cell. loop through and fetch all the Colliders for( var i = 0; i < cell.Count; i++ ) { var collider = cell[i]; // skip this collider if it is our excludeCollider or if it doesnt match our layerMask if( collider == excludeCollider || !Flags.isFlagSet( layerMask, collider.physicsLayer ) ) continue; if( bounds.intersects( collider.bounds ) ) _tempHashset.Add( collider ); } } } return _tempHashset; }
public TextButton(string text, Vector2 position) { _centerPosition = position; this.Text = text; _area = new RectangleF(_centerPosition.X, _centerPosition.Y, 1, 1); }
public void CollidesWith(RectangleF boundingBox, Action<CollisionInfo> onCollision) { var sx = (int)(boundingBox.Left / CellWidth); var sy = (int)(boundingBox.Top / CellHeight); var ex = (int)((boundingBox.Right / CellWidth) + 1); var ey = (int)((boundingBox.Bottom / CellHeight) + 1); for (var y = sy; y < ey; y++) { for (var x = sx; x < ex; x++) { if (GetDataAt(x, y) == 0) continue; var cellRectangle = GetCellRectangle(x, y); var intersectingRectangle = RectangleF.Intersect(cellRectangle.ToRectangleF(), boundingBox); if (intersectingRectangle.IsEmpty) continue; var collisionInfo = new CollisionInfo { Row = y, Column = x, IntersectingRectangle = intersectingRectangle, CellRectangle = cellRectangle }; onCollision(collisionInfo); } } }
internal override void recalculateBounds( Collider collider ) { // if we dont have rotation or dont care about TRS we use localOffset as the center so we'll start with that center = collider.localOffset; if( collider.shouldColliderScaleAndRotateWithTransform ) { // we only scale lineraly being a circle so we'll use the max value var scale = collider.entity.transform.scale; var hasUnitScale = scale.X == 1 && scale.Y == 1; var maxScale = Math.Max( scale.X, scale.Y ); radius = _originalRadius * maxScale; if( collider.entity.transform.rotation != 0 ) { // to deal with rotation with an offset origin we just move our center in a circle around 0,0 with our offset making the 0 angle var offsetAngle = Mathf.atan2( collider.localOffset.Y, collider.localOffset.X ) * Mathf.rad2Deg; var offsetLength = hasUnitScale ? collider._localOffsetLength : ( collider.localOffset * collider.entity.transform.scale ).Length(); center = Mathf.pointOnCircle( Vector2.Zero, offsetLength, collider.entity.transform.rotationDegrees + offsetAngle ); } } position = collider.entity.transform.position + center; bounds = new RectangleF( position.X - radius, position.Y - radius, radius * 2f, radius * 2f ); }
public PipeSet(Entity referencePipeEntity, float scrollSpeed, float startScrollPos, float screenWidth) { this.scrollSpeed = scrollSpeed; this.startScrollPos = startScrollPos; halfScrollWidth = screenWidth / 2f; // Store Entity and create another one for two rendering: // top and bottom sprite of pipe. var spriteComp = referencePipeEntity.Get<SpriteComponent>(); bottomPipe = referencePipeEntity.Clone(); topPipe = referencePipeEntity.Clone(); Entity.AddChild(bottomPipe); Entity.AddChild(topPipe); var sprite = spriteComp.CurrentSprite; pipeWidth = sprite.SizeInPixels.X; pipeHeight = sprite.SizeInPixels.Y; halfPipeWidth = pipeWidth/2f; // Setup pipeCollider pipeCollider = new RectangleF(0, 0, pipeWidth, pipeHeight); // Place the top/bottom pipes relatively to the root. topPipe.Transform.Position.Y = -(VerticalDistanceBetweenPipe + pipeHeight) * 0.5f; bottomPipe.Transform.Position.Y = (VerticalDistanceBetweenPipe + pipeHeight) * 0.5f; bottomPipe.Transform.Rotation = Quaternion.RotationZ(MathUtil.Pi); ResetPipe(); }
/// <summary> /// internal hack used by Particles so they can reuse a Circle for all collision checks /// </summary> /// <param name="radius">Radius.</param> /// <param name="position">Position.</param> internal void recalculateBounds( float radius, Vector2 position ) { _originalRadius = radius; this.radius = radius; this.position = position; bounds = new RectangleF( position.X - radius, position.Y - radius, radius * 2f, radius * 2f ); }
internal GPRECTF(RectangleF rect) { this.X = rect.X; this.Y = rect.Y; this.Width = rect.Width; this.Height = rect.Height; }
public void AddImage(Image image) { // scale image float widthMultiplier = maxDimension / (float)image.Width; float heightMultiplier = maxDimension / (float)image.Height; float minMultiplier = Math.Min(Math.Min(widthMultiplier, heightMultiplier), 1f); float newWidth = minMultiplier * (float)image.Width; float newHeight = minMultiplier * (float)image.Height; // choose a random translation & rotation float angle = GetRandomAngle(); PointF newDimensions = RotateAndFindNewDimensions(new PointF(newWidth, newHeight), angle); PointF offset = GetRandomOffset(newDimensions); surfaceGraphics.TranslateTransform(offset.X, offset.Y); surfaceGraphics.RotateTransform(angle); // draw borders + image DrawRectangle(Brushes.White, newWidth, newHeight, thickLineWidth); DrawRectangle(Brushes.Black, newWidth, newHeight, thinLineWidth); surfaceGraphics.DrawImage(image, -newWidth / 2f, -newHeight / 2f, newWidth, newHeight); // calculate new image boundaries RectangleF newBounds = new RectangleF( offset.X - newDimensions.X / 2f, offset.Y - newDimensions.Y / 2f, newDimensions.X, newDimensions.Y); if (surfaceBounds.HasValue) { surfaceBounds = Union(surfaceBounds.Value, newBounds); } else { surfaceBounds = newBounds; } surfaceGraphics.ResetTransform(); }
public override void Render(float delta, float mouseX, float mouseY) { var editor = (GuiScreenEditor)EditorWindow.Instance.GuiScreen; var rect = ClientRectangle; var mouseOver = false; // grid transparency int griddim = EditorSettings.GridOpacity; GL.Color4(Color.FromArgb(griddim, 36, 35, 33)); Glu.RenderQuad(rect.X, rect.Y, rect.Width, rect.Height); var cellSize = rect.Width / 3f; var noteSize = cellSize * 0.75f; var gap = cellSize - noteSize; var audioTime = EditorWindow.Instance.MusicPlayer.CurrentTime.TotalMilliseconds; if (editor.Numpad.Toggle) { if (EditorWindow.Instance.inputState == "keyboard") { EditorWindow.Instance.ChangeKeyMapping("numpad"); } } else { if (EditorWindow.Instance.inputState == "numpad") { EditorWindow.Instance.ChangeKeyMapping("keyboard"); } } GL.Color3(0.2, 0.2, 0.2f); for (float y = 0; y <= 3; y++) { var ly = y * cellSize; Glu.RenderQuad((int)(rect.X), (int)(rect.Y + ly), rect.Width + 1, 1); } for (float x = 0; x <= 3; x++) { var lx = x * cellSize; Glu.RenderQuad((int)(rect.X + lx), (int)(rect.Y), 1, rect.Height + 1); } if (editor.NoteAlign.Value != 1 && editor.QuantumGridLines.Toggle) { GL.Begin(PrimitiveType.Lines); var div = editor.NoteAlign.Value + 1; for (int i = 1; i < div; i++) { //GL.Vertex2(rect.X + rect.Width / div * i, rect.Y); //GL.Vertex2(rect.X + rect.Width / div * i, rect.Y + rect.Height / div * i); GL.Vertex2(rect.X + rect.Width / div * i, rect.Y); GL.Vertex2(rect.X + rect.Width / div * i, rect.Y + rect.Height); GL.Vertex2(rect.X, rect.Y + rect.Height / div * i); GL.Vertex2(rect.X + rect.Width, rect.Y + rect.Height / div * i); } GL.End(); } var fr = EditorWindow.Instance.FontRenderer; GL.Color3(0.2f, 0.2f, 0.2f); foreach (var pair in EditorWindow.Instance.KeyMapping) { if (pair.Key == Key.Y) { continue; } var letter = pair.Key == Key.Z ? "Y/Z" : pair.Key.ToString(); if (letter.Length > 1) { letter = letter.Replace("Keypad", ""); } var tuple = pair.Value; var x = rect.X + tuple.Item1 * cellSize + cellSize / 2; var y = rect.Y + tuple.Item2 * cellSize + cellSize / 2; var width = fr.GetWidth(letter, 38); var height = fr.GetHeight(38); fr.Render(letter, (int)(x - width / 2f), (int)(y - height / 2), 38); } Note last = null; Note next = null; for (var index = 0; index < EditorWindow.Instance.Notes.Count; index++) { var note = EditorWindow.Instance.Notes[index]; var passed = audioTime > note.Ms + 1; var visible = !passed && note.Ms - audioTime <= 750; if (passed) { last = note; } else if (next == null) { next = note; } if (!visible) { if (passed && next != null) { break; } continue; } var x = rect.X + note.X * cellSize + gap / 2; var y = rect.Y + note.Y * cellSize + gap / 2; var progress = (float)Math.Pow(1 - Math.Min(1, (note.Ms - audioTime) / 750.0), 2); var noteRect = new RectangleF(x, y, noteSize, noteSize); OpenTK.Graphics.Color4 colora = new OpenTK.Graphics.Color4(note.Color.R, note.Color.G, note.Color.B, progress * 0.15f); GL.Color4(colora); Glu.RenderQuad(noteRect); OpenTK.Graphics.Color4 color = new OpenTK.Graphics.Color4(note.Color.R, note.Color.G, note.Color.B, progress); GL.Color4(color); Glu.RenderOutline(noteRect); if (editor.ApproachSquares.Toggle) { var outlineSize = 4 + noteSize + noteSize * (1 - progress) * 2; Glu.RenderOutline(x - outlineSize / 2 + noteSize / 2, y - outlineSize / 2 + noteSize / 2, outlineSize, outlineSize); } if (editor.GridNumbers.Toggle) { GL.Color4(1, 1, 1, progress); var s = $"{(index + 1):#,##}"; var w = fr.GetWidth(s, 24); var h = fr.GetHeight(24); fr.Render(s, (int)(noteRect.X + noteRect.Width / 2 - w / 2f), (int)(noteRect.Y + noteRect.Height / 2 - h / 2f), 24); } if (!mouseOver) { MouseOverNote = null; } if (EditorWindow.Instance.SelectedNotes.Contains(note)) { var outlineSize = noteSize + 8; GL.Color4(0, 0.5f, 1f, progress); Glu.RenderOutline(x - outlineSize / 2 + noteSize / 2, y - outlineSize / 2 + noteSize / 2, outlineSize, outlineSize); } if (!mouseOver && noteRect.Contains(mouseX, mouseY)) { MouseOverNote = note; mouseOver = true; GL.Color3(0, 1, 0.25f); Glu.RenderOutline(x - 4, y - 4, noteSize + 8, noteSize + 8); } } //RENDER AUTOPLAY if (editor.Autoplay.Toggle) { RenderAutoPlay(last, next, cellSize, rect, audioTime); } }
public static PortableRectangle ToPortable(this RectangleF rectangle) { return(new PortableRectangle(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height)); }
protected override void Layout() { base.Layout(); // Set the actual layout of the component here: // first change the width to suit; using max to determine component visualisation style FixLayout(); int s = 3; //spacing to edges and internal between boxes //spacer and title int h0 = 0; if (SpacerTxt1 != "") { h0 = 10; SpacerBounds1 = new RectangleF(Bounds.X, Bounds.Bottom + s / 2, Bounds.Width, h0); } // create annotation (x, y, z, xx, yy, zz) placeholders float w = (Bounds.Width - 6 * s) / 6; // width of each check box int h2 = 15; // height xTxtBounds1 = new RectangleF(Bounds.X + s, Bounds.Bottom + h0, w, h2); yTxtBounds1 = new RectangleF(Bounds.X + 1.5f * s + w, Bounds.Bottom + h0, w, h2); zTxtBounds1 = new RectangleF(Bounds.X + 2.5f * s + 2 * w, Bounds.Bottom + h0, w, h2); xxTxtBounds1 = new RectangleF(Bounds.X + 3f * s + 3 * w, Bounds.Bottom + h0, w + s, h2); yyTxtBounds1 = new RectangleF(Bounds.X + 4f * s + 4 * w, Bounds.Bottom + h0, w + s, h2); zzTxtBounds1 = new RectangleF(Bounds.X + 5f * s - 1 + 5 * w, Bounds.Bottom + h0, w + s, h2); // create check box placeholders int h3 = 15; xBounds1 = new RectangleF(Bounds.X + s / 2, Bounds.Bottom + h0 + h2, w, h3); yBounds1 = new RectangleF(Bounds.X + 1.5f * s + w, Bounds.Bottom + h0 + h2, w, h3); zBounds1 = new RectangleF(Bounds.X + 2.5f * s + 2 * w, Bounds.Bottom + h0 + h2, w, h3); xxBounds1 = new RectangleF(Bounds.X + 3.5f * s + 3 * w, Bounds.Bottom + h0 + h2, w, h3); yyBounds1 = new RectangleF(Bounds.X + 4.5f * s + 4 * w, Bounds.Bottom + h0 + h2, w, h3); zzBounds1 = new RectangleF(Bounds.X + 5.5f * s - 1 + 5 * w, Bounds.Bottom + h0 + h2, w, h3); Bounds = new RectangleF(Bounds.X, Bounds.Y, Bounds.Width, Bounds.Height + h0 + h2 + h3 + s); h0 = 0; if (SpacerTxt2 != "") { h0 = 10; SpacerBounds2 = new RectangleF(Bounds.X, Bounds.Bottom + s / 2, Bounds.Width, h0); } // create annotation (x, y, z, xx, yy, zz) placeholders xTxtBounds2 = new RectangleF(Bounds.X + s, Bounds.Bottom + h0, w, h2); yTxtBounds2 = new RectangleF(Bounds.X + 1.5f * s + w, Bounds.Bottom + h0, w, h2); zTxtBounds2 = new RectangleF(Bounds.X + 2.5f * s + 2 * w, Bounds.Bottom + h0, w, h2); xxTxtBounds2 = new RectangleF(Bounds.X + 3f * s + 3 * w, Bounds.Bottom + h0, w + s, h2); yyTxtBounds2 = new RectangleF(Bounds.X + 4f * s + 4 * w, Bounds.Bottom + h0, w + s, h2); zzTxtBounds2 = new RectangleF(Bounds.X + 5f * s - 1 + 5 * w, Bounds.Bottom + h0, w + s, h2); // create check box placeholders xBounds2 = new RectangleF(Bounds.X + s / 2 + 1, Bounds.Bottom + h0 + h2, w, h3); yBounds2 = new RectangleF(Bounds.X + 1.5f * s + w, Bounds.Bottom + h0 + h2, w, h3); zBounds2 = new RectangleF(Bounds.X + 2.5f * s + 2 * w, Bounds.Bottom + h0 + h2, w, h3); xxBounds2 = new RectangleF(Bounds.X + 3.5f * s + 3 * w, Bounds.Bottom + h0 + h2, w, h3); yyBounds2 = new RectangleF(Bounds.X + 4.5f * s + 4 * w, Bounds.Bottom + h0 + h2, w, h3); zzBounds2 = new RectangleF(Bounds.X + 5.5f * s - 1 + 5 * w, Bounds.Bottom + h0 + h2, w, h3); Bounds = new RectangleF(Bounds.X, Bounds.Y, Bounds.Width, Bounds.Height + h0 + h2 + h3 + s); }
public TiledLayerDelegate (TiledPdfView view) { this.view = view; bounds = view.Bounds; }
public DrawingView(RectangleF rect) : base(rect) { ContentMode = UIViewContentMode.Redraw; this.AutoresizingMask = UIViewAutoresizing.All; BackgroundColor = UIColor.White; }
// masking breaks the pan-out transform with nested sub-settings panels. protected override bool ComputeIsMaskedAway(RectangleF maskingBounds) => false;
public static Rectangle ToRectangle(RectangleF rectF) { return(new Rectangle((int)rectF.X, (int)rectF.Y, (int)rectF.Width, (int)rectF.Height)); }
/// <summary> /// DrawTab method /// </summary> /// <param name="g">Graphic Object</param> /// <param name="tabPage">TagPage object</param> /// <param name="nIndex">integer index</param> internal void DrawTab(Graphics g, TabPage tabPage, int nIndex) { Rectangle recBounds = this.GetTabRect(nIndex); RectangleF tabTextArea = (RectangleF)this.GetTabRect(nIndex); bool bSelected = (this.SelectedIndex == nIndex); Point[] pt = new Point[7]; if (this.Alignment == TabAlignment.Top) { pt[0] = new Point(recBounds.Left, recBounds.Bottom); pt[1] = new Point(recBounds.Left, recBounds.Top + 3); pt[2] = new Point(recBounds.Left + 3, recBounds.Top); pt[3] = new Point(recBounds.Right - 3, recBounds.Top); pt[4] = new Point(recBounds.Right, recBounds.Top + 3); pt[5] = new Point(recBounds.Right, recBounds.Bottom); pt[6] = new Point(recBounds.Left, recBounds.Bottom); } else { pt[0] = new Point(recBounds.Left, recBounds.Top); pt[1] = new Point(recBounds.Right, recBounds.Top); pt[2] = new Point(recBounds.Right, recBounds.Bottom - 3); pt[3] = new Point(recBounds.Right - 3, recBounds.Bottom); pt[4] = new Point(recBounds.Left + 3, recBounds.Bottom); pt[5] = new Point(recBounds.Left, recBounds.Bottom - 3); pt[6] = new Point(recBounds.Left, recBounds.Top); } //---------------------------- // fill this tab with background color Brush br = new SolidBrush(tabPage.BackColor); g.FillPolygon(br, pt); br.Dispose(); //---------------------------- //---------------------------- // draw border //g.DrawRectangle(SystemPens.ControlDark, recBounds); g.DrawPolygon(SystemPens.ControlDark, pt); if (bSelected) { //---------------------------- // clear bottom lines Pen pen = new Pen(tabPage.BackColor); switch (this.Alignment) { case TabAlignment.Top: g.DrawLine(pen, recBounds.Left + 1, recBounds.Bottom, recBounds.Right - 1, recBounds.Bottom); g.DrawLine(pen, recBounds.Left + 1, recBounds.Bottom + 1, recBounds.Right - 1, recBounds.Bottom + 1); break; case TabAlignment.Bottom: g.DrawLine(pen, recBounds.Left + 1, recBounds.Top, recBounds.Right - 1, recBounds.Top); g.DrawLine(pen, recBounds.Left + 1, recBounds.Top - 1, recBounds.Right - 1, recBounds.Top - 1); g.DrawLine(pen, recBounds.Left + 1, recBounds.Top - 2, recBounds.Right - 1, recBounds.Top - 2); break; } pen.Dispose(); //---------------------------- } //---------------------------- //---------------------------- // draw tab's icon if ((tabPage.ImageIndex >= 0) && (ImageList != null) && (ImageList.Images[tabPage.ImageIndex] != null)) { int nLeftMargin = 8; int nRightMargin = 2; Image img = ImageList.Images[tabPage.ImageIndex]; Rectangle rimage = new Rectangle(recBounds.X + nLeftMargin, recBounds.Y + 1, img.Width, img.Height); // adjust rectangles float nAdj = (float)(nLeftMargin + img.Width + nRightMargin); rimage.Y += (recBounds.Height - img.Height) / 2; tabTextArea.X += nAdj; tabTextArea.Width -= nAdj; // draw icon g.DrawImage(img, rimage); } //---------------------------- //---------------------------- // draw string StringFormat stringFormat = new StringFormat(); stringFormat.Alignment = StringAlignment.Center; stringFormat.LineAlignment = StringAlignment.Center; br = new SolidBrush(tabPage.ForeColor); g.DrawString(tabPage.Text, Font, br, tabTextArea, stringFormat); //---------------------------- }
public void IntersectClip(RectangleF rect) { g.IntersectClip(rect); }
public void DrawRectangle(AbstractBrush brush, RectangleF rect) { Apply(brush); g.FillRectangle(this.brush, rect); }
public static void setClip(RectangleF limitRect) { setClip((int)limitRect.X, (int)limitRect.Y, (int)limitRect.Width, (int)limitRect.Height); }
public static void drawTextureImage(TextureImage textrueImage, RectangleF srcRect, RectangleF destRect, Matrix4 matrix, float alpha) { alpha = MathUtil.limitNumber(alpha, 0, 1); //GLGraphics.setColor((uint)(0xFFFFFF | (((int)(alpha*255))<<24))); GL.Color4(1.0f, 1.0f, 1.0f, alpha); GL.PushMatrix(); GL.Enable(EnableCap.Texture2D); GL.Enable(EnableCap.LineSmooth); //目标尺寸 float _dw = destRect.Width; float _dh = destRect.Height; //贴图坐标 float txW = textrueImage.TextureWidth; float txH = textrueImage.TextureHight; float ltX = srcRect.X / txW; float ltY = srcRect.Y / txH; float rbX = (srcRect.X + srcRect.Width) / txW; float rbY = (srcRect.Y + srcRect.Height) / txH; GL.BindTexture(TextureTarget.Texture2D, textrueImage._name); matrixDraw.identity(); matrixDraw.preTranslate(destRect.X, destRect.Y); if (matrix != null) { matrix.multiply(matrixDraw, matrixDraw); } float[] data = matrixDraw.getValue(); GL.MultMatrix(data); GL.Begin(BeginMode.Quads); GL.TexCoord2(ltX, ltY); GL.Vertex3(0, 0, 0); GL.TexCoord2(rbX, ltY); GL.Vertex3(_dw, 0, 0); GL.TexCoord2(rbX, rbY); GL.Vertex3(_dw, _dh, 0); GL.TexCoord2(ltX, rbY); GL.Vertex3(0, _dh, 0); GL.End(); GL.Disable(EnableCap.Texture2D); GL.PopMatrix(); }
/** * 简易的绘图方式 */ public static void drawTextureImage(TextureImage textrueImage, RectangleF srcRect, float destX, float destY) { drawTextureImage(textrueImage, srcRect, new RectangleF(destX, destY, srcRect.Width, srcRect.Height), null, 1.0f); }
public override void Draw (RectangleF rect) { // empty (on purpose so the delegate will draw) }
public EllipseShape(RectangleF rect) : base(rect) { }
// 進行と描画 /// <summary> /// アイキャッチのアニメーションを進行し、アイキャッチ画像を描画する。 /// </summary> protected override void 進行描画する(DeviceContext dc, StoryboardStatus 描画しないStatus) { bool すべて完了 = true; var preTrans = dc.Transform; #region " シャッター " //---------------- for (int i = シャッター枚数 - 1; i >= 0; i--) { var context = this._シャッターアニメーション[i]; if (context.ストーリーボード.Status != StoryboardStatus.Ready) { すべて完了 = false; } if (context.ストーリーボード.Status == 描画しないStatus) { continue; } dc.Transform = Matrix3x2.Rotation(context.角度rad) * Matrix3x2.Translation(context.開き中心位置 + (context.閉じ中心位置 - context.開き中心位置) * new Vector2((float)context.開to閉割合.Value)) * preTrans; float w = context.矩形サイズ.Width; float h = context.矩形サイズ.Height; var rc = new RectangleF(-w / 2f, -h / 2f, w, h); dc.FillRectangle(rc, context.ブラシ); dc.DrawRectangle(rc, this._白ブラシ, 3.0f); } dc.Transform = preTrans; //---------------- #endregion if (null != this._ロゴ不透明度) { #region " ロゴ " //---------------- if (this._ロゴボード.Status != StoryboardStatus.Ready) { すべて完了 = false; } float 率 = this._ロゴ表示幅 / this._ロゴ.サイズ.Width; this._ロゴ.描画する( dc, this._ロゴ表示位置.Width, this._ロゴ表示位置.Height, 透明度0to1: (float)this._ロゴ不透明度.Value, X方向拡大率: 率, Y方向拡大率: 率); //---------------- #endregion } if (すべて完了) { if (this.現在のフェーズ == フェーズ.クローズ) { this.現在のフェーズ = フェーズ.クローズ完了; } else if (this.現在のフェーズ == フェーズ.オープン) { this.現在のフェーズ = フェーズ.オープン完了; } } }
private void WriteError(String msg, String code) { if (this.Format == WMSImageFormat.kml) { WriteKMLError(msg, code); } if (this.Exceptions == WMSExceptionType.se_xml) { String sMsg = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""no"" ?> <!DOCTYPE ServiceExceptionReport SYSTEM ""http://www.digitalearth.gov/wmt/xml/exception_1_1_0.dtd""> <ServiceExceptionReport version=""1.1.0""> <ServiceException> message. </ServiceException> </ServiceExceptionReport>"; sMsg = sMsg.Replace("message.", msg); if (code != null) { sMsg = sMsg.Replace("<ServiceException>", "<ServiceException code=\"" + code + "\">"); } //Response.ContentType = "application/vnd.ogc.se_xml"; //Response.Write(sMsg); //Response.End(); } else if (this.Exceptions == WMSExceptionType.se_in_image) { Bitmap bt = new Bitmap(this.Width, this.Height, PixelFormat.Format32bppArgb); Graphics g = Graphics.FromImage(bt); if (!this.Transparent) { g.Clear(this.BgColor); } else { bt.MakeTransparent(this.BgColor); g.Clear(this.BgColor); } Font f = new Font("Tahoma", 12, FontStyle.Regular); SizeF sz = g.MeasureString(msg, f); RectangleF rect = new RectangleF(5f, 5f, sz.Width, sz.Height); g.DrawString(msg, f, new SolidBrush(Color.Black), rect); g.Save(); if (this.Format == WMSImageFormat.gif) { bt = this.CreateTransparentGif(bt, bt.Palette); } MemoryStream oStr = new MemoryStream(); bt.Save(oStr, SystemDrawingGetImageFormat()); //Response.ContentType = this.MimeType; //byte[] img = oStr.ToArray(); //Response.OutputStream.Write(img, 0, img.Length); //Response.End(); } else { Bitmap bt = new Bitmap(this.Width, this.Height, PixelFormat.Format32bppArgb); Graphics g = Graphics.FromImage(bt); if (!this.Transparent) { g.Clear(this.BgColor); } else { bt.MakeTransparent(this.BgColor); g.Clear(this.BgColor); } g.Save(); if (this.Format == WMSImageFormat.gif) { bt = this.CreateTransparentGif(bt, bt.Palette); } MemoryStream oStr = new MemoryStream(); bt.Save(oStr, SystemDrawingGetImageFormat()); //Response.ContentType = this.MimeType; //byte[] img = oStr.ToArray(); //Response.OutputStream.Write(img, 0, img.Length); //Response.End(); } }
private GraphicsPath FillRoundedRectangle(Graphics graphics, SolidBrush brush, RectangleF rect, int borderRadius) { throw new NotImplementedException(); }
protected NativeListViewBase(RectangleF frame, UICollectionViewLayout layout) : base(frame, layout) { Initialize(); }
/// <summary> /// Creates a path rotated by the specified radians around its center. /// </summary> /// <param name="path">The path to rotate.</param> /// <param name="radians">The radians to rotate the path.</param> /// <returns>A <see cref="IPath"/> with a rotate transform applied.</returns> public static IPath Rotate(this IPath path, float radians) { return(path.Transform(Matrix3x2.CreateRotation(radians, RectangleF.Center(path.Bounds)))); }
public object Create(RectangleF rectangle, Color startColor, Color endColor, float angle) { GradientHelper.GetLinearFromRectangle(rectangle, angle, out var startPoint, out var endPoint); return(Create(startColor, endColor, startPoint, endPoint)); }
// --- constructors --- /// <summary>Creates a new character.</summary> /// <param name="textureCoordinates">The texture coordinates that represent the character in the underlying texture.</param> /// <param name="physicalSize">The physical size of the character.</param> /// <param name="typographicSize">The typographic size of the character.</param> internal OpenGlFontChar(RectangleF textureCoordinates, Size physicalSize, Size typographicSize) { this.TextureCoordinates = textureCoordinates; this.PhysicalSize = physicalSize; this.TypographicSize = typographicSize; }
/// <summary> /// Creates a path rotated by the specified radians around its center. /// </summary> /// <param name="path">The path to rotate.</param> /// <param name="radians">The radians to rotate the path.</param> /// <returns>A <see cref="IPath"/> with a rotate transform applied.</returns> public static IPathCollection Rotate(this IPathCollection path, float radians) { return(path.Transform(Matrix3x2Extensions.CreateRotation(radians, RectangleF.Center(path.Bounds)))); }
/// <summary> /// Creates a <see cref="Bitmap"/> of a <see cref="Metafile"/> instance specified in the <paramref name="metafile"/> parameter. /// </summary> /// <param name="metafile">The <see cref="Metafile"/> to convert.</param> /// <param name="requestedSize">The requested size of the result <see cref="Bitmap"/>.</param> /// <param name="antiAliased"><see langword="true"/> to create an anti-aliased result; otherwise, <see langword="false"/>.</param> /// <param name="keepAspectRatio"><see langword="true"/> to keep aspect ratio of the source <paramref name="metafile"/>; otherwise, <see langword="false"/>.</param> /// <returns>A <see cref="Bitmap"/> instance of the requested size.</returns> public static Bitmap ToBitmap(this Metafile metafile, Size requestedSize, bool antiAliased, bool keepAspectRatio) { if (metafile == null) { throw new ArgumentNullException(nameof(metafile), PublicResources.ArgumentNull); } if (requestedSize.Width < 1 || requestedSize.Height < 1) { throw new ArgumentOutOfRangeException(nameof(requestedSize), PublicResources.ArgumentOutOfRange); } Size sourceSize = metafile.Size; Rectangle targetRectangle = new Rectangle(Point.Empty, requestedSize); if (keepAspectRatio && requestedSize != sourceSize) { float ratio = Math.Min((float)requestedSize.Width / sourceSize.Width, (float)requestedSize.Height / sourceSize.Height); targetRectangle.Size = new Size((int)(sourceSize.Width * ratio), (int)(sourceSize.Height * ratio)); targetRectangle.Location = new Point((requestedSize.Width >> 1) - (targetRectangle.Width >> 1), (requestedSize.Height >> 1) - (targetRectangle.Height >> 1)); } if (!antiAliased && requestedSize == targetRectangle.Size) { return(new Bitmap(metafile, requestedSize)); } var result = new Bitmap(requestedSize.Width, requestedSize.Height); if (!antiAliased) { if (OSUtils.IsWindows) { using (Graphics g = Graphics.FromImage(result)) { // it can happen that metafile bounds is not at 0, 0 location GraphicsUnit unit = GraphicsUnit.Pixel; RectangleF sourceRectangle = metafile.GetBounds(ref unit); // no process-wide lock occurs here because the source image is a Metafile g.DrawImage(metafile, targetRectangle, sourceRectangle, unit); g.Flush(); } } else { // On Linux there comes a NotImplementedException for Graphics.DrawImage(metafile, ...) so creating a temp buffer // Note: though this does not crash it can happen that an empty bitmap is created... at least we are future proof in case it will be fixed // Note 2: The result still can be wrong if bounds is not at 0, 0 location using (Bitmap buf = new Bitmap(metafile, targetRectangle.Width, targetRectangle.Height)) buf.DrawInto(result, targetRectangle); } return(result); } // for anti-aliasing using self resizing to prevent process-wide lock that Graphics.DrawImage would cause (even if it is slower) using (Bitmap bmpDouble = new Bitmap(metafile, targetRectangle.Width << 1, targetRectangle.Height << 1)) bmpDouble.DrawInto(result, targetRectangle); return(result); }
/// <summary> /// Creates a path translated by the supplied postion /// </summary> /// <param name="path">The path to translate.</param> /// <param name="scaleX">The amount to scale along the X axis.</param> /// <param name="scaleY">The amount to scale along the Y axis.</param> /// <returns>A <see cref="IPath"/> with a translate transform applied.</returns> public static IPath Scale(this IPath path, float scaleX, float scaleY) { return(path.Transform(Matrix3x2.CreateScale(scaleX, scaleY, RectangleF.Center(path.Bounds)))); }
/// <summary> /// Creates a path translated by the supplied postion /// </summary> /// <param name="path">The path to translate.</param> /// <param name="scale">The amount to scale along both the x and y axis.</param> /// <returns>A <see cref="IPath"/> with a translate transform applied.</returns> public static IPathCollection Scale(this IPathCollection path, float scale) { return(path.Transform(Matrix3x2.CreateScale(scale, RectangleF.Center(path.Bounds)))); }
internal void RenderBackgroundInternal( Graphics g, Rectangle rect, Color baseColor, Color borderColor, Color innerBorderColor, RoundStyle style, int roundWidth, float basePosition, bool drawBorder, bool drawGlass, LinearGradientMode mode) { if (drawBorder) { rect.Width--; rect.Height--; } using (LinearGradientBrush brush = new LinearGradientBrush( rect, Color.Transparent, Color.Transparent, mode)) { Color[] colors = new Color[4]; colors[0] = GetColor(baseColor, 0, 35, 24, 9); colors[1] = GetColor(baseColor, 0, 13, 8, 3); colors[2] = baseColor; colors[3] = GetColor(baseColor, 0, 68, 69, 54); ColorBlend blend = new ColorBlend(); blend.Positions = new float[] { 0.0f, basePosition, basePosition + 0.05f, 1.0f }; blend.Colors = colors; brush.InterpolationColors = blend; if (style != RoundStyle.None) { using (GraphicsPath path = GraphicsPathHelper.CreatePath(rect, roundWidth, style, false)) { g.FillPath(brush, path); } if (baseColor.A > 80) { Rectangle rectTop = rect; if (mode == LinearGradientMode.Vertical) { rectTop.Height = (int)(rectTop.Height * basePosition); } else { rectTop.Width = (int)(rect.Width * basePosition); } using (GraphicsPath pathTop = GraphicsPathHelper.CreatePath( rectTop, roundWidth, RoundStyle.Top, false)) { using (SolidBrush brushAlpha = new SolidBrush(Color.FromArgb(80, 255, 255, 255))) { g.FillPath(brushAlpha, pathTop); } } } if (drawGlass) { RectangleF glassRect = rect; if (mode == LinearGradientMode.Vertical) { glassRect.Y = rect.Y + rect.Height * basePosition; glassRect.Height = (rect.Height - rect.Height * basePosition) * 2; } else { glassRect.X = rect.X + rect.Width * basePosition; glassRect.Width = (rect.Width - rect.Width * basePosition) * 2; } ControlPaintEx.DrawGlass(g, glassRect, 170, 0); } if (drawBorder) { using (GraphicsPath path = GraphicsPathHelper.CreatePath(rect, roundWidth, style, false)) { using (Pen pen = new Pen(borderColor)) { g.DrawPath(pen, path); } } rect.Inflate(-1, -1); using (GraphicsPath path = GraphicsPathHelper.CreatePath(rect, roundWidth, style, false)) { using (Pen pen = new Pen(innerBorderColor)) { g.DrawPath(pen, path); } } } } else { g.FillRectangle(brush, rect); if (baseColor.A > 80) { Rectangle rectTop = rect; if (mode == LinearGradientMode.Vertical) { rectTop.Height = (int)(rectTop.Height * basePosition); } else { rectTop.Width = (int)(rect.Width * basePosition); } using (SolidBrush brushAlpha = new SolidBrush(Color.FromArgb(80, 255, 255, 255))) { g.FillRectangle(brushAlpha, rectTop); } } if (drawGlass) { RectangleF glassRect = rect; if (mode == LinearGradientMode.Vertical) { glassRect.Y = rect.Y + rect.Height * basePosition; glassRect.Height = (rect.Height - rect.Height * basePosition) * 2; } else { glassRect.X = rect.X + rect.Width * basePosition; glassRect.Width = (rect.Width - rect.Width * basePosition) * 2; } ControlPaintEx.DrawGlass(g, glassRect, 200, 0); } if (drawBorder) { using (Pen pen = new Pen(borderColor)) { g.DrawRectangle(pen, rect); } rect.Inflate(-1, -1); using (Pen pen = new Pen(innerBorderColor)) { g.DrawRectangle(pen, rect); } } } } }
/// <summary> /// The Control is being redrawn /// </summary> protected override void OnPaint(PaintEventArgs e) { Graphics gResult = e.Graphics; if (!_locked) { _locked = true; Graphics g = Graphics.FromImage(_backBuffer); g.Clear(Color.Transparent); // drawing color band (all in case it's disabled or a half of it) int positionY = (chkEnabled.Checked) ? _topHandle.Position : BAND_OFFSET_Y; int dy = (chkEnabled.Checked) ? _bottomHandle.Position - _topHandle.Position : Height - 2 * BAND_OFFSET_Y; Rectangle rect = new Rectangle(BAND_OFFSET_X, positionY, BAND_WIDTH, dy); if (dy > 0) { Brush brush; if (_colorFill1 != _colorFill2) { Color clr1 = chkEnabled.Checked ? _colorFill1 : Color.FromArgb(120, _colorFill1); brush = new LinearGradientBrush(rect, clr1, clr1, LinearGradientMode.Horizontal); } else { Color clr = chkEnabled.Checked ? _colorFill1 : Color.FromArgb(120, _colorFill1); brush = new SolidBrush(clr); } g.FillRectangle(brush, rect); } rect = new Rectangle(BAND_OFFSET_X, BAND_OFFSET_Y, BAND_WIDTH, Height - 2 * BAND_OFFSET_Y); Pen pen = new Pen(_colorOutline); g.DrawRectangle(pen, rect); // ------------------------------------------------- // drawing the scale // ------------------------------------------------- float step = (Height - BAND_OFFSET_Y * 2) / 9.0f; g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit; var color = UseDynamicVisibility ? Color.Black : Color.Gray; var textBrush = new SolidBrush(color); for (int i = 0; i < 10; i++) { float y = BAND_OFFSET_Y + step * i; g.DrawLine(pen, (float)BAND_OFFSET_X - 5, y, BAND_OFFSET_X, y); g.DrawLine(pen, (float)(BAND_OFFSET_X + BAND_WIDTH), y, BAND_OFFSET_X + BAND_WIDTH + 5, y); string s = "1×e" + (9 - i); SizeF size = g.MeasureString(s, _font); size.Width += 2; PointF pos = new PointF(BAND_OFFSET_X - 5.0f - size.Width, y - size.Height / 2.0f); RectangleF r = new RectangleF(pos, size); g.DrawString(s, _font, textBrush, r); } if (chkEnabled.Checked) { if (_topHandle.Selected) { DrawHandle(g, _bottomHandle); DrawHandle(g, _topHandle); } else { DrawHandle(g, _topHandle); DrawHandle(g, _bottomHandle); } } // drawing current scale if (_currentScale != -1.0) { int position = Scale2Position(_currentScale); Pen p = new Pen(Color.Red); //_colorSelection g.DrawRectangle(p, BAND_OFFSET_X - 3, position - 1, BAND_WIDTH + 6, 2); g.FillRectangle(new SolidBrush(Color.Red), BAND_OFFSET_X - 3, position - 1, BAND_WIDTH + 6, 2); } g.Flush(); _locked = false; } gResult.DrawImage(_backBuffer, 0, 0); if (_draggingIsPerformed) { gResult.Flush(FlushIntention.Sync); } }
// Cohen-Sutherland algorithm public static Line2D ClipToRectangle(Line2D line, RectangleF rect, out bool intersects) { int flags1 = MapSet.GetCSFieldBits(line.v1, ref rect); int flags2 = MapSet.GetCSFieldBits(line.v2, ref rect); intersects = false; Line2D result = line; while (true) { if (flags1 == 0 && flags2 == 0) { // Line is fully inside the box intersects = true; return(result); } if ((flags1 & flags2) != 0) { // Both points are in the same outer area intersects = false; return(new Line2D()); } float x, y; int outFlags = flags1 != 0 ? flags1 : flags2; if ((outFlags & 0x1) > 0) // Top { x = result.v1.x + (result.v2.x - result.v1.x) * (rect.Top - result.v1.y) / (result.v2.y - result.v1.y); y = rect.Top; } else if ((outFlags & 0x2) > 0) // Bottom { x = result.v1.x + (result.v2.x - result.v1.x) * (rect.Bottom - result.v1.y) / (result.v2.y - result.v1.y); y = rect.Bottom; } else if ((outFlags & 0x4) > 0) // Left { y = result.v1.y + (result.v2.y - result.v1.y) * (rect.Left - result.v1.x) / (result.v2.x - result.v1.x); x = rect.Left; } else if ((outFlags & 0x8) > 0) // Right { y = result.v1.y + (result.v2.y - result.v1.y) * (rect.Right - result.v1.x) / (result.v2.x - result.v1.x); x = rect.Right; } else { intersects = true; return(result); } if (outFlags == flags1) { result.v1 = new Vector2D(x, y); flags1 = MapSet.GetCSFieldBits(result.v1, ref rect); } else { result.v2 = new Vector2D(x, y); flags2 = MapSet.GetCSFieldBits(result.v2, ref rect); } } }
public HeaderRectangleActual() { Syncfusion.Windows.Forms.Diagram.Rectangle MainRect = new Syncfusion.Windows.Forms.Diagram.Rectangle(0, 0, 200, 150); MainRect.FillStyle.Color = Color.White; MainRect.LineStyle.LineColor = Color.Black; Syncfusion.Windows.Forms.Diagram.Rectangle HeadContent = new Syncfusion.Windows.Forms.Diagram.Rectangle(MainRect.BoundingRectangle.Width / 2 - 50, -10, 100, 20); HeadContent.FillStyle.Color = Color.LightYellow; Syncfusion.Windows.Forms.Diagram.Label lbl = new Syncfusion.Windows.Forms.Diagram.Label(); lbl.Text = "Actual"; lbl.SizeToNode = true; lbl.Position = Position.Center; lbl.FontStyle.Size = 12; lbl.FontStyle.Bold = true; HeadContent.Labels.Add(lbl); this.AppendChild(MainRect); this.AppendChild(HeadContent); Syncfusion.Windows.Forms.Diagram.Ellipse ellipse; ellipse = new Syncfusion.Windows.Forms.Diagram.Ellipse(10, 40, 15, 15); ellipse.FillStyle.Color = Color.Green; RectangleF rect = new RectangleF(30, 35, 150, 25); TextNode txtContent = new TextNode("=OnSchedule", rect); txtContent.BackgroundStyle.Color = Color.Transparent; txtContent.LineStyle.LineWidth = 0; txtContent.FontStyle.Size = 10; txtContent.ReadOnly = true; txtContent.HorizontalAlignment = StringAlignment.Near; txtContent.VerticalAlignment = StringAlignment.Center; this.AppendChild(txtContent); this.AppendChild(ellipse); ellipse = new Syncfusion.Windows.Forms.Diagram.Ellipse(10, 70, 15, 15); ellipse.FillStyle.Color = Color.Yellow; rect = new RectangleF(30, 65, 150, 25); txtContent = new TextNode("=Behind Schedule", rect); txtContent.BackgroundStyle.Color = Color.Transparent; txtContent.LineStyle.LineWidth = 0; txtContent.FontStyle.Size = 10; txtContent.ReadOnly = true; txtContent.HorizontalAlignment = StringAlignment.Near; txtContent.VerticalAlignment = StringAlignment.Center; this.AppendChild(txtContent); this.AppendChild(ellipse); ellipse = new Syncfusion.Windows.Forms.Diagram.Ellipse(10, 100, 15, 15); ellipse.FillStyle.Color = Color.Red; rect = new RectangleF(30, 95, 150, 25); txtContent = new TextNode("=Critically Behind", rect); txtContent.BackgroundStyle.Color = Color.Transparent; txtContent.LineStyle.LineWidth = 0; txtContent.FontStyle.Size = 10; txtContent.ReadOnly = true; txtContent.HorizontalAlignment = StringAlignment.Near; txtContent.VerticalAlignment = StringAlignment.Center; this.AppendChild(txtContent); this.AppendChild(ellipse); ellipse = new Syncfusion.Windows.Forms.Diagram.Ellipse(10, 130, 15, 15); ellipse.FillStyle.Color = Color.Blue; rect = new RectangleF(30, 125, 120, 25); txtContent = new TextNode("=Complete", rect); txtContent.BackgroundStyle.Color = Color.Transparent; txtContent.LineStyle.LineWidth = 0; txtContent.FontStyle.Size = 10; txtContent.ReadOnly = true; txtContent.HorizontalAlignment = StringAlignment.Near; txtContent.VerticalAlignment = StringAlignment.Center; this.AppendChild(txtContent); this.AppendChild(ellipse); this.EditStyle.AllowSelect = false; }