Hallo VB-Fans,
für mein Projekt (algolok.de) benutze ich dynamisch erzeugte Textboxen mit eigenem Handler.

Beispiel: AddHandler boxen(i).MouseDown, AddressOf maustastefeststellen

Das klappt klaglos, leider erscheint bei der rechten Maustaste dann das lästige Kontextmenü, das ich gerne loswerden würde. Meine Recherchen ergaben, dass der sauberste Weg Subclassing ist, das habe ich aber noch nicht hinbekommen. Kennt ihr evtl. einen einfacheren Weg? Mir würde schon das direkte Schließen des Kontextmenüs reichen…

Gruß von Algolok

Gelöst!
Vielen Dank, das war es!
Noch einfacher geht es ja kaum. Und ich schlage mich einen halben Tag mit Subclassing rum!

Herzliches Dankeschön von
Algolok.

Ah, verstehe!
Also hier noch mal die optimale Version:

Dim KeinKontext As New ContextMenuStrip
Dim boxen() As TextBox
Dim elementanzahl = 5
ReDim boxen(elementanzahl)

for i = 1 to 5
boxen(i) = New TextBox
boxen(i).ContextMenuStrip = KeinKontext
Me.Controls.Add(boxen(i))
AddHandler boxen(I).MouseDown, AddressOf maustastefeststellen
'maustastefeststellen ist ein Private Sub, in der das Ereignis "MouseDown" behandelt wird
Next

Noch mal besten Dank, das hilft doch sehr!
Gruß von Algolok

Hmm,
damit wollte ich andeuten, dass die Anzahl der Textboxen dynamisch erweitert wird. Wenn der Inhalt der bereits existierenden Boxen erhalten bleiben soll, ist ReDim doch der eleganteste Weg oder? Ansonsten müßte man alle Inhalte retten, alle Textboxen löschen und in der neuen Anzahl anlegen und die alten Inhalte übertragen.

O.k., das gehört zwar nicht zu meinem Startthema, da ich aber auf keine bessere Lösung gekommen bin, hier meine Problemstellung:
Für die Programmierung einer intuitiven Entwicklungsumgebung (algolok.de) stelle ich den Ablauf des Programms grafisch dar (Verzweigung, Schleife, Anweisung). Trifft der Ablauf auf eine Anweisung, werden die Operationen als Funktionen mit Parametern dargestellt, z.B:

Da jeder Anweisungsblock eine unterschiedliche Anzahl von Funktionen und jede Funktion eine unterschiedliche Anzahl an Parametern haben kann, hielt ich die Definition von dynamisch erzeugten Textboxen für den einzig gangbaren Weg. Ich habe es auch schon mit einer großen Textbox je Funktion und einer Kontrolle des Textes probiert, das wurde aber beliebig kompliziert.Wenn ihr eine Idee für mich habt, ich versuche es gerne!
Gruß von Algolok

Ich habe die beiden vorgeschlagenen Mittel „Typisierte Liste“ und „Treeview“ einmal ausprobiert. Beide haben ihren Charme, da man sich entweder viel Verwaltungsarbeit oder Darstellungsaufwand spart. Leider haben auch beide gravierende Nachteile.
Nur zur Klarstellung: Die Textboxen dienen mir nur zur Darstellung und dem Anwender zur Eingabe. Die Datenstruktur (Funktion mit n-Parametern) ist eher flach, die bekommt man ohne größeren Aufwand in eine Datei.
Was ich realisieren muss, ist eine kompakte Anzeige, da die Anzahl und Darstellungsbreite naturgemäß schwankt, etwas so:

Funktion_____Name_________Sichtbar_Text______
Zeigefenster_Hauptfenster_True_____Hallo Welt

Funktion______Variable_Zahl
Multipliziere_Kapital__3___

Das Treeview-Element stellt diese Strukturen als Baum dar, damit muss man sich um die horizontale Breite keine Sorgen mehr machen, vertikal ist der Bildschirm allerdings schon nach wenigen Anweisungen voll, das wird zu unkomfortabel (eigentlich ist diese Struktur ja auch keine Baumstruktur, sondern eine flache Liste).

Trotzdem natürlich: DANKE für eure Anregungen!

Algolok

Zu:„Also den Nachteil von "typisierte Liste" gegenüber ReDim hast du nicht erklärt. Ist auch unmöglich, denn sie hat keinen :P“
Stimmt, der Satz „Was ich realisieren muss, ist eine kompakte Anzeige, da die Anzahl und Darstellungsbreite naturgemäß schwankt“, ist nicht unbedingt selbsterklärend.Eine typisierte Liste bringt für die Darstellung unterschiedlich vieler und langer Einträge je "Datenzeile" keinen strukturellen Vorteil. Die Methoden der typisierten Liste sind aber schon verlockend. Danke für den Hinweis.

ZU:„Das wundert mich, dass du meinst, einen Programmfluss mit einer flachen Liste modellieren zu können.“
Das würde mich auch wundern, denn das geht auch m.E. nicht. Ist hier aber auch nicht das Thema. Siehe oben „Für die Programmierung einer intuitiven Entwicklungsumgebung (algolok.de) stelle ich den Ablauf des Programms grafisch dar (Verzweigung, Schleife, Anweisung). Trifft der Ablauf auf eine Anweisung, werden die Operationen als Funktionen mit Parametern dargestellt“
Es geht hier momentan nur um die geeignete Darstellung und Editiermöglichkeit einer Aufzählung von Funktionen mit unterschiedlich vielen Parametern. Also das, was Intellisens so schön mit Text und der Trennung durch Kommata macht (und was ich mal eben mit einer endlichen Anzahl von Textboxen nachzubilden versuchte).

Gruß von Algolok

Genau!
Die Anweisung selbst ist ja Teil des Ablauffensters (siehe mein Avatar, dort ist es das blaue Ausrufezeichen), wenn allerdings eine Anweisung ausgewählt wurde, dann sollen ja alle Funktionen dieser Anweisung angezeigt werden und die haben neben Pflichtparametern auch optionale. Die dann sollen dann hinzugefügt oder gelöscht werden können:

Diese Funktion zeigt das vorher definierte Objekt „Windowsfenster“ an und gibt den Text „Hallo Welt“ im Formtext aus.
Funktion_____Name_________Sichtbar_Text______
Zeigefenster_Hauptfenster_True_____Hallo Welt

Der Text-Parameter ist aber optional, er kann also gelöscht werden.
Funktion_____Name_________Sichtbar
Zeigefenster_Hauptfenster_True____
Diese Funktion zeigt dann das vorher definierte Objekt „Windowsfenster“ ohne Text an.

So wird diese ganze Funktions- und Parametersteuerung ein recht komplexes Ding, zumal ja auch Kopier- und Löschfunktionen für die ganze Funktionszeile vorgesehen werden müssen.
Je weiter meine Konzeptphase geht, desto mehr Komplexität wird deutlich. Ihr kennt nicht zufällig jemanden, der mitmachen will?

Gruß von Algolok

Danke für den Tipp! Evtl. kann ich da ja einige Anregungen gewinnen. Kannte ich noch gar nicht.

Ich gebe dir recht, ohne Vereinbarungen, die man (kennen)lernen muss, kann man mit dem Computer nicht kommunizieren. Ich glaube aber, dass der Einstieg in viele höhere Programmiersprachen schwierig ist und den gelegentlichen Anwender überfrachtet. Zumindest ist das bei mir so. Dies liegt m.E. an der Vermengung von Ablaufsteuerung und auszuführendem Code. Dadurch gibt es eine strenge Syntax und komplexe Semantik.
Beispiel: Die Ermittlung des größten gemeinsamen Teilers in C ist zugegebenermaßen kompakt, wenn man das aber nicht jeden Tag liest, wird es unverständlich:
GGT in C:
int Euklid(int a, int b)
{if (a == 0)
{return b;}
while(b != 0)
{if (a > b)
{a = a - b; }
else
{b = b - a;}
}
return a;}

Hier liegt natürlich die Idee nahe, sich von diesem Ballast zu trennen. In meiner Wunschvorstellung klickt man sich in ALGOLOK den Ablauf zusammen (siehe meinen Avatar), füllt Verzweigungen und Schleife (Fragezeichen) mit den Zustandsprüfungen und stellt sich die benötigten Funktionen (Ausrufezeichen) zusammen. Das ist ja fast selbsterklärend und kann auch von einem Programmierneuling direkt verstanden werden.
Das ist zwar nicht kompakt oder elegant, für meine Wünsche wäre so etwas aber mehr als ausreichend. Ich kann kaum glauben, dass es so etwas noch nicht gibt.

Naja, wie heißt es so schön: Wenn du willst, dass etwas funktioniert, dann mache es eben selbst. Dann mach ich mal!

Schönes Wochenende wünscht
Algolok