// Az Alakzat ősbe (9.7) kerül két új tag:
public virtual bool VanFogo { get { return true; } }

public virtual Alakzat Masol()
{
    return (Alakzat)this.MemberwiseClone();   // a Point és a Color érték típus: a KetPontos másolata önálló
}

// új alakzat: szabadkézi vonal (pontlista)
public class Szabadkezi : Alakzat
{
    public List<Point> Pontok = new List<Point>();

    public override bool VanFogo { get { return false; } }

    public override Point Fogo { get { return Pontok.Count > 0 ? Pontok[Pontok.Count - 1] : Point.Empty; } }

    public override void FogoMozgat(Point uj) { }   // a szabadkézi vonalnak nincs átméretező fogója

    public override Alakzat Masol()
    {
        Szabadkezi m = (Szabadkezi)this.MemberwiseClone();
        m.Pontok = new List<Point>(this.Pontok);   // mély másolat: a lista nem lehet közös
        return m;
    }

    public override Rectangle Hatar()
    {
        if (Pontok.Count == 0) { return Rectangle.Empty; }

        int minX = Pontok.Min(p => p.X), maxX = Pontok.Max(p => p.X), minY = Pontok.Min(p => p.Y), maxY = Pontok.Max(p => p.Y);
        int m = (int)Math.Ceiling(Vastagsag / 2) + 3;

        return new Rectangle(minX - m, minY - m, maxX - minX + 2 * m, maxY - minY + 2 * m);
    }

    public override void Rajzol(Graphics g)
    {
        using (Pen toll = UjToll())
        using (Brush b = new SolidBrush(Szin))
        {
            toll.StartCap = toll.EndCap = LineCap.Round;
            toll.LineJoin = LineJoin.Round;

            if (Pontok.Count == 1) { g.FillEllipse(b, Pontok[0].X - Vastagsag / 2, Pontok[0].Y - Vastagsag / 2, Vastagsag, Vastagsag); }
            else if (Pontok.Count > 1) { g.DrawLines(toll, Pontok.ToArray()); }
        }
    }

    public override bool Talal(Point p)
    {
        double tures = Math.Max(4, Vastagsag / 2 + 3);

        if (Pontok.Count == 1) { return Geometria.TavolsagSzakasztol(p, Pontok[0], Pontok[0]) <= tures; }

        for (int i = 1; i < Pontok.Count; i++)
        {
            if (Geometria.TavolsagSzakasztol(p, Pontok[i - 1], Pontok[i]) <= tures) { return true; }
        }

        return false;
    }

    public override void Mozgat(int dx, int dy)
    {
        for (int i = 0; i < Pontok.Count; i++) { Pontok[i] = new Point(Pontok[i].X + dx, Pontok[i].Y + dy); }
    }
}

private enum Allapot { Nincs, Rajzol, Letrehoz, Mozgat, Atmeretez }

private List<Alakzat> alakzatok = new List<Alakzat>();
private Stack<List<Alakzat>> visszavon = new Stack<List<Alakzat>>();
private Stack<List<Alakzat>> ujra = new Stack<List<Alakzat>>();
private List<Alakzat> mentettAllapot = null;   // az Esc-hez: a művelet kezdete előtti állapot

private Allapot allapot = Allapot.Nincs;
private Alakzat aktiv = null;
private Point elozo;
private Color szin = Color.SteelBlue;
private Bitmap hatter = null;
private string fajl = "";
private bool modosult = false;
private bool beallit = false;
private const int FogoMeret = 8;

// ---- visszavonás pillanatképekkel ----

private List<Alakzat> Pillanatkep()
{
    return alakzatok.Select(a => a.Masol()).ToList();   // mély másolat
}

private void Mentes()   // a módosítás ELŐTT hívjuk
{
    visszavon.Push(Pillanatkep());
    ujra.Clear();
    Modosult();
}

private void Visszaallit(List<Alakzat> allapotLista)
{
    alakzatok = allapotLista;
    Allapotsor();
    rp.Invalidate();
}

private void miVisszavon_Click(object sender, EventArgs e)
{
    if (visszavon.Count == 0 || allapot != Allapot.Nincs) { return; }

    ujra.Push(Pillanatkep());
    Visszaallit(visszavon.Pop());
}

private void miUjra_Click(object sender, EventArgs e)
{
    if (ujra.Count == 0 || allapot != Allapot.Nincs) { return; }

    visszavon.Push(Pillanatkep());
    Visszaallit(ujra.Pop());
}

// ---- eszközök és egér ----

private Alakzat Kijelolt() { return alakzatok.Find(x => x.Kijelolt); }

private void Kijeloles(Alakzat a)
{
    foreach (Alakzat x in alakzatok) { x.Kijelolt = x == a; }

    if (a != null)
    {
        beallit = true;
        nudVastag.Value = (decimal)Math.Max(1, Math.Min(30, a.Vastagsag));
        chkKitolt.Checked = a.Kitoltott;
        beallit = false;
    }

    Allapotsor();
    rp.Invalidate();
}

private Rectangle FogoTeglalap(Alakzat a)
{
    Point f = a.Fogo;
    return new Rectangle(f.X - FogoMeret / 2, f.Y - FogoMeret / 2, FogoMeret, FogoMeret);
}

private Alakzat TalalatKeres(Point p)
{
    for (int i = alakzatok.Count - 1; i >= 0; i--) { if (alakzatok[i].Talal(p)) { return alakzatok[i]; } }

    return null;
}

private void Frissit(Rectangle regi, Alakzat a)
{
    Rectangle t = Rectangle.Union(regi, a.Hatar());
    t.Inflate(FogoMeret + 2, FogoMeret + 2);
    rp.Invalidate(t);
}

private Alakzat UjAlakzat(Point p)
{
    Alakzat a;

    if (rbSzabad.Checked) { Szabadkezi sz = new Szabadkezi(); sz.Pontok.Add(p); a = sz; }
    else
    {
        KetPontos kp = rbTeglalap.Checked ? (KetPontos)new Teglalap() : rbEllipszis.Checked ? (KetPontos)new Ellipszis() : new Vonal();
        kp.A = kp.B = p;
        a = kp;
    }

    a.Szin = szin;
    a.Vastagsag = (float)nudVastag.Value;
    a.Kitoltott = chkKitolt.Checked;

    return a;
}

private void rp_MouseDown(object sender, MouseEventArgs e)
{
    if (e.Button != MouseButtons.Left) { return; }

    elozo = e.Location;
    mentettAllapot = Pillanatkep();

    if (!rbKijelol.Checked)
    {
        Mentes();
        aktiv = UjAlakzat(e.Location);
        alakzatok.Add(aktiv);
        Kijeloles(null);
        allapot = rbSzabad.Checked ? Allapot.Rajzol : Allapot.Letrehoz;
        return;
    }

    Alakzat kij = Kijelolt();

    if (kij != null && kij.VanFogo && FogoTeglalap(kij).Contains(e.Location))
    {
        Mentes();
        aktiv = kij;
        allapot = Allapot.Atmeretez;
        return;
    }

    Alakzat talalat = TalalatKeres(e.Location);

    Kijeloles(talalat);

    if (talalat != null)
    {
        Mentes();
        aktiv = talalat;
        allapot = Allapot.Mozgat;
        rp.Cursor = Cursors.SizeAll;
    }
}

private void rp_MouseMove(object sender, MouseEventArgs e)
{
    tsslPoz.Text = e.X + ", " + e.Y;

    if (aktiv == null || allapot == Allapot.Nincs) { return; }

    Rectangle regi = aktiv.Hatar();

    switch (allapot)
    {
        case Allapot.Rajzol:
            Szabadkezi sz = (Szabadkezi)aktiv;
            Point utolso = sz.Pontok[sz.Pontok.Count - 1];

            if (Math.Abs(e.X - utolso.X) + Math.Abs(e.Y - utolso.Y) >= 2) { sz.Pontok.Add(e.Location); }
            break;

        case Allapot.Letrehoz:
        case Allapot.Atmeretez:
            aktiv.FogoMozgat(e.Location);
            break;

        case Allapot.Mozgat:
            aktiv.Mozgat(e.X - elozo.X, e.Y - elozo.Y);
            elozo = e.Location;
            break;
    }

    Frissit(regi, aktiv);
}

private void rp_MouseUp(object sender, MouseEventArgs e)
{
    if (allapot == Allapot.Letrehoz && aktiv is KetPontos)
    {
        KetPontos kp = (KetPontos)aktiv;

        if (Math.Abs(kp.A.X - kp.B.X) < 3 && Math.Abs(kp.A.Y - kp.B.Y) < 3)
        {
            alakzatok.Remove(aktiv);   // egyetlen kattintás: nincs alakzat
            visszavon.Pop();           // a felesleges pillanatkép törlése
        }
    }

    Veg();
}

private void rp_MouseCaptureChanged(object sender, EventArgs e)
{
    if (allapot != Allapot.Nincs) { Megszakit(); }
}

private void Veg()
{
    allapot = Allapot.Nincs;
    aktiv = null;
    mentettAllapot = null;
    rp.Cursor = Cursors.Cross;
    Allapotsor();
    rp.Invalidate();
}

private void Megszakit()   // Esc: a művelet kezdete előtti állapot vissza
{
    if (mentettAllapot != null)
    {
        alakzatok = mentettAllapot;

        if (visszavon.Count > 0) { visszavon.Pop(); }   // a művelet pillanatképe nem kell
    }

    Veg();
}

protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{
    if (keyData == Keys.Escape && allapot != Allapot.Nincs) { Megszakit(); return true; }
    if (keyData == Keys.Delete && allapot == Allapot.Nincs) { btnTorol.PerformClick(); return true; }

    Alakzat kij = Kijelolt();

    if (kij != null && allapot == Allapot.Nincs && (keyData == Keys.Left || keyData == Keys.Right || keyData == Keys.Up || keyData == Keys.Down))
    {
        Mentes();
        Rectangle regi = kij.Hatar();

        kij.Mozgat(keyData == Keys.Left ? -5 : keyData == Keys.Right ? 5 : 0, keyData == Keys.Up ? -5 : keyData == Keys.Down ? 5 : 0);
        Frissit(regi, kij);
        return true;
    }

    return base.ProcessCmdKey(ref msg, keyData);   // a Ctrl+Z / Ctrl+Y a menüpontok gyorsbillentyűi
}

// ---- tulajdonságok, z-sorrend, törlés ----

private void Tulajdonsag_Valtozott(object sender, EventArgs e)
{
    Alakzat a = Kijelolt();

    if (beallit || a == null) { return; }

    Mentes();
    a.Vastagsag = (float)nudVastag.Value;
    a.Kitoltott = chkKitolt.Checked;
    a.Szin = szin;
    rp.Invalidate();
}

private void btnTorol_Click(object sender, EventArgs e)
{
    Alakzat a = Kijelolt();

    if (a != null) { Mentes(); alakzatok.Remove(a); Allapotsor(); rp.Invalidate(); }
}

private void ZSorrend(Action<Alakzat> muvelet)
{
    Alakzat a = Kijelolt();

    if (a != null) { Mentes(); muvelet(a); rp.Invalidate(); }
}

private void btnElre_Click(object sender, EventArgs e) { ZSorrend(a => { alakzatok.Remove(a); alakzatok.Add(a); }); }
private void btnHatra_Click(object sender, EventArgs e) { ZSorrend(a => { alakzatok.Remove(a); alakzatok.Insert(0, a); }); }
private void btnFel_Click(object sender, EventArgs e) { ZSorrend(a => { int i = alakzatok.IndexOf(a); if (i < alakzatok.Count - 1) { alakzatok.RemoveAt(i); alakzatok.Insert(i + 1, a); } }); }
private void btnLe_Click(object sender, EventArgs e) { ZSorrend(a => { int i = alakzatok.IndexOf(a); if (i > 0) { alakzatok.RemoveAt(i); alakzatok.Insert(i - 1, a); } }); }

private void miMindentTorol_Click(object sender, EventArgs e)
{
    if (alakzatok.Count > 0 && MessageBox.Show(this, "Minden alakzat törlődik. (A visszavonás visszaállítja.) Folytatod?", "Mindent töröl", MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
    {
        Mentes();
        alakzatok = new List<Alakzat>();
        Allapotsor();
        rp.Invalidate();
    }
}

// ---- rajzolás ----

private Size Illeszt(Size forras, Size doboz)
{
    double arany = Math.Min((double)doboz.Width / forras.Width, (double)doboz.Height / forras.Height);

    return new Size(Math.Max(1, (int)Math.Round(forras.Width * arany)), Math.Max(1, (int)Math.Round(forras.Height * arany)));
}

private void KepetRajzol(Graphics g, Size meret, bool kijeloles, Rectangle klip)
{
    g.SmoothingMode = SmoothingMode.AntiAlias;
    g.Clear(Color.White);

    if (hatter != null)
    {
        Size m = Illeszt(hatter.Size, meret);

        g.InterpolationMode = InterpolationMode.HighQualityBilinear;
        g.DrawImage(hatter, new Rectangle((meret.Width - m.Width) / 2, (meret.Height - m.Height) / 2, m.Width, m.Height));
    }

    foreach (Alakzat a in alakzatok)
    {
        Rectangle h = a.Hatar();
        h.Inflate(FogoMeret, FogoMeret);

        if (klip.IsEmpty || h.IntersectsWith(klip))
        {
            a.Rajzol(g);

            if (kijeloles && a.Kijelolt)
            {
                using (Pen szagg = new Pen(Color.RoyalBlue) { DashStyle = DashStyle.Dash })
                {
                    Rectangle k = a.Hatar();
                    g.DrawRectangle(szagg, k.X, k.Y, k.Width, k.Height);
                }

                if (a.VanFogo)
                {
                    Rectangle fogo = FogoTeglalap(a);
                    g.FillRectangle(Brushes.White, fogo);
                    g.DrawRectangle(Pens.RoyalBlue, fogo.X, fogo.Y, fogo.Width, fogo.Height);
                }
            }
        }
    }
}

private void rp_Paint(object sender, PaintEventArgs e)
{
    KepetRajzol(e.Graphics, rp.ClientSize, true, e.ClipRectangle);
}

private void Allapotsor()
{
    tsslDb.Text = alakzatok.Count + " alakzat, " + alakzatok.Count(a => a.Kijelolt) + " kijelölve";
}

private void Modosult()
{
    if (!modosult) { modosult = true; CimFrissit(); }
}

private void CimFrissit()
{
    this.Text = (fajl.Length == 0 ? "Névtelen" : Path.GetFileName(fajl)) + (modosult ? "*" : "") + " – Rajzoló";
}

private void miHatter_Click(object sender, EventArgs e)
{
    ofd.Filter = "Képek (*.png;*.jpg;*.jpeg;*.bmp)|*.png;*.jpg;*.jpeg;*.bmp";

    if (ofd.ShowDialog(this) != DialogResult.OK) { return; }

    string hiba;
    Bitmap uj = KepBetolt(ofd.FileName, out hiba);   // zárolás nélkül, hibatűréssel (9.1 lecke)

    if (uj == null) { tsslUzenet.Text = hiba; return; }

    Bitmap regi = hatter;

    hatter = uj;
    rp.Invalidate();

    if (regi != null) { regi.Dispose(); }   // az új beállítása után szabadítjuk a régit
}

private void miHatterTorol_Click(object sender, EventArgs e)
{
    if (hatter != null) { hatter.Dispose(); hatter = null; rp.Invalidate(); }
}

private void miExport_Click(object sender, EventArgs e)
{
    sfd.Filter = "PNG (*.png)|*.png|JPEG (*.jpg)|*.jpg";
    sfd.DefaultExt = "png";

    if (sfd.ShowDialog(this) != DialogResult.OK) { return; }

    try
    {
        using (Bitmap kep = new Bitmap(rp.Width, rp.Height))
        {
            using (Graphics g = Graphics.FromImage(kep))
            {
                KepetRajzol(g, kep.Size, false, Rectangle.Empty);   // kijelölés nélkül
            }

            if (sfd.FilterIndex == 2) { JpegMent(kep, sfd.FileName, tbMinoseg.Value); }
            else { kep.Save(sfd.FileName, ImageFormat.Png); }
        }

        tsslUzenet.Text = "Exportálva: " + Path.GetFileName(sfd.FileName);
    }
    catch (Exception ex)
    {
        MessageBox.Show(this, "Az exportálás nem sikerült: " + ex.Message, "Exportálás", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

// ---- .rajz fájl: soronként egy alakzat ----
// V;ax;ay;bx;by;#szin;vastag;kitolt     (Vonal)
// T;...   (Teglalap), E;...   (Ellipszis)
// S;x,y x,y x,y;#szin;vastag;kitolt     (Szabadkezi)

private string Sor(Alakzat a)
{
    string kozos = ";" + ColorTranslator.ToHtml(a.Szin) + ";" + a.Vastagsag.ToString(CultureInfo.InvariantCulture) + ";" + (a.Kitoltott ? 1 : 0);

    Szabadkezi sz = a as Szabadkezi;

    if (sz != null) { return "S;" + string.Join(" ", sz.Pontok.Select(p => p.X + "," + p.Y)) + kozos; }

    KetPontos kp = (KetPontos)a;
    string tipus = a is Teglalap ? "T" : a is Ellipszis ? "E" : "V";

    return tipus + ";" + kp.A.X + ";" + kp.A.Y + ";" + kp.B.X + ";" + kp.B.Y + kozos;
}

private Alakzat Elemez(string sor)
{
    string[] m = sor.Split(';');
    Alakzat a;
    int kozosKezdet;

    if (m[0] == "S")
    {
        Szabadkezi sz = new Szabadkezi();

        foreach (string pont in m[1].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
        {
            string[] xy = pont.Split(',');
            sz.Pontok.Add(new Point(int.Parse(xy[0]), int.Parse(xy[1])));
        }

        if (sz.Pontok.Count == 0) { throw new FormatException("nincs pont"); }

        a = sz;
        kozosKezdet = 2;
    }
    else
    {
        KetPontos kp = m[0] == "T" ? (KetPontos)new Teglalap() : m[0] == "E" ? (KetPontos)new Ellipszis() : new Vonal();

        if (m[0] != "T" && m[0] != "E" && m[0] != "V") { throw new FormatException("ismeretlen típus"); }

        kp.A = new Point(int.Parse(m[1]), int.Parse(m[2]));
        kp.B = new Point(int.Parse(m[3]), int.Parse(m[4]));
        a = kp;
        kozosKezdet = 5;
    }

    a.Szin = ColorTranslator.FromHtml(m[kozosKezdet]);
    a.Vastagsag = Math.Max(1, Math.Min(30, float.Parse(m[kozosKezdet + 1], CultureInfo.InvariantCulture)));
    a.Kitoltott = m[kozosKezdet + 2] == "1";

    return a;
}

private bool Ment(bool maskent)
{
    string ut = fajl;

    if (maskent || ut.Length == 0)
    {
        sfd.Filter = "Rajz (*.rajz)|*.rajz";
        sfd.DefaultExt = "rajz";

        if (sfd.ShowDialog(this) != DialogResult.OK) { return false; }

        ut = sfd.FileName;
    }

    try
    {
        File.WriteAllLines(ut + ".tmp", alakzatok.Select(Sor), new UTF8Encoding(false));

        if (File.Exists(ut)) { File.Delete(ut); }

        File.Move(ut + ".tmp", ut);
        fajl = ut;
        modosult = false;
        CimFrissit();
        return true;
    }
    catch (Exception ex)
    {
        MessageBox.Show(this, "A mentés nem sikerült: " + ex.Message, "Mentés", MessageBoxButtons.OK, MessageBoxIcon.Error);
        return false;
    }
}

private bool Folytathat()
{
    if (!modosult) { return true; }

    switch (MessageBox.Show(this, "Mented a változtatásokat?", "Rajzoló", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning))
    {
        case DialogResult.Yes: return Ment(false);
        case DialogResult.No: return true;
        default: return false;
    }
}

private void miMegnyit_Click(object sender, EventArgs e)
{
    ofd.Filter = "Rajz (*.rajz)|*.rajz";

    if (!Folytathat() || ofd.ShowDialog(this) != DialogResult.OK) { return; }

    List<Alakzat> uj = new List<Alakzat>();
    int hibas = 0;

    try
    {
        foreach (string sor in File.ReadAllLines(ofd.FileName))
        {
            if (sor.Trim().Length == 0) { continue; }

            try { uj.Add(Elemez(sor)); }
            catch (Exception) { hibas++; }   // a hibás sor kimarad, számoljuk
        }
    }
    catch (IOException ex)
    {
        MessageBox.Show(this, "A fájl nem olvasható: " + ex.Message, "Megnyitás", MessageBoxButtons.OK, MessageBoxIcon.Error);
        return;   // az eddigi rajz érintetlen
    }

    if (hibas > 0 && (uj.Count == 0 || MessageBox.Show(this, hibas + " hibás sor van. A többi (" + uj.Count + " alakzat) betöltsem?", "Megnyitás", MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) != DialogResult.Yes))
    {
        return;
    }

    alakzatok = uj;   // csak a teljes feldolgozás után
    visszavon.Clear();
    ujra.Clear();
    fajl = ofd.FileName;
    modosult = false;
    CimFrissit();
    Allapotsor();
    rp.Invalidate();
}

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    if (e.CloseReason == CloseReason.UserClosing && !Folytathat()) { e.Cancel = true; }
}

private void Form1_FormClosed(object sender, FormClosedEventArgs e)
{
    if (hatter != null) { hatter.Dispose(); }
}