Example #1
0
        public PixelOffsetSection()
        {
            var layout = new DynamicLayout();

            var drawable = new Drawable {
                Size = canvasSize
            };

            drawable.Paint += (sender, pe) => {
                pe.Graphics.FillRectangle(Brushes.Black(), pe.ClipRectangle);
                pe.Graphics.PixelOffsetMode = PixelOffsetMode.None;
                Draw(pe.Graphics);
            };
            layout.AddRow(new Label {
                Text = "None (Default)"
            }, drawable);

            drawable = new Drawable {
                Size = canvasSize
            };
            drawable.Paint += (sender, pe) => {
                pe.Graphics.FillRectangle(Brushes.Black(), pe.ClipRectangle);
                pe.Graphics.PixelOffsetMode = PixelOffsetMode.Half;
                Draw(pe.Graphics);
            };
            layout.AddRow(new Label {
                Text = "Half"
            }, drawable);
            layout.Add(null);

            Content = layout;
        }
Example #2
0
        Control FillLinePath()
        {
            var control = new Drawable {
                Size = new Size(550, 200)
            };

            control.Paint += (sender, e) => {
                e.Graphics.FillPath(Brushes.Black(), path);
            };

            return(control);
        }
Example #3
0
        public void Clear(SolidBrush brush)
        {
            var rect = this.ClipBounds;

            if (drawingVisual != null)
            {
                // bitmap
                Control.Close();
                var newbmp = new swmi.RenderTargetBitmap((int)bounds.Width, (int)bounds.Height, 96, 96, swm.PixelFormats.Pbgra32);
                newbmp.Render(visual);

                swm.Geometry maskgeometry;
                if (clipPath != null)
                {
                    maskgeometry = clipPath.ToWpf();
                }
                else
                {
                    maskgeometry = new swm.RectangleGeometry(rect.ToWpf());
                }
                var boundsgeometry = new swm.RectangleGeometry(this.bounds);
                maskgeometry = swm.Geometry.Combine(boundsgeometry, maskgeometry, swm.GeometryCombineMode.Exclude, null);
                var dr = new swm.GeometryDrawing(swm.Brushes.Black, null, maskgeometry);
                var db = new swm.DrawingBrush(dr);
                //db.Transform = new swm.TranslateTransform (0.5, 0.5);

                Control = drawingVisual.RenderOpen();
                PushGuideLines(bounds.X, bounds.Y, bounds.Width, bounds.Height);
                Control.PushOpacityMask(db);
                Control.DrawImage(newbmp, this.bounds);
                Control.Pop();

                TransformStack.PushAll();
                ApplyClip();
            }
            else
            {
                // drawable
                if (brush == null || brush.Color.A < 1.0f)
                {
                    Widget.FillRectangle(Brushes.Black(Generator), rect);
                }
            }
            if (brush != null)
            {
                Widget.FillRectangle(brush, rect);
            }
        }
Example #4
0
        public TransformSection()
        {
            image = TestIcons.TestIcon();
            font  = Fonts.Sans(10);

            var layout = new DynamicLayout();

            var drawable = new Drawable {
                Size = canvasSize
            };

            drawable.Paint += (sender, pe) => {
                pe.Graphics.FillRectangle(Brushes.Black(Generator), pe.ClipRectangle);
                MatrixTests(pe.Graphics);
            };
            layout.AddRow(new Label {
                Text = "Matrix"
            }, drawable);

            drawable = new Drawable {
                Size = canvasSize
            };
            drawable.Paint += (sender, pe) => {
                pe.Graphics.FillRectangle(Brushes.Black(Generator), pe.ClipRectangle);
                DirectTests(pe.Graphics);
            };
            layout.AddRow(new Label {
                Text = "Direct"
            }, drawable);
            layout.Add(null);

            var m = Matrix.Create();

            m.Scale(100, 100);
            var m2 = m.Clone();

            m2.Translate(10, 10);

            if (m == m2)
            {
                throw new Exception("Grr!");
            }

            Content = layout;
        }
Example #5
0
        Control LargeCanvas()
        {
            var control = new Drawable
            {
                Size            = new Size(1000, 1000),
                BackgroundColor = Colors.Blue
            };
            var image = TestIcons.TestImage;

            control.Paint += delegate(object sender, PaintEventArgs pe)
            {
                pe.Graphics.FillRectangle(Brushes.Black(), new Rectangle(150, 150, 100, 100));
                var whitePen = Pens.White();
                var inc      = 400;
                for (int i = 0; i <= control.Size.Width / inc; i++)
                {
                    var pos = i * inc;
                    pe.Graphics.DrawLine(whitePen, new Point(pos, 0), new Point(pos + control.Size.Width, control.Size.Height));
                    pe.Graphics.DrawLine(whitePen, new Point(pos, 0), new Point(pos - control.Size.Width, control.Size.Height));
                }
                var lpos = 100;
                pe.Graphics.DrawLine(whitePen, new Point(0, lpos), new Point(control.Size.Width, lpos));
                pe.Graphics.DrawLine(whitePen, new Point(lpos, 0), new Point(lpos, control.Size.Height));
                pe.Graphics.DrawImage(image, 100, 10);
                pe.Graphics.DrawImage(image, 250, 10, 80, 20);
            };
            LogEvents(control);

            var layout = new PixelLayout();

            layout.Add(control, 25, 25);
            return(new Scrollable
            {
                Size = new Size(250, 250),
                Content = layout
            });
        }
Example #6
0
            public Box(Size canvasSize, bool useTexturesAndGradients, DirectDrawingRenderer renderer)
            {
                this.renderer = renderer;
                var size     = new SizeF(random.Next(50) + 50, random.Next(50) + 50);
                var location = new PointF(random.Next(canvasSize.Width - (int)size.Width), random.Next(canvasSize.Height - (int)size.Height));

                position  = new RectangleF(location, size);
                increment = new SizeF(random.Next(3) + 1, random.Next(3) + 1);
                if (random.Next(2) == 1)
                {
                    increment.Width = -increment.Width;
                }
                if (random.Next(2) == 1)
                {
                    increment.Height = -increment.Height;
                }

                angle    = random.Next(360);
                rotation = (random.Next(20) - 10f) / 4f;

                var rect = new RectangleF(size);

                color = GetRandomColor(random);
                var colorPen   = new Pen(color, generator: renderer.Generator);
                var blackPen   = Pens.Black(renderer.Generator);
                var blackBrush = Brushes.Black(renderer.Generator);

                switch (random.Next(useTexturesAndGradients ? 4 : 2))
                {
                case 0:
                    draw  = g => g.DrawRectangle(colorPen, rect);
                    erase = g => g.DrawRectangle(blackPen, rect);
                    break;

                case 1:
                    draw  = g => g.DrawEllipse(colorPen, rect);
                    erase = g => g.DrawEllipse(blackPen, rect);
                    break;

                case 2:
                    switch (random.Next(2))
                    {
                    case 0:
                        fillBrush = new LinearGradientBrush(GetRandomColor(random), GetRandomColor(random), PointF.Empty, new PointF(size.Width, size.Height), renderer.Generator);
                        break;

                    case 1:
                        fillBrush = new TextureBrush(renderer.texture, 1f, renderer.Generator)
                        {
                            Transform = Matrix.FromScale(size / 80, renderer.Generator)
                        };
                        break;
                    }
                    draw  = g => g.FillEllipse(fillBrush, rect);
                    erase = g => g.FillEllipse(blackBrush, rect);
                    break;

                case 3:
                    switch (random.Next(2))
                    {
                    case 0:
                        fillBrush = new LinearGradientBrush(GetRandomColor(random), GetRandomColor(random), PointF.Empty, new PointF(size.Width, size.Height), renderer.Generator);
                        break;

                    case 1:
                        fillBrush = new TextureBrush(renderer.texture, 1f, renderer.Generator)
                        {
                            Transform = Matrix.FromScale(size / 80, renderer.Generator)
                        };
                        break;
                    }
                    draw  = g => g.FillRectangle(fillBrush, rect);
                    erase = g => g.FillRectangle(blackBrush, rect);
                    break;
                }
            }