C# - CustomLineCap laten vullen (Inkleuren)

[l.degroot01]

Ik ben bezig een UML editor te maken, maar kom er niet uit om een CustomLineCap (een ruitje) te laten inkleuren. Zie hieronder een screenshotje.



Ik gebruik:

code:

CustomLineCap diamond = new CustomLineCap(null, hPath);

Waarbij de eerste parameter het fillpath is en de 2e het Strokepath.
Volgens MSDN mag ik ze niet tegelijk gebruiken dus heb ik hPath verplaatst naar FillPath, maar dan krijg ik een berg fouten.

Een andere optie zou zijn

code:

myPen.EndCap = LineCap.DiamondAnchor

. Echter tekent hij dan met dezelfde grootte als waar de pen al op staat ingesteld zodat je bijna geen gevuld ruitje kan zien.

Hoe krijg ik dit ruitje nou gevuld zonder hem groter of kleiner te maken?

code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;

namespace UMLeditor
{
    class Compositie : UmlComponent
    {
        private int xBegin, yBegin, xEind, yEind;
        private Font lettertype = new Font("verdana", 12);

        public Compositie(int xBegin, int yBegin, int xEind, int yEind)
        {
            this.xBegin = xBegin;
            this.yBegin = yBegin;
            this.xEind = xEind;
            this.yEind = yEind;
        }

        public override void Teken(Graphics g)
        {
            SolidBrush myBrush = new SolidBrush(Color.Black);
            Pen myPen = new Pen(myBrush);

            // Object aanmaken van de klasse GraphicsPath, om een pad vast te leggen voor de CustomLineCap.
            GraphicsPath hPath = new GraphicsPath();

            // Aanmaken van de coördinaten van het pad, voor de CustomLineCap.
            hPath.AddLine(new Point(0, 0), new Point(10, 10));
            hPath.AddLine(new Point(10, 10), new Point(0, 20));
            hPath.AddLine(new Point(0, 20), new Point(-10, 10));
            hPath.AddLine(new Point(-10, 10), new Point(0, 0));

            CustomLineCap diamond = new CustomLineCap(null, hPath);

            myPen.CustomEndCap = diamond;
            g.DrawLine(myPen, xBegin, yBegin, xEind, yEind); // tekent lijn
            
        }
    }
}

[Verwijderd]

volgens mij kun je daar gewoon g.FillPath(Brush, Path); voor gebruiken om dat te bereiken

[l.degroot01]

Verwijderd schreef op woensdag 28 september 2011 @ 13:30:
volgens mij kun je daar gewoon g.FillPath(Brush, Path); voor gebruiken om dat te bereiken

Nee, dat heb ik al geprobeerd, maar dan vult hij alleen vaste coördinaten. dus letterlijk de volgende coördinaten:

code:

            // Object aanmaken van de klasse GraphicsPath, om een pad vast te leggen voor de CustomLineCap.
            GraphicsPath hPath = new GraphicsPath();

            // Aanmaken van de coördinaten van het pad, voor de CustomLineCap.
            hPath.AddLine(new Point(0, 0), new Point(10, 10));
            hPath.AddLine(new Point(10, 10), new Point(0, 20));
            hPath.AddLine(new Point(0, 20), new Point(-10, 10));
            hPath.AddLine(new Point(-10, 10), new Point(0, 0));

Ik moet echt de LineCap vullen zodat hij dynamisch meeschuift naar waar je de lijn ook tekent.

[Verwijderd]

Een klein voorbeeld zoals het voor mij werkt.
Maar is dit wel zoals je het bedoelde?

C#:

class Compositie
{
    private int x, y;
    private Font lettertype = new Font("verdana", 12);

    public Compositie(int x, int y)
    {
       this.x = x;
       this.y = y;
    }

    public void Teken(Graphics g)
    {
        SolidBrush myBrush = new SolidBrush(Color.Black);
        GraphicsPath hPath = new GraphicsPath();

        // Aanmaken van de coördinaten van het pad, voor de CustomLineCap.
        hPath.StartFigure();
        hPath.AddLine(new Point(x, y), new Point(x + 10, y + 10));
        hPath.AddLine(new Point(x + 10, y + 10), new Point(x, y + 20));
        hPath.AddLine(new Point(x, y + 20), new Point(x - 10, y + 10));
        hPath.AddLine(new Point(x - 10, y + 10), new Point(x, y));
        hPath.CloseFigure();

        g.FillPath(myBrush, hPath);
    }
}

[ Voor 4% gewijzigd door Verwijderd op 28-09-2011 13:56 ]

[l.degroot01]

Ongeveer wel, maar hoe voeg je dat gevulde ruitje nu toe aan een lijn. als EndCap of CustomLineCap of iets dergelijks.

[Verwijderd]

Hmm ik had even de documentatie op MSDN doorgezocht, er is wel een constructor met een FillPath.
Maar het stomme is als je die gebruikt krijg je een 'Not Implemented' exception, dus ze moeten deze nog toevoegen als ze dit gaan doen uiteindelijk is een andere vraag.

Ik denk dat het de moeilijkere keuze wordt en uiteindelijk zelf maar een klasse of method schrijven die het tekenen zelf afhandelt.

[SaphuA]

.

[ Voor 97% gewijzigd door SaphuA op 31-01-2022 16:01 ]

[Kwastie]

Waarom gebruik je niet fillpolygon?

Windesheim opdracht toevallig?

[l.degroot01]

Kwastie schreef op woensdag 28 september 2011 @ 16:32:
Waarom gebruik je niet fillpolygon?

Windesheim opdracht toevallig?

Ja Windesheim opdracht

Zal morgen ff kijken naar die fillPolygon

[Grijze Vos]

SaphuA schreef op woensdag 28 september 2011 @ 16:32:
Is het geen optie om in WPF te werken? Scheelt je een HOOP gedoe uiteindelijk.

Is het geen optie om de VS DSL Tools te gebruiken? Die zijn er voor gemaakt..

[jip_86]

Kwastie schreef op woensdag 28 september 2011 @ 16:32:
Waarom gebruik je niet fillpolygon?

Windesheim opdracht toevallig?

Hehe, komt heel bekend voor

Ik weet zo niet uit mijn hoofd hoe we dat gedaan hebben. Volgens mij door wat extra lijntjes te trekken

[l.degroot01]

Hieronder de geüpdate code, maar het werkt nog niet.
Nu tekent hij idd aan het eind van de lijn een gevuld ruitje, maar alleen als je de lijn naar beneden trekt.
Andere richtingen draait het ruitje niet mee, omdat het geen endcap is.

Sommigen zeiden gebruik die en die tool, maar dat is niet toegestaan.

FillPolygon, gaf overigens hetzelfde resultaat na het tekenen van de daadwerkelijke Polygon.

C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;

namespace UMLeditor
{
    class Compositie : UmlComponent
    {
        private int xBegin, yBegin, xEind, yEind;
        private Font lettertype = new Font("verdana", 12);

        public Compositie(int xBegin, int yBegin, int xEind, int yEind)
        {
            this.xBegin = xBegin;
            this.yBegin = yBegin;
            this.xEind = xEind;
            this.yEind = yEind;
        }

        public override void Teken(Graphics g)
        {
            SolidBrush myBrush = new SolidBrush(Color.Black);
            Pen myPen = new Pen(myBrush);

            // Object aanmaken van de klasse GraphicsPath, om een pad vast te leggen voor de CustomLineCap.
            GraphicsPath hPath = new GraphicsPath();
            GraphicsPath fillPath = new GraphicsPath();

            // Aanmaken van de coördinaten van het pad, voor de CustomLineCap.
            //hPath.AddLine(new Point(0, 0), new Point(10, 10));
            //hPath.AddLine(new Point(10, 10), new Point(0, 20));
            //hPath.AddLine(new Point(0, 20), new Point(-10, 10));
            //hPath.AddLine(new Point(-10, 10), new Point(0, 0));

            // Aanmaken van de coördinaten voor het vullen, voor de CustomLineCap.
            fillPath.AddLine(new Point(xEind, yEind), new Point(xEind + 10, yEind + 10));
            fillPath.AddLine(new Point(xEind + 10, yEind + 10), new Point(xEind, yEind + 20));
            fillPath.AddLine(new Point(xEind, yEind + 20), new Point(xEind - 10, yEind + 10));
            fillPath.AddLine(new Point(xEind - 10, yEind + 10), new Point(xEind, yEind));

            //CustomLineCap diamond = new CustomLineCap(null, hPath, LineCap.DiamondAnchor);

            //myPen.CustomEndCap = diamond;
            g.DrawLine(myPen, xBegin, yBegin, xEind, yEind); // tekent lijn
            g.FillPath(myBrush, fillPath);


        }
    }
}

[l.degroot01]

Ik heb het inmiddels opgelost met een beetje wiskunde

C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;

namespace UMLeditor
{
    class Compositie : UmlComponent
    {
        private int xBegin, yBegin, xEind, yEind;
        private Font lettertype = new Font("verdana", 12);

        public Compositie(int xBegin, int yBegin, int xEind, int yEind)
        {
            this.xBegin = xBegin;
            this.yBegin = yBegin;
            this.xEind = xEind;
            this.yEind = yEind;
        }

        public override void Teken(Graphics g)
        {
            Pen p = new Pen(Color.Black, 1);
            Pen p2 = new Pen(p.Color, 12);

            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

            p2.EndCap = System.Drawing.Drawing2D.LineCap.DiamondAnchor;

            double angle = Math.Atan2(yEind - yBegin, xEind - xBegin);

            g.DrawLine(p, xBegin, yBegin, xEind, yEind);
            g.DrawLine(p2, xEind, yEind, xEind + (float)(Math.Cos(angle)), yEind + (float)(Math.Sin(angle)));
        }
    }
}

Thanx allemaal voor jullie hulp

[Verwijderd]

Dat heb je netjes opgelost, code ziet er ook mooi compact uit!

[jip_86]

Grappig, ik heb mijn UML app er nog even bijgezocht. Je was warm alleen de verkeerde constructor gebruikt.

C#:

GraphicsPath hPath = new GraphicsPath();
hPath.AddPolygon(new Point[4] { new Point(0, 0), new Point(5, -5), new Point(0, -10), new Point(-5, -5) });
CompositionCap = new CustomLineCap(hPath, null, LineCap.Flat, 20);

Het CustomLineCap object kun je dan op de CustomEndCap property van je Pen zetten.