Aus einer Klasse eine Methode der Forms1 aufrufen
Hallo Alle zusammen,
ich bin neu hier im Forum und hoffe, dass ich im richtigen Bereich poste.
Ich mache meine ersten Gehversuche in C# und habe schon ein konkretes Problem:
- Ich habe eine Klasse (DynamicMenuItems), die mir zur Laufzeit Untermenüpunkte erstellt.
- Wird dann zur Laufzeit aus der Klasse Forms1 einer dieser Menüpunkte aufgerufen, dann soll eine Methode (DoSomethingInForm1()), die in Forms1 liegt, aufgerufen werden.
Das schaffe ich leider nicht.
Ich kann zur Laufzeit Untermenüpunkte erstellen. Diese reagieren auch wenn ich sie anwähle. Dabei komme ich in die Methode buttonAddmenuItems_Click(object sender, EventArgs e) in der Klasse DynamicMenuItems.
Es gelingt mir, dass die Methode DoSomething(), die in der Klasse DynamicMenuItems ist, aufzurufen.
Es gelingt mir nicht die Methode DoSomethingInForm1(), die in Forms1 liegt, aus der Methode ToolStripMenuItem_Click(object sender, EventArgs e) die in DynamicMenuItems liegt, aufzurufen.
Nachfolgend mein Code:
DynamicMenuItems:
namespace Eugen.ESystem
{
public class DynamicMenuItems
{
public DynamicMenuItems()
{
//Mache hier irgendwann irgendetwas
}
/// <summary>
/// List of menu entries to be created
/// </summary>
public string[] MenuItems { get; set; }
/// <summary>
/// Menu into which the submenus are inserted
/// </summary>
public ToolStripMenuItem Menu { get; set; }
/// <summary>
/// Insert a menu item
/// </summary>
/// <param name="menuItem">Name of the Menu item</param>
public void AddMenuItem(string menuItem)
{
ToolStripMenuItem menu = (ToolStripMenuItem)(Menu);
Menu.DropDownItems.Add(menuItem, null, new EventHandler(ToolStripMenuItem_Click));
}
/// <summary>
/// Insert menu entry from a list
/// </summary>
/// <param name="menuList">List of menu items</param>
public void AddMenuItems(string[] menuList)
{
//Für jedes Element in der Liste einen Menüpunkt anlegen
foreach (var element in menuList)
{
AddMenuItem(element);
}
}
/// <summary>
/// Check a menu item
/// </summary>
/// <param name="selectedItem">Item name</param>
public void CheckMenuItem(string selectedItem)
{
//Hier soll der Menüeintrag, der dem Übergebenen Wert entspricht, auf 'Checked = true' gesetzt werden
foreach (ToolStripMenuItem item in Menu.DropDownItems)
{
if (item.Text == selectedItem)
{
item.Checked = true;
}
else
{
item.Checked = false;
}
}
}
private void ToolStripMenuItem_Click(object sender, EventArgs e)
{
ToolStripMenuItem MenuItem = (ToolStripMenuItem)sender;
CheckMenuItem(MenuItem.Text);
MessageBox.Show("Menu " + sender + " angeklickt");
DoSomething();
DoSomethingInForm1(); //Hier liegt das Problem !!!
}
public void DoSomething()
{
OnMyEvent(EventArgs.Empty);
MessageBox.Show("Jetzt sind wir hier");
// ...
}
public event EventHandler MyEvent;
protected virtual void OnMyEvent(EventArgs e)
{
EventHandler myEvent = MyEvent;
if (myEvent != null)
{
myEvent(this, e);
}
}
}
}
Forms1:
namespace Test_DynamicMenuItems
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
//...
}
public static string Value { set; get; }
private void buttonAddmenuItems_Click(object sender, EventArgs e)
{
var dmi = new DynamicMenuItems();
dmi.Menu = subtestToolStripMenuItem;
string[] items = { "SubMenu 1", "SubMenu 2", "SubMenu 3" };
dmi.AddMenuItems(items); //Menüeinträge aus einer List erzeugen
DynamicMenuItems myObject = new DynamicMenuItems();
myObject.MyEvent += myObject_MyEvent;
//myObject.DoSomething();
}
public static void myObject_MyEvent(Object objSender, EventArgs e)
{
MessageBox.Show("myObject_MyEvent (" + objSender + ", " + e + ")");
}
public static void DoSomethingInForm1()
{
//Hier komme ich irgendwie nicht her !!!
MessageBox.Show("Juhu, es hat funktioniert");
//Und da passieren noch ganz viele andere Dinge
}
}
}
So, wie geht man, das richtig an? Sicher habe ich einen Gedankenfehler. Ich sehe mittlerweile vor lauter Bäumen den Wald schon nicht mehr.
Es wäre schön, wenn mir jemand weiterhelfen könnte, da ich zu diesem Problem dringend eine Lösung benötige. Schon ein Mal einen verzweifelten, herzlichen Dank im voraus.
Wenn du deiner DynamicMenuItems Klasse die Instanz zu Form1 übergibst, dann kannst du dir diese dort merke und dann auch auf die Methode zugreifen.
namespace Eugen.ESystem
{
public class DynamicMenuItems
{
private readonly Form1 _form;
public DynamicMenuItems( Form1 form )
{
_form = form;
//Mache hier irgendwann irgendetwas
}
/// <summary>
/// List of menu entries to be created
/// </summary>
public string[] MenuItems { get; set; }
/// <summary>
/// Menu into which the submenus are inserted
/// </summary>
public ToolStripMenuItem Menu { get; set; }
/// <summary>
/// Insert a menu item
/// </summary>
/// <param name="menuItem">Name of the Menu item</param>
public void AddMenuItem(string menuItem)
{
ToolStripMenuItem menu = (ToolStripMenuItem)(Menu);
Menu.DropDownItems.Add(menuItem, null, new EventHandler(ToolStripMenuItem_Click));
}
/// <summary>
/// Insert menu entry from a list
/// </summary>
/// <param name="menuList">List of menu items</param>
public void AddMenuItems(string[] menuList)
{
//Für jedes Element in der Liste einen Menüpunkt anlegen
foreach (var element in menuList)
{
AddMenuItem(element);
}
}
/// <summary>
/// Check a menu item
/// </summary>
/// <param name="selectedItem">Item name</param>
public void CheckMenuItem(string selectedItem)
{
//Hier soll der Menüeintrag, der dem Übergebenen Wert entspricht, auf 'Checked = true' gesetzt werden
foreach (ToolStripMenuItem item in Menu.DropDownItems)
{
if (item.Text == selectedItem)
{
item.Checked = true;
}
else
{
item.Checked = false;
}
}
}
private void ToolStripMenuItem_Click(object sender, EventArgs e)
{
ToolStripMenuItem MenuItem = (ToolStripMenuItem)sender;
CheckMenuItem(MenuItem.Text);
MessageBox.Show("Menu " + sender + " angeklickt");
DoSomething();
_form.DoSomethingInForm1(); //Hier liegt das Problem !!!
}
public void DoSomething()
{
OnMyEvent(EventArgs.Empty);
MessageBox.Show("Jetzt sind wir hier");
// ...
}
public event EventHandler MyEvent;
protected virtual void OnMyEvent(EventArgs e)
{
EventHandler myEvent = MyEvent;
if (myEvent != null)
{
myEvent(this, e);
}
}
}
}
hier der Code von Form1:
namespace Test_DynamicMenuItems
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
//...
}
public static string Value { set; get; }
private void buttonAddmenuItems_Click(object sender, EventArgs e)
{
var dmi = new DynamicMenuItems( this );
dmi.Menu = subtestToolStripMenuItem;
string[] items = { "SubMenu 1", "SubMenu 2", "SubMenu 3" };
dmi.AddMenuItems(items); //Menüeinträge aus einer List erzeugen
DynamicMenuItems myObject = new DynamicMenuItems( this );
myObject.MyEvent += myObject_MyEvent;
//myObject.DoSomething();
}
public static void myObject_MyEvent(Object objSender, EventArgs e)
{
MessageBox.Show("myObject_MyEvent (" + objSender + ", " + e + ")");
}
public static void DoSomethingInForm1()
{
// jetzt kommen wir hier auch hin
MessageBox.Show("Juhu, es hat funktioniert");
//Und da passieren noch ganz viele andere Dinge
}
}
}
So richtig gesund ist das irgendwie nicht - allerdings sehe ich noch nicht so richtig, was für ein Problem du damit eigentlich lösen möchtest.
PS: Deinen Code solltest du mit Code-Tags versehen, dann ist der auch so leserlich wie meiner hier.
Hat die Blume einen Knick, war der Schmetterling zu dick.
Hallo BlonderHans,
danke für Deine rasche Antwort. Momentan versuche ich das Ganze umzusetzen, aber so ganz gelingt mir das nicht. Ich bekomme immer eine Fehlermeldung (siehe Anhang).
Habe ich da etwas Übersehen?
Was ich vergessen habe zu erwähnen: Die KlasseDynamicMenuItems ist eine DLL.
Zu Deiner Frage, dass Du den Zweck des Programms nicht erkennen kannst, ist zu sagen, dass das eigentliche Programm zwecks Übersichtlichkeit, soweit wie möglich zusammengekürzt wurde.
Nochmals danke.
Hallo
Der Fehler liegt eigentlich daran, dass man das so gar nicht macht! Eine Unterklasse sollte nie ihren Parent kennen. Dazu verwendet man Events, siehe https://mycsharp.de/forum/threads/5960/faq-kommunikation-von-2-forms.
mfG
Thomas
@BlonderHans: Danke für deine Unterstützung. Habe das Ding jetzt am laufen - Es fehlt nur eine using Anweisung.
@thomas.at: Danke, es ist mir schon klar, das man das Events machen sollte, aber das hat in meinem Fall noch nicht so funktioniert wie es soll/ich mir das vorstelle. Das Problem ist, dass ich auf ein bestehendes Programm aufsetzen muss und die Möglichkeiten die ich habe, sehr eingeschränkt sind. Aber noch einmal danke für Deine Unterstützung.
Hallo Thomas.at,
ich habe mir das mit den Events noch einmal angesehen, weil es es mir tendenziell auch besser gefällt als die andere Lösung.
Soweit funktioniert das auch, wenn die Methode DoSomething() in der Klasse ausgeführt werden soll. Was ich jedoch nicht hinbekomme, ist, wenn die Methode DoSomethingInForm1() ausgeführt werden soll.
Der Grund warum die ausgeführt werden soll, liegt an dem Programm, in welchem ich die Änderungen vornehmen soll:
Bisher war es so, wenn sich ein Menüeintrag geändert hat, dann wurde das Programm entsprechend geändert. Entsprechend der Menüeinträge gab es eine Methode, welche den ausgewählten Menüeintrag analysierte und dann entsprechend dem Ergebnis und einem dahinterliegenden Regelwerk andere Methoden aufrief.
Seit einiger Zeit müssen immer öfter und immer mehr Menüeinträge geändert, gelöscht und ergänzt werden. Darum soll jetzt die Programmfunktion so weit abgeändert werden, dass die Menüeinträge aus einer Art Konfigurationsdatei kommen. Aus dieser Konfigurationsdatei liest eine neue Klasse (DLL), die in unserem Beispiel durch die Klasse DynamicMenuItems repräsentiert wird, die Werte ein und legt die Menüpunkte zur Laufzeit im Hauptprogramm an. Der Einfachheit halber, werden in meinem Beispiel drei Menüeinträge (SubMenu 1, SubMenu 2 und SubMenu 3) so zur Laufzeit erzeugt und nicht aus einer Konfigurationsdatei. Wird dann im Hauptprogramm ein Menüpunkt ausgewählt, dann soll die bestehende Methode, welche die Auswahl analysiert, aufgerufen werden. Diese Methode und alles was dahinterliegt, soll nicht verändert werden, da dies ziemlich komplex und über Jahre gewachsen ist und man einerseits in eine Änderung dieser nichts investieren will und andererseits befürchtet, was eigentlich noch gravierender ist, dass am Anfang zu viele Fehler passieren, was das Programm über einen längeren Zeitraum unbrauchbar machen würde.
So, jetzt zu meiner eigentlichen Frage:
Gibt es eine Möglichkeit, dass ich, um bei meinem Beispiel zu bleiben, durch ein Event, welches durch den Aufruf eines Menüpunktes in der Klasse Form1 ausgelöst wird, die Methode DoSomethingInForm1() ausgeführt wird. Ich habe da leider nichts entsprechendes gefunden. Und wenn, dann habe ich es falsch interpretiert.
Da dies nicht das einzige Programm ist, welches auf diese Art umgebaut werden soll, wäre ich über eine Lösung wirklich dankbar.
Hallo
In der Klasse "DynamicMenuItems" löst Du in der Methode "ToolStripMenuItem_Click" das neue Event aus. Dieses wird dann in Form1 abonniert und dort kannst Du die Methode "DoSomethingInForm1" aufrufen. Eigentlich so wie BlonderHans in seinem Beispiel zeigt mit folgenden Änderungen:
private readonly Form1 _form;
public DynamicMenuItems( Form1 form )
{
_form = form;
//Mache hier irgendwann irgendetwas
}
Das kann gestrichen werden. In DynamicMenuItems folgendes eintragen:
private void ToolStripMenuItem_Click(object sender, EventArgs e)
{
ToolStripMenuItem MenuItem = (ToolStripMenuItem)sender;
CheckMenuItem(MenuItem.Text);
MessageBox.Show("Menu " + sender + " angeklickt");
OnMyEvent(EventArgs.Empty);
}
In Form1 dann das programmieren:
public static void myObject_MyEvent(Object objSender, EventArgs e)
{
MessageBox.Show("myObject_MyEvent (" + objSender + ", " + e + ")");
DoSomethingInForm1();
}
Wenn Du mehrere Aktionen im Event in Form1 ausführen möchtest, dann musst Du halt ein eigenes EventArg definieren und dieses in den beiden Klassen entsprechend übergeben und auswerten.
P.S. Das registrieren des Events in Form1 sollte nicht im ButtonClick sein, sondern in FormLoad. Sonst wird nämlich bei jedem Klick des Buttons das Event nochmals registriert und dadurch das Event x-mal aufgerufen.
Ich hoffe das es jetzt etwas klarer wird und wünsche "Happy Coding"
Thomas
Hallo Thomas.at,
erst einmal danke für Deine verständliche Ausführung.
Es scheint alles zu funktionieren. Ich habe jetzt Alles nach Deinen Vorgaben umgesetzt. Nur ein kleines Problem habe ich noch:
Was muss in die Klammer der Zeile DynamicMenuItems myObject = new DynamicMenuItems(Form1); - Form1 passt nicht, this will VS auch nicht und wenn ich die Klammer leer lasse meckert VS auch.
public Form1()
{
InitializeComponent();
}
DynamicMenuItems myObject = new DynamicMenuItems(Form1);
private void Form1_Load(object sender, EventArgs e)
{
....
myObject.MyEvent += myObject_MyEvent; //Event abonnieren
}
Danke für Deine Geduld.
Hast du den Konstruktor von DynamicMenuItems ganz gelöscht? Füge wieder den Standardkonstruktor, wie in deinem Originalcode, hinzu.
Hallo Th69,
danke für den Tipp - genau das war es.
Hallo Zusammen,
gestern war ich anscheinend etwas zu voreilig, da bei einem ersten flüchtigen Test die Methode DoSomethingInForm1() aufgerufen wurde. Als ich mir am Abend das Ganze noch einmal genauer ansehen wollte, funktionierte es nicht mehr. Keine Ahnung warum, ich hatte am Code nicht verändert. Die Methode DoSomethingInForm1() wird einfach nicht mehr aufgerufen.
Nachfolgend der Code, so wie ich ihn jetzt habe:
Die Klasse DynamicMenuItems:
{
public class DynamicMenuItems
{
public Form1()
{
SetDllInfo();
}
/// <summary>
/// List of menu entries to be created
/// </summary>
public string[] MenuItems { get; set; }
/// <summary>
/// Menu into which the submenus are inserted
/// </summary>
public ToolStripMenuItem Menu { get; set; }
/// <summary>
/// Insert a menu item
/// </summary>
/// <param name="menuItem">Name of the Menu item</param>
public void AddMenuItem(string menuItem)
{
ToolStripMenuItem menu = (ToolStripMenuItem)(Menu);
Menu.DropDownItems.Add(menuItem, null, new EventHandler(ToolStripMenuItem_Click));
}
/// <summary>
/// Insert menu entry from a list
/// </summary>
/// <param name="menuList">List of menu items</param>
public void AddMenuItems(string[] menuList)
{
//Für jedes Element in der Liste einen Menüpunkt anlegen
foreach (var element in menuList)
{
AddMenuItem(element);
}
}
/// <summary>
/// Check a menu item
/// </summary>
/// <param name="selectedItem">Item name</param>
public void CheckMenuItem(string selectedItem)
{
//Hier soll der Menüeintrag, der dem Übergebenen Wert entspricht, auf 'Checked = true' gesetzt werden
foreach (ToolStripMenuItem item in Menu.DropDownItems)
{
if (item.Text == selectedItem)
{
item.Checked = true;
}
else
{
item.Checked = false;
}
}
}
private void ToolStripMenuItem_Click(object sender, EventArgs e)
{
ToolStripMenuItem MenuItem = (ToolStripMenuItem)sender;
CheckMenuItem(MenuItem.Text);
MessageBox.Show("Menu " + sender + " angeklickt");
OnMyEvent(EventArgs.Empty);
}
public event EventHandler MyEvent;
protected virtual void OnMyEvent(EventArgs e)
{
EventHandler myEvent = MyEvent;
if (myEvent != null)
{
myEvent(this, e);
}
}
}
}
Die Klasse Form1:
namespace Test_DynamicMenuItems
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
DynamicMenuItems myObject = new DynamicMenuItems(); //Event deklarieren
private void Form1_Load(object sender, EventArgs e)
{
myObject.MyEvent += myObject_MyEvent; //Event abonnieren
}
public static string Value { set; get; }
private void buttonAddmenuItems_Click(object sender, EventArgs e)
{
var dmi = new DynamicMenuItems();
dmi.Menu = subtestToolStripMenuItem;
string[] items = { "SubMenu 1", "SubMenu 2", "SubMenu 3" };
dmi.AddMenuItems(items); //Menüeinträge aus einer List erzeugen
}
public static void myObject_MyEvent(Object objSender, EventArgs e)
{
MessageBox.Show("myObject_MyEvent(" + objSender + ", " + e +")");
DoSomethingInForm1();
}
public static void DoSomethingInForm1()
{
//Hier komme ich irgendwie nicht hin !!!
MessageBox.Show("Juhu, es hat funktioniert");
}
}
}
Ich werde aus dem Ganzen einfach nicht schlau. Auf der einen Seite klingt das Ganze für mich logisch, auf der anderen Seite verhält es sich irgendwie komplett anders als gedacht.
Für Eure Hilfe und Geduld möchte ich mich schon im Vorhinein bedanken.
Benutze den Debugger: [Artikel] Debugger: Wie verwende ich den von Visual Studio?
Hallo TH69,
den Debugger habe ich natürlich schon benutzt. Bisher habe ich aber nichts gefunden, außer dass myObject_MyEvent(Object objSender, EventArgs e) einfach nie angesprungen wird. Ich habe keine Idee wie ich das Verhalten ändern könnte.
Es wäre sehr hilfreich wenn du deinen Code mit den entsprechenden Code-Tags posten würdest, das erhöht die Chance, dass sich überhaupt jemand die Mühe macht, deinen Code anzusehen.
Also statt so
namespace Hier
{
public class Da
{
public void Dort()
{
// ganz wichtig!
}
}
}
hätten wir es gerne so
namespace Hier
{
public class Da
{
public void Dort()
{
// ganz wichtig!
}
}
}
PS: Und statt myObject_MyEvent(Object objSender, EventArgs e) hätten wir gerne myObject_MyEvent(Object objSender, EventArgs e)
Hat die Blume einen Knick, war der Schmetterling zu dick.
Wird denn Form1_Load aufgerufen? Evtl. hast du vergessen es im Designer zu aktivieren/abonnieren.
Alternativ kannst du den enthaltenen Code auch direkt in den Form-Konstruktor verschieben.
Sorry, das mit Code-Tags hatte ich nicht so richtig geschnallt. Ich hoffe, dass es jetzt passt.
Nochmal danke, dass Ihr euch die Zeit nehmt und mich unterstützt und auch für Eure Geduld. Für mich ist das Alles neu hier und dementsprechend bin ich noch etwas holprig unterwegs.
Übrigens,Form_Load wird beim Debuggen durchlaufen.
Die Klasse DynamicMenuItems:
namespace Eugen.ESystem
{
public class DynamicMenuItems
{
public DynamicMenuItems()
{
SetDllInfo();
}
/// <summary>
/// List of menu entries to be created
/// </summary>
public string[] MenuItems { get; set; }
/// <summary>
/// Menu into which the submenus are inserted
/// </summary>
public ToolStripMenuItem Menu { get; set; }
/// <summary>
/// Insert a menu item
/// </summary>
/// <param name="menuItem">Name of the Menu item</param>
public void AddMenuItem(string menuItem)
{
ToolStripMenuItem menu = (ToolStripMenuItem)(Menu);
Menu.DropDownItems.Add(menuItem, null, new EventHandler(ToolStripMenuItem_Click));
}
/// <summary>
/// Insert menu entry from a list
/// </summary>
/// <param name="menuList">List of menu items</param>
public void AddMenuItems(string[] menuList)
{
//Für jedes Element in der Liste einen Menüpunkt anlegen
foreach (var element in menuList)
{
AddMenuItem(element);
}
}
/// <summary>
/// Check a menu item
/// </summary>
/// <param name="selectedItem">Item name</param>
public void CheckMenuItem(string selectedItem)
{
//Hier soll der Menüeintrag, der dem Übergebenen Wert entspricht, auf 'Checked = true' gesetzt werden
foreach (ToolStripMenuItem item in Menu.DropDownItems)
{
if (item.Text == selectedItem)
{
item.Checked = true;
}
else
{
item.Checked = false;
}
}
}
private void ToolStripMenuItem_Click(object sender, EventArgs e)
{
ToolStripMenuItem MenuItem = (ToolStripMenuItem)sender;
CheckMenuItem(MenuItem.Text);
MessageBox.Show("Menu " + sender + " angeklickt");
OnMyEvent(EventArgs.Empty);
}
public event EventHandler MyEvent;
protected virtual void OnMyEvent(EventArgs e)
{
EventHandler myEvent = MyEvent;
if (myEvent != null)
{
myEvent(this, e);
}
}
}
}
Die Klasse Form1:
namespace Test_DynamicMenuItems
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
DynamicMenuItems myObject = new DynamicMenuItems(); //Event deklarieren
private void Form1_Load(object sender, EventArgs e)
{
myObject.MyEvent += myObject_MyEvent; //Event abonnieren
}
public static string Value { set; get; }
private void buttonAddmenuItems_Click(object sender, EventArgs e)
{
var dmi = new DynamicMenuItems();
dmi.Menu = subtestToolStripMenuItem;
string[] items = { "SubMenu 1", "SubMenu 2", "SubMenu 3" };
dmi.AddMenuItems(items); //Menüeinträge aus einer List erzeugen
//DynamicMenuItems myObject = new DynamicMenuItems();
//myObject.MyEvent += myObject_MyEvent;
}
public static void myObject_MyEvent(Object objSender, EventArgs e)
{
MessageBox.Show("myObject_MyEvent(" + objSender + ", " + e +")");
DoSomethingInForm1();
}
public static void DoSomethingInForm1()
{
//Hier komme ich irgendwie nicht hin !!!
MessageBox.Show("Juhu, es hat funktioniert");
}
}
}
Also du hast dort eine Instanz, wo du die Events abonnierst:
DynamicMenuItems myObject = new DynamicMenuItems(); //Event deklarieren
myObject.MyEvent += myObject_MyEvent; //Event abonnieren
und dann erzeugst du eine andere Instanz um dort das anzulegen, was dann irgendwie dieses Event auslösen soll
var dmi = new DynamicMenuItems();
dmi.Menu = subtestToolStripMenuItem;
string[] items = { "SubMenu 1", "SubMenu 2", "SubMenu 3" };
dmi.AddMenuItems(items); //Menüeinträge aus einer List erzeugen
Das ist ungefähr so, wenn du dich benachrichtigen lässt, wenn bei Paul an der Wohnungstür jemand klingelt - du bei Sabine an der Wohnungstür auf die Klingel drückst und dich wunderst, warum du keine Benachrichtigung erhälst.
Hat die Blume einen Knick, war der Schmetterling zu dick.
Hallo BlonderHans,
jetzt ist mir klar wie das Aufsehen muss, es hat funktioniert.
Danke für Deine Unterstützung - Du hast mir den Tag gerettet.