OnPaint wird nicht gecalled

Hallo,

ich möchte eine Tutorial blase machen und hatte mir dafür eine eigenes Element erstellt.
Nun klappte es alles schon super aber nachdem ich den Code habwegst aufgeräumt habe geht es nicht mehr und ich finde den Fehler einfach nicht. Onpaint wird einfach nicht mehr aufgerufen.
Vielleicht kann mir ja jemand helfen.

Übrigens wenn ich von Form ableite funktioniert es und on Paint wird aufgerufen, aber sobald es wieder von Panel ableite geht es nicht.

using System;
using System.Diagnostics.CodeAnalysis;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

/// <summary>
/// Erstellt eine abgerundetes Dreieck wo der TutorialText drin steht.
/// </summary>
public class TutorialBubble : Panel
{
    //--------------------------------------------------------------------------------------
    //----------------------    ENUMS   ----------------------------------------------------
    //--------------------------------------------------------------------------------------
    /// Enum welches die möglichen Dockingmodes beinhaltet
    /// Right = Bubble dock rechts am Control an
    public enum DOCKMODES
    {
        /// <remarks/>
        DOCKMODE_NONE = 0,
        /// <remarks/>
        DOCKMODE_RIGHT,
        /// <remarks/>
        DOCKMODE_BOTTOM,
        /// <remarks/>
        DOCKMODE_LEFT,
        /// <remarks/>
        DOCKMODE_TOP,
        /// <remarks/>
        DOCKMODE_CENTER
    }

    //--------------------------------------------------------------------------------------
    //---------------------     Member   ---------------------------------------------------
    //--------------------------------------------------------------------------------------
    /// <summary>
    /// Flag wo die Tutorialblase andocken soll
    /// </summary>
    private DOCKMODES _DockMode;

    /// <summary>
    /// Getter/Setter
    /// !Setter: Setzt den Docking Mode und fals eine Blase aktiv ändert er sie
    /// </summary>
    public DOCKMODES DockMode
    {
        get { return _DockMode; }
        set
        {
            _DockMode = value;

            if (_Active)
            {
                // TODO M-Code
                // neu zeichnen
                // PikeOffset neu berechnen
            }
        }
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Das Control an dem die Bubble gedock ist
    /// </summary>
    private Control _OnDockedControl;

    /// <summary>
    /// Getter/Setter
    /// </summary>
    public Control OnDockedControl
    {
        get { return _OnDockedControl; }
        set
        {
            _OnDockedControl = value;

            if (_Active)
            {
                // TODO M-Code
                // neu zeichnen
            }
        }
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Die Position der Blase.
    /// </summary>
    private Point _PikeOffset;
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Abmaße der Blase.
    /// </summary>
    private Size _Size;
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Der Text der Blase.
    /// </summary>
    private String _Text;
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Der Radius der Abgerundeten Ecken.
    /// </summary>
    private int _CornerRadius;

    /// <summary>
    /// Getter/Setter
    /// </summary>
    public int CornerRadius
    {
        get { return _CornerRadius; }
        set
        {
            _CornerRadius = value;
            // TODO M-Code
            // neu zeichnen
        }
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Der Pen für den Rahmen.
    /// </summary>
    private Pen _Pen;

    /// <summary>
    /// Getter/Setter
    /// </summary>
    public Pen Pen
    {
        get { return _Pen; }
        set
        {
            _Pen = value;
            // TODO M-Code
            // neu zeichnen
        }
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Der Brush der die Figur ausfüllt.
    /// </summary>
    private Brush _Brush;

    /// <summary>
    /// Getter/Setter
    /// </summary>
    public Brush Brush
    {
        get { return _Brush; }
        set
        {
            _Brush = value;
            // TODO M-Code
            // neu zeichnen
        }
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Der Font in der der Text geschrieben werden soll.
    /// </summary>
    private Font _TutorialFont;

    /// <summary>
    /// Getter/Setter
    /// </summary>
    public Font TutorialFont
    {
        get { return _TutorialFont; }
        set
        {
            _TutorialFont = value;
            // TODO M-Code
            // neu schreiben
        }
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Der Brush der den Text schreibt.
    /// </summary>
    private Brush _FontBrush;

    /// <summary>
    /// Getter/Setter
    /// </summary>
    public Brush FontBrush
    {
        get { return _FontBrush; }
        set
        {
            _FontBrush = value;
            // TODO M-Code
            // neu schreiben
        }
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// FLAG: Ob eine Tutorialblase angezeit werden soll wenn möglich
    /// </summary>
    private bool _Active;

    /// <summary>
    /// Getter/Setter
    /// !Setter: Beeinflusst auch die Sichtbarkeit ( Show()/Hide() )
    /// </summary>
    public bool Active
    {
        get { return _Active; }
        set
        {
            _Active = value;
            if (value)
                this.Show();
            else
                this.Hide();
        }
    }
    //--------------------------------------------------------------------------------------
    //---------------------     Funktionen   -----------------------------------------------
    //--------------------------------------------------------------------------------------

    ///<summary>
    /// standart Konstrukter
    ///</summary>
    public TutorialBubble()
    {
        InitializeComponent();

        Active = false;
        this.Show();

        SetDefault();

        // legt die Size des Forms fest
        // Da der Stiftbreite außen an den Linien malt ist das Fenster um die 2 fache Stiftbreite größer
        this.ClientSize = new Size(_Size.Width + ((int)_Pen.Width << 1), _Size.Height + ((int)_Pen.Width << 1));
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Setzt die Standartwerte
    /// </summary>
    private void SetDefault()
    {
        _Brush = new SolidBrush(Color.AntiqueWhite);
        _FontBrush = new SolidBrush(Color.Black);
        _Pen = new Pen(Color.Black, 2);
        _TutorialFont = new Font("Arial", 8);
        _Text = "";

        // vielleicht anderen Standart nehmen //
        _DockMode = DOCKMODES.DOCKMODE_NONE;  //
        _PikeOffset = new Point(0, 0);        //

        _Size = new Size(100, 100);
        _CornerRadius = 5;
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Setzt die Tutorialblase an ein Control
    /// </summary>
    public void SetTutorialBubble(Control control, String tutorialText)
    {
        Active = true;

        OnDockedControl = control;
        // TODO M-Code
        // fallunterscheidung
        
        //this.Location = _OnDockedControl.Location;
        this.Location = new Point(500,500);

        _Text = tutorialText;
    }

    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Zeichnet das Objekt.
    /// </summary>
    /// <param name="e"></param>
    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);

        Graphics graphicObj = e.Graphics;

        // Legt die Renderqualitäten fest
        graphicObj.SmoothingMode = SmoothingMode.HighQuality;
        graphicObj.PixelOffsetMode = PixelOffsetMode.HighQuality;
        graphicObj.InterpolationMode = InterpolationMode.High;
        graphicObj.CompositingQuality = CompositingQuality.HighQuality;

        if (Visible)
        {
            // Draw Bubble
            DrawRoundedRectangle(graphicObj);

            // Draw String
            RectangleF writingRec = new RectangleF(_CornerRadius, _CornerRadius,
                                            _Size.Width - (_CornerRadius << 2), _Size.Height - (_CornerRadius << 2));
            graphicObj.DrawString(_Text, _TutorialFont, _FontBrush, writingRec);
        }
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// Rendert ein RechtEck mit abgerundeten Ecken.
    /// </summary>
    /// <param name="graphicObj"></param>
    private void DrawRoundedRectangle(Graphics graphicObj)
    {
        // legt das den Zeichenpfad an
        GraphicsPath graphicsPath = new GraphicsPath();

        // TODO Fallunterscheidungen

        // Ecke Rechts Oben
        graphicsPath.AddArc(_Pen.Width + _Size.Width - _CornerRadius, _Pen.Width,
            _CornerRadius, _CornerRadius, 270, 90);

        // Ecke Rechts Unter
        graphicsPath.AddArc(_Pen.Width + _Size.Width - _CornerRadius, _Pen.Width + _Size.Height - _CornerRadius,
            _CornerRadius, _CornerRadius, 0, 90);

        // Ecke Links Unten
        graphicsPath.AddArc(_Pen.Width, _Pen.Width + _Size.Height - _CornerRadius,
            _CornerRadius, _CornerRadius, 90, 90);

        // Ecke Links Oben
        graphicsPath.AddArc(_Pen.Width, _Pen.Width,
            _CornerRadius, _CornerRadius, 180, 90);

        // jetzt verbinden
        graphicsPath.CloseFigure();

        // Figur füllen
        if (_Brush != null)
        {
            graphicObj.FillPath(_Brush, graphicsPath);
        }

        // Figur rahmen
        if (_Pen != null)
        {
            graphicObj.DrawPath(_Pen, graphicsPath);
        }
    }
    //--------------------------------------------------------------------------------------

    /// <summary>
    /// inizialisiert die Componenten mit den Einstellungen aus dem Designer
    /// </summary>
    private void InitializeComponent()
    {
        this.SuspendLayout();
        // 
        // TutorialBubble
        // 
        //this.BackColor = Color.Transparent;
        this.ClientSize = new System.Drawing.Size(0, 0);
        this.Name = "TutorialBubble";
        this.ResumeLayout(false);
    }
}

welche controlstyles sind denn gesetzt?

Ein vorschlag, kommentier mal alles überflüssige aus. Und dann schritt für schritt wieder ein, so findest du das am schnellsten. Und deine underscores am Anfang einer variable finde ich persönlich schrecklich.

Kleine Anmerkung. Ich habs bei mir mal ausprobiert und es geht ohne Probleme.

@ JAck30lena
Also Controlstyles sind aktuell nicht gesetzt aber daran sollte es nicht liegen.
Wiegesagt ich hat ja schon mal funktioniert. Aber ich habe leider kein Backup weil den unschönen Code nicht hochladen wollte, deshalt alles aufgeräumt und nun geht es nicht mehr arrr

@rollerfreak2
8o bei dir funktioniert es doppelt arrrr
Aber danke für die Info dann werd ich mal ein frisches Projekt aufsetzen und nochmal austesten.

Die Unterstriche sowie die deutschen Kommentare müssen so sein ist der mir vorgegebene Codestyle, finde es aber auch nicht schön ^^

MfG
Bug

@ JAck30lena
Also Controlstyles sind aktuell nicht gesetzt aber daran sollte es nicht liegen.

controlstyles sind unter garantie gesetzt und ein bestimmtes davon verhindert den aufruf von onpaint.... daher meine frage.

edit: die frage ist ob gerade dieses bei dir gesetzt ist/war.

Onpaint wird einfach nicht mehr aufgerufen.

Hast du mal versucht, per Invalidate() das Panel neuzuzeichnen? Dann sollte OnPaint auf jeden Fall aufgerufen werden.

Hast du mal versucht, per Invalidate() das Panel neuzuzeichnen? Dann sollte OnPaint auf jeden Fall aufgerufen werden.

nein. wenn es vorher nicht aufgerufen wurde, nützt das invalidate auch ncihts.

es gibt nur eine möglichkeit, das onpaint nciht aufgerufen wird und das ist das besagte controlstyle.

@rollerfreak2
ich weiß nicht wie du es geschafft hast aber ich hab es nicht hinbekommen.
Habe eine neues Projekt aufgesetzt und nur das gemacht

public partial class Form1 : Form
    {
        TutorialBubble blub;
        public Form1()
        {
            InitializeComponent();
            blub = new TutorialBubble();
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            blub.SetTutorialBubble(null, "Hallo");
            blub.Show();
        }
    }

@JAck30lena
Controlstyles hab ich nicht verändert sind also alle noch auf standart gesetzt.
Hatte aber auch schon die

this.SetStyle(ControlStyles.DoubleBuffer |
                          ControlStyles.UserPaint |
                          ControlStyles.AllPaintingInWmPaint |
                          ControlStyles.SupportsTransparentBackColor |
                          ControlStyles.ResizeRedraw, true);

ausprobiert ändert leider nichts.

MfG
Bug

lösche mal den "bin" und "obj" ordner aus deinem projektverzeicniss und starte das programm direkt aus VS heraus mit einem breakpoint in der onpaint.

@JAck30lena
ok hab ich gemacht half leider nicht 😦

kontrolliere mal die projekteigenschaften. was steht unter "debug" und was steht unter "build" ? irgendwelche buildevents?

mach am besten von allen dreien einen screenshot.

Build Events

Build

Debug

also ich sehe nicht viel und wie gesagt in einem frischen Projekt geht es ja auch nicht

ok, da ist alles ok. ((vs 2010?)

@JAck30lena
schon mal ganz großen Dank für die Mühe

wenn du ein breakpoint setzt und aus vs heraus startest, ist dann im vs am breakpoint so ein ausrufezeichen?

nein ist nicht

kannst du mal das ganze projekt zippen und hier hochladen?

Wenn ich rollerfreak2 richtig verstanden habe sollte es bei ihm so geklappt haben.

ok ich hab den fehler.

    public partial class Form1 : Form
    {
        TutorialBubble blub;
        public Form1()
        {
            InitializeComponent();
            blub = new TutorialBubble();
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            blub.SetTutorialBubble(null, "");
        }
    }

hier erzeugst du zwar eine instanz deines controls aber fügst es nicht der form hinzu.

dir fehlt:

this.Controls.Add(blub);

öch nö wie doof bin ich denn X(
Vielen Dank