Embed Size (px)
Citation preview
Leseprobe zu
EPLAN Electric P8 automatisieren Grundlagen und Beispiele zum Erstellen von Scripten in C#.
Mit sofort einsetzbaren Scripten
von Johann Weiher
ISBN (Buch): 978-3-446-45492-7 ISBN (E-Book): 978-3-446-45712-6 ISBN (E-Pub): 978-3-446-45833-8
Weitere Informationen und Bestellungen unter http://www.hanser-fachbuch.de/978-3-446-45492-7
sowie im Buchhandel © Carl Hanser Verlag, München
Inhalt
1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.1 Toolbars – der erste Schritt zum Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1 Toolbars anpassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.1.2 Schaltflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.1.3 Schaltflächen mit Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.1.4 Schaltflächen mit externen Programmen belegen . . . . . . . . . . . . . 191.1.5 Verschachtelte Toolbars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221.1.6 Toolbars importieren und exportieren . . . . . . . . . . . . . . . . . . . . . . . 27
1.2 Einführung in die Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281.2.1 Was ist eine Entwicklungsumgebung? . . . . . . . . . . . . . . . . . . . . . . . 301.2.2 Projekt in Microsoft Visual C# erstellen . . . . . . . . . . . . . . . . . . . . . 33
2 Scriptfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392.1 Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.1.1 Start . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402.1.2 DeclareAction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512.1.3 DeclareEventHandler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542.1.4 DeclareRegister und DeclareUnregister . . . . . . . . . . . . . . . . . . . . . . 552.1.5 DeclareMenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.2 Actions ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572.2.1 Einzelne Action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572.2.2 Mehrere Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602.2.3 Action mit Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642.2.4 Action überladen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.3 Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692.3.1 String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702.3.2 Integer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 782.3.3 Float . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822.3.4 Fehlerbehandlung – Try und Catch . . . . . . . . . . . . . . . . . . . . . . . . . 84
VI Inhalt
2.3.5 Systemmeldungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 882.3.6 Parameterübergabe: String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 902.3.7 Parameterübergabe: Integer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 922.3.8 MessageBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 932.3.9 Eigene Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
2.4 Programmsteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1002.4.1 If-Abfrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1002.4.2 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1052.4.3 Methoden extrahieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1072.4.4 Decider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1172.4.5 Action mit Rückgabewert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
2.5 Settings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1242.5.1 String-Setting verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1242.5.2 Bool-Setting verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1262.5.3 Integer-Setting verändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1282.5.4 String-Setting lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1292.5.5 Bool-Setting lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1302.5.6 Integer-Setting lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1312.5.7 Import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1322.5.8 Projekteinstellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
2.6 Menüs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1392.6.1 Menüpunkt in Dienstprogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . 1392.6.2 Bestehendes Menü erweitern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1422.6.3 Hauptmenü mit einem Untermenüpunkt . . . . . . . . . . . . . . . . . . . . 1442.6.4 Bestehendes Menü mit Popup-Menü erweitern . . . . . . . . . . . . . . . 1452.6.5 Hauptmenü mit Popup-Menü . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1462.6.6 Menüpunkt in Kontextmenü . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
2.7 Progressbar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1522.7.1 SimpleProgress . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1522.7.2 EnhancedProgress . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
2.8 Formulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1582.8.1 Vorlage erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1582.8.2 Button . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1642.8.3 Checkbox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1692.8.4 Label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1722.8.5 TabIndex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1732.8.6 Progressbar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1742.8.7 Mauszeiger ändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1762.8.8 ListView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
2.9 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Inhalt VII
3 Schnittstellen programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . 1993.1 Externe Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
3.1.1 Prozess ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1993.1.2 Unterschiedliche Prozesse ausführen . . . . . . . . . . . . . . . . . . . . . . . 201
3.2 Dateien und Ordner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2063.2.1 Ordner prüfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2063.2.2 Dateien prüfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2073.2.3 Dateien löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2093.2.4 Dateien mit Datumsstempel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
3.3 Dateien öffnen und speichern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2113.3.1 SaveFileDialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2113.3.2 OpenFileDialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2143.3.3 Dateinamen überprüfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2173.3.4 FileSelectDecisionContext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
3.4 Dateien schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2223.4.1 Beschriftung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2223.4.2 Beschriftung mit Überprüfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2283.4.3 PDF beim Schließen erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2343.4.4 Textdatei schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2393.4.5 XML-Datei schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
3.5 Dateien lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2453.5.1 Textdatei lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2453.5.2 XML-Datei lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2513.5.3 XML-Datei lesen (eigene Klasse) . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
3.6 Befehlszeile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2603.6.1 Allgemeine Befehlszeilenparameter . . . . . . . . . . . . . . . . . . . . . . . . . 2603.6.2 Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
3.7 EplanRemoteClient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
4 Praxisbeispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2694.1 Compress . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
4.2 ChangeLayer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
4.3 Edit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
4.4 ExecuteScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
4.5 Print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
4.6 ProjectAction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
4.7 XEsSetProjectPropertyAction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
4.8 Backup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
VIII Inhalt
4.9 Restore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
4.10 ProjectManagement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
4.11 SelectionSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
5 Anhang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2875.1 Daten zum Buch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
5.2 Internetseiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
Liebe Leserinnen und liebe Leser,
mit diesem Buch möchte ich Ihnen einen einfachen und unkomplizierten Einstieg in die Erstellung von Scripten für EPLAN Electric P8 ermöglichen. Das Buch rich-tet sich an alle EPLAN-Anwender, ganz gleich, ob es sich dabei um regelmäßige oder sporadische Konstrukteure handelt, die mithilfe von Scripting ihre Aufgaben automatisieren wollen. Programmierkenntnisse werden nicht vorausgesetzt. Sie werden erstaunt sein, wie schnell dabei ein Resultat zustande kommt, das Sie be-geistert. Schon mit einem kleinen Script, das aus nur ein paar Zeilen besteht, kön-nen Sie viel Zeit bei der Projektierung sparen. Auf Grundlage der im Buch vermit-telten Informationen werden Sie rasch imstande sein, EPLAN-Aktionen zu verwenden und gegebenenfalls zu erweitern. Darüber hinaus lernen Sie auch, ei-gene Erweiterungen zu programmieren. Scripte können ab der Version EPLAN Electric P8 Compact genutzt werden. Das API-Modul ist dafür nicht erforderlich.
Im Script, wie in der Programmierung selbst, ist vieles, wenn nicht sogar alles, mög-lich. Deshalb stellt sich die Frage, in welchem Umfang dieses Buch das Themenfeld abdecken kann. Die Sprache C#, die ich zum Erstellen der Scripte verwende, ist sehr komplex und mit ihrer Beschreibung allein könnte man mehrere Tausend Seiten füllen, ohne irgendeine EPLAN-Funktion zu erklären. Aus diesem Grund beschränke ich mich darauf, die Grundlagen von C# zu vermitteln, die notwendig sind, um neue Scripte zu erstellen oder bestehende zu erweitern bzw. zu verändern. Auch auf die wichtigsten Erweiterungen durch eigenen Programmcode gehe ich ein.
Alle EPLAN-Aktionen werden anhand von praxisnahen Beispielen beschrieben und erklärt. Viele der Beispiele werden Ihren Workflow beschleunigen. Hinzu kommt, dass mehr Zeit für die wesentlichen Aufgaben, nämlich die der Konstruk-tion, bleibt. Jeder kennt die wiederkehrenden, monotonen Aufgaben, die z. B. beim Projektabschluss anstehen. Viele Auswertungen und Beschriftungen müssen er-zeugt werden, zusätzlich muss der Plan als PDF erstellt werden. All dies können Sie per Knopfdruck erledigen. Wie? Das wird Schritt für Schritt im Buch erklärt.
Vorwort
2 Vorwort
Auf der Internetseite https://eep8a.de finden Sie das komplette Projekt mit allen Beispielen und fertigen Scripten, welche Sie direkt in EPLAN verwenden können.
An dieser Stelle möchte ich mich recht herzlich bei allen bedanken, die mir gehol-fen haben, dieses Buch zu schreiben.
Allen voran danke ich meiner Frau Daniela für die Motivation, das Buch zu schreiben, und die Unterstützung, um genügend Zeit zu finden. Vielen Dank auch an meine wundervollen Töchter Leni & Fina für die erfreulichen Unterbrechungen und Ablenkungen beim Schreiben.
Großer Dank geht an meinen Chef, Kollegen und Freund Michael Kastl für die Frei-heit, dieses Buch zu schreiben. Es macht einfach Spaß, mit dir zu arbeiten.
Ein besonderer Dank gilt Florian Reiter – hier ist aus einem Berater ein Freund geworden. Ein großes Lob möchte ich auch Herrn Andreas Krämer für die immer sehr guten Hilfestellungen aussprechen.
Zu guter Letzt möchte ich mich bei Julia Stepp vom Carl Hanser Verlag für die Hilfe und Unterstützung bedanken.
Johann Weiher
Dürnhart, im Mai 2018
Was ist Scripting?Scripting bezeichnet die Möglichkeit, einzelne Befehle bzw. Programmcode in EPLAN auszuführen. Dies geschieht über die sogenannte API (Application Program-ming Interface, dt. Programmierschnittstelle). Hinter der EPLAN-API verbergen sich alle Funktionen, die in der Plattform (Electric P8, Fluid, Pro-Panel usw.) vorhanden sind. Diese Programme bauen alle auf dem gleichen Programmcode auf und sind dadurch untereinander kompatibel. In den verschiedenen Applikationen sind ähnli-che bzw. gleiche Funktionen enthalten, z. B. kann man Beschriftungen sowohl in Fluid als auch in Electric P8 erzeugen. Einziger Unterschied ist der Inhalt.
Diese Abläufe werden in EPLAN Actions (Aktionen) genannt. Ihnen ist Ab-schnitt 2.2, „Actions ausführen“, gewidmet, da es mehrere Wege gibt, solche Ac-tions auszuführen. Das Wort Scripting bezieht sich meistens nur auf Scripte, die Sie ab der Ausbaustufe EPLAN Electric P8 Compact nutzen können. Um weitere Befehle oder Funktionen ausführen zu können, benötigen Sie das API-Modul von EPLAN. In diesem Buch gehe ich aber ausschließlich auf den Standardumfang der Compact-Version ein.
Was sind Scripte?Scripte sind kleine Programmcodes. In EPLAN können diese in zwei Programmier-sprachen erstellt werden:
� Microsoft C# (C-Sharp) � Microsoft VB.NET (Visual Basic.NET)
Ich werde in den folgenden Kapiteln nur Beispiele in C# bereitstellen, da EPLAN mit dieser Sprache fertigen Code generiert und dadurch eine optimale Vorlage lie-fert. Ein Script ist nicht alleine ausführbar. Es muss in Verbindung mit EPLAN ge-startet werden.
1 Einführung
4 1 Einführung
Was können Scripte?Scripte können vieles, aber nicht alles. EPLAN stellt eine Reihe von Befehlen be-reit, schränkt diese aber auf einen überschaubaren Bereich ein. Dadurch wird dem Anwender der Einstieg enorm erleichtert. Auf diese Weise wird auch sichergestellt, dass keine ungewollten Aktionen, z. B. auf das Projekt, ausgeführt werden.
Sicherlich kennen Sie die wiederkehrende Aufgabe, Beschriftungen auszugeben. Je Projekt sind mehrere Exporte nötig. Jedes Mal muss das Beschriftungsschema neu ausgewählt, zusätzlich der Ordner benannt und ein Dateiname vergeben werden. Mit einem Script können Sie all diese Arbeitsschritte zusammenfassen und z. B. auf einen Menüpunkt legen. Sie können über diese Funktion auch mehrere Be-schriftungen nacheinander erzeugen. Auch der PDF-Export kann automatisiert werden. Möchten Sie z. B. beim Schließen des Projekts automatisch ein PDF zur Änderungsverfolgung erzeugen? Mit einem Script lässt sich dies problemlos reali-sieren. Sie wollen Schnittstellen schaffen und Informationen außerhalb von EPLAN, z. B. in Ihrem ERP-System, nutzen? Gar kein Problem! Über die Möglich-keiten im Scripting geht das auf Knopfdruck. Oft muss zwischen verschiedenen Einstellungen hin und her gewechselt werden. Das Suchen in den unzähligen Ein-stellungen in EPLAN ist mühselig. Schreiben Sie stattdessen ein Script für Ihre Konfigurationen und erledigen Sie dies unter der Projektierung.
Dies ist eine kleine Auflistung der Möglichkeiten, die mit Scripten realisiert wer-den können:
� Beschriftungen automatisieren � PDF-Export � Backup � Eigene Menüs/Toolbars erstellen � Grafische Formulare, z. B. mit Buttons, Checkboxen und Auswahldialogen, erstel-len
� Eigenschaften verändern � Projekteigenschaften � Seiteneigenschaften
� Einstellungen � Lesen � Schreiben
51.1 Toolbars – der erste Schritt zum Script
Und das sind noch längst nicht alle Funktionen! Durch das Erweitern des Pro-grammcodes können noch mehr Funktionen hinzugefügt werden.
Was kann das API-Modul im Vergleich zum Scripting?Um den Unterschied etwas deutlicher zu machen, finden Sie im Folgenden eine kleine Auflistung der wichtigsten Merkmale des API-Moduls in EPLAN:
� Zugriff auf das komplette EPLAN-Datenmodell � Einfacheres Lesen von Objekten � Zugriff auf mehr Objekte � Direkter Zugriff auf Projekteigenschaften/Projekteinstellungen � Lesen/Schreiben von Daten in der Artikeldatenbank � Mehr verfügbare Actions
� 1.1 Toolbars – der erste Schritt zum Script
1.1.1 Toolbars anpassen
In EPLAN gibt es die Möglichkeit, eigene Toolbars zu erstellen. Doch was hat das mit Scripting zu tun? Ein Script ist eigentlich eine Erweiterung der Funktionalität einer Symbolleiste. In einer benutzerdefinierten Toolbar können vordefinierte Be-fehle ausgeführt werden. Dies sind alle von EPLAN offiziell unterstützten Actions, welche zudem in der Hilfe dokumentiert sind. Einen Verweis zur Hilfe finden Sie in Kapitel 5. Diese Befehle werden auch in einem Script verwendet. Ein Vorteil des Scripts gegenüber der klassischen Toolbar ist, dass mehrere Actions ausgeführt werden können. In der Symbolleiste müsste man mehrere Schaltflächen erstellen, um zum gleichen Ergebnis zu kommen. Bei der Menge an Möglichkeiten wird der Arbeitsbereich schnell unübersichtlich.
Im Folgenden wollen wir eine neue Toolbar erstellen. Dazu führen wir einen Rechtsklick auf die grafische Oberfläche aus und wählen den Punkt Anpassen … im Kontextmenü an (Bild 1.1).
� 2.1 Attribute
Ein Script kann, wie wir schon in Kapitel 1 erfahren haben, verschiedenste Funk-tionen ausführen. Darum müssen Sie im Programmcode hinterlegen, welche Funk-tion das Script bereitstellt. Es können auch mehrere Actions in einem Script vor-handen sein. Sie können z. B. eine Beschriftung automatisch erzeugen lassen. Außerdem kann für diese Action ein eigener Menüpunkt in der Menüleiste erzeugt werden. Dies ist alles innerhalb einer Datei möglich. In diesem Fall macht das auch Sinn, da der Menüpunkt nicht ohne die dazugehörige Action ausgeführt werden kann. Es macht aber keinen Sinn, alle Actions in eine Datei zu packen, da es so schnell unübersichtlich wird.
Für unser erstes Beispiel verwenden wir das Attribut [Start]. Das ist der schnellste Weg, mehrere Scripte zu testen. Oftmals stellt sich die Frage, wann ein Script ge-laden und was ausgeführt werden muss. Über die Attribute können Sie dies schnell und einfach herausfinden. Dies ist eine Auflistung der Attribute fürs Ausführen und Laden:
� Ausführen: � [Start]
� Laden: � [DeclareAction]
� [DeclareEventHandler]
� [DeclareMenu]
� [DeclareRegister]
� [DeclareUnregister]
2 Scriptfunktionen
40 2 Scriptfunktionen
Bild 2.1 Scripte ausführen/laden/entladen
2.1.1 Start
Das Attribut [Start] wird meistens verwendet, wenn man ein Script nur einmal oder eher selten benötigt. Sie müssen bei jedem Starten der Action über die Menü-leiste gehen, um das Script auszuführen.
In der Entwicklungsumgebung wechseln Sie ins Codefenster und betrachten die ersten Zeilen. Führen Sie hierfür einen Doppelklick auf die Datei 01_Start.cs aus.
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;
Mit dem Befehl using beschreiben Sie, welche Verweise verwendet werden sollen. In einer sogenannten Using-Direktive werden bestimmte Programmbefehle ge-
412.1 Attribute
speichert und können, sofern sie geladen sind, abgerufen werden. Für das erste Script sind folgende Verweise erforderlich:
� System.Windows.Forms � Eplan.EplApi.Scripting
Es werden nicht immer alle Verweise benötigt. Dennoch ist es ratsam, eine Vorlage zu erstellen, die alle für Sie wichtigen Using-Direktiven enthält. Später können Sie nicht benötigte Elemente entfernen. Folgende Namespaces werden im Scripting häufig verwendet:
� Eplan.EplApi.ApplicationFramework � Eplan.EplApi.Base � Eplan.EplApi.Scripting
Beim Tippen des Codes erscheint ein kleiner Dialog mit verschiedenen Begriffen (Bild 2.2). Diesen Dialog nennt man IntelliSense. Es ist eine Möglichkeit zur Wort-vervollständigung einzelner Begriffe in der Programmierung. Das von Microsoft entwickelte Hilfsmittel ist in fast allen Entwicklungsumgebungen für sämtliche Programmiersprachen vorhanden. Wenn Sie einen Begriff eingeben, werden über-einstimmende Ergebnisse angezeigt. Sie können nun mit den Pfeiltasten auf der Tastatur den gewünschten Begriff auswählen. Um das Getippte zu vervollständi-gen, drücken Sie auf die Tab-Taste. Ist der IntelliSense nicht sichtbar, kann der Dialog mit dem Tastatur-Shortcut Strg + Leertaste wieder eingeblendet werden.
Bild 2.2 IntelliSense
Eine Code-Folge wird in C# immer mit einem Semikolon (;) beendet. Wer schon einmal in Visual Basic programmiert hat, weiß, dass es dort der Zeilenumbruch ist. In C# können Sie beliebig viele Zeilenumbrüche im Code einfügen.
Den Aufbau eines Programmcodes in C# können Sie sich vorstellen wie eine Zwie-bel (Bild 2.3). Es gibt verschiedene Schichten, die mit geschweiften Klammern ein-gegrenzt werden. Der Aufbau ist allerdings nicht so kompliziert, dass die Zwiebel Sie zum Weinen bringen wird.
42 2 Scriptfunktionen
Bild 2.3 Aufbau des Programmcodes in C#
Die „äußere Schale“ ist der Namespace:
namespace Namespace{}
Die „mittlere Schale“ ist die Klasse (Class):
class Class{}
In einer Klasse muss mindestens eine Funktion vorhanden sein. Man spricht hier von Methoden. Methoden werden mit void gekennzeichnet. Ergänzen Sie den Pro-grammcode um folgende Zeilen:
void Function(){}
In der Funktion steht nun der eigentliche Programmcode (Was soll EPLAN tun?).
Wir lassen eine MessageBox anzeigen, um festzustellen, ob unser Script aus-geführt wurde. Dies ist der Aufbau des Befehls in kurzen Worten:
� Was soll ich machen? → MessageBox � Was soll ich damit anstellen? → Show (anzeigen) � Was soll ich anzeigen? → Ich kann scripten!
Die einzelnen Klassen und Methoden werden durch einen Punkt getrennt. Stellen Sie sich hierzu eine Treppe vor. Auf jeder Ebene befinden sich andere Räume mit unterschiedlichen Funktionen. Zu Beginn findet man oft nicht sofort die gewünschte Funktion, aber mit der Zeit versteht man die Struktur des .NET Frameworks.
Beispielaufbau eines Methodenaufrufs:
Ebene0.Ebene1.Ebene2.Methode();
432.1 Attribute
Nehmen wir als Beispiel eine Aktivität an einem Ort, müsste dies wie folgt angege-ben werden:
München.Theresienwiese.Oktoberfest.Achterbahnfahren();
Text steht im Programmcode immer in Hochkommas (“Anführungszeichen”):
München.Bahnhof.Schaffner.Ruft(“Alles einsteigen!”);
Kommentare können mit zwei Schrägstrichen eingefügt werden:
// Ich bin ein Kommentar
Dadurch weiß das Programm, dass es sich um einen Kommentar handelt, der nicht abgearbeitet werden muss.
In Visual Studio gibt es fertige Buttons für das Einfügen von Kommenta-ren. Ist diese Toolbar nicht sichtbar, können Sie diese, wie in Bild 2.4 dargestellt, einblenden. Es wird dann die komplette Zeile, welche gerade aktiv ist, ein- bzw. auskommentiert.
Bild 2.4 Toolbar Text-Editor einblenden
44 2 Scriptfunktionen
Um eine MessageBox anzuzeigen, ist folgender Code notwendig:
MessageBox.Show(“Ich kann scripten!”); // Kommentar
Eine Funktion wird mit return (zurückkehren) abgeschlossen. Dies ist nicht zwin-gend notwendig, wenn jeder Teil des Programmcodes Werte zurückgibt.
return;
Nicht verwendete Verweise sollten Sie entfernen, um das Starten des Scripts zu beschleunigen. Durch einen rechten Mausklick und das Ausführen der Funktion Using-Direktiven organisieren > Entfernen und Sortieren in Visual Studio ge-schieht dies automatisch (Bild 2.5).
Bild 2.5 Using-Direktiven organisieren
452.1 Attribute
Nun setzen wir unsere „Schalen“ zusammen. Das komplette Beispiel ist immer am Ende einer Lektion zu finden:
using Eplan.EplApi.Scripting;using System.Windows.Forms; namespace Namespace{ public class Class { [Start] public void Function() { MessageBox.Show(“Ich kann scripten!”); // Kommentar return; } }}
Wechseln Sie nun nach EPLAN und testen Sie das Script über Dienstprogramme > Scripte > Ausführen …. Im darauffolgenden Dialog wählen Sie das Script aus. Die Scriptdatei befindet sich im Ordner Ihres Visual-Studio-Projekts (Bild 2.6).
Bild 2.6 Script ausführen
46 2 Scriptfunktionen
Wurde der Programmcode fehlerfrei ausgeführt, sehen Sie den in Bild 2.7 dargestell-ten Dialog.
Bild 2.7 MessageBox
Beim Schreiben des Programmcodes können mehrere Fehler passieren. Kommen-tieren Sie testweise die Initialisierung der Using-Direktiven aus:
//using System.Windows.Forms;//using Eplan.EplApi.Scripting;
Vielleicht ist Ihnen beim Auskommentieren der Using-Anweisungen aufgefallen, dass im Fehlerfenster von Visual Studio einige Fehler hinzugekommen sind. Dies resultiert aus der Tatsache, dass die Entwicklungsumgebung die Ausdrücke auf-grund fehlender Verweise nicht finden kann. Diese Fehlerliste ist ähnlich wie die Meldungsverwaltung von EPLAN aufgebaut (Bild 2.8). Hier wird ebenfalls unter-schieden zwischen:
� Fehlern � Warnungen � Mitteilungen
Bild 2.8 Fehlerliste
Ist das Fenster aus Bild 2.8 nicht sichtbar, können Sie es über Ansicht > Fehler-liste einblenden (Bild 2.9).
472.1 Attribute
Bild 2.9 Fehlerliste einblenden
Fehler: Using-DirektiveEs kann sein, dass Fehler in Visual Studio nicht auftreten, jedoch beim Ausführen/Starten des Scripts in EPLAN gefunden werden. Ist dies der Fall, werden sie in den Systemmeldungen angezeigt (Bild 2.10). EPLAN beachtet dabei nicht, welche Using-Direktiven intern schon bekannt waren. Ist ein anderer Fehler im Script vor-handen, werden diese (fehlerhafterweise) auch angezeigt, können aber guten Ge-wissens ignoriert werden.
48 2 Scriptfunktionen
Bild 2.10 Fehler: Using-Direktive wurde bereits zuvor verwendet.
In den Systemmeldungen in Bild 2.10 werden folgende Fehler angezeigt:
1. Compilerfehler: Information, dass das Script einen Fehler verursacht hat
2. Die Using-Direktive wurde bereits zuvor in diesem Namespace verwendet.
3. Die Using-Direktive wurde bereits zuvor in diesem Namespace verwendet.
4. Semikolon erwartet: Dies ist der eigentliche Fehler, den Sie als einzigen im Script korrigieren müssen. Danach wird das Script korrekt ausgeführt.
5. Das Script konnte nicht compiliert werden.
Um eventuell auftretende Fehler schnell zu finden, können Sie über die Optionen in Visual Studio auch die Zeilennummern einblenden, falls diese noch nicht sichtbar sind (Bild 2.11 und Bild 2.12).
492.1 Attribute
Bild 2.11 Optionen in Visual Studio
Bild 2.12 Anzeigen der Zeilennummern aktivieren
50 2 Scriptfunktionen
Semikolon erwartetGerade am Anfang vergisst man öfter mal, den Code mit einem Semikolon ab-zuschließen. Wenn Sie die Fehlerliste eingeblendet haben, können Sie dies schon vor dem Ausführen in EPLAN sehen. Im Code-Fenster wird die Stelle rot unterstri-chen (Bild 2.13).
Bild 2.13 Visual Studio: Semikolon erwartet
Auch EPLAN überprüft den Code, bevor dieser geladen oder ausgeführt wird (Bild 2.14).
Bild 2.14 EPLAN: Semikolon erwartet
Scriptdatei nicht gefundenWenn Sie auf Dateiebene den Dateinamen eines Scripts ändern oder es löschen, weiß EPLAN davon nichts. Darum bekommen Sie in diesem Fall auch einen Fehler in den Systemmeldungen angezeigt (Bild 2.15). Bei jedem Start von EPLAN werden die Scripte überprüft. Das Script muss entladen und neu geladen werden. Dies ist nur notwendig, wenn ein Script geladen wurde (wie in Abschnitt 2.1.2, „DeclareAction“).
1392.6 Menüs
Bei bestimmten Projekteinstellungen kann es dazu kommen, dass diese zwar ge-setzt werden, EPLAN diese jedoch nicht als Änderung feststellt. Tritt dieses Fehl-verhalten z. B. beim Ändern des Normblatts auf, müssen Sie folgenden Programm-code hinzufügen:
new EventManager().Send(“PageManagement.ProjectSettings.Changed”, new EventParameterString());
� 2.6 Menüs
Wie bereits zu Beginn des Buches beschrieben, können in EPLAN eigene Menüs erzeugt werden. Es gibt mehrere Arten von Menütypen, welche unterschiedliche Funktionen haben:
� Menüpunkt in Dienstprogrammen � Menüpunkt in einem bestehenden Menü � Hauptmenü mit einem Menüpunkt � Popup-Menü
Jedem neu hinzugefügten Menüpunkt muss eine Action zugewiesen werden. Dies kann eine EPLAN-Action oder eine eigene Action sein. In den folgenden Beispielen werden wir immer die Action mit dem Namen MenuAction verwenden. Es darf kein anderes Script mit dieser Action vorhanden sein, wenn das Script in EPLAN ge-laden wird.
Wird ein Menü-Script entladen, wird das Menü nicht immer entfernt. Auch bei Änderungen werden diese oft nicht übernommen, oder das Menü enthält doppelte Einträge. Tritt eines dieser Probleme auf, müssen Sie EPLAN neu starten.
2.6.1 Menüpunkt in Dienstprogramme
Erstellen Sie ein neues Script mit dem Namen 01_Menüpunkt_in_Dienstpro-gramme.cs und zusätzlich einen neuen Ordner für das Abschnitt Menüs ( 06_Menüs). Als Attribute benötigen wir [DeclareAction(“MenuAction”)] für die Action und [DeclareMenu] für den dazugehörigen Menüpunkt.
Unsere Action soll nur eine MessageBox mit dem Text Action wurde ausgeführt! an-zeigen, um die Funktionalität zu testen. Erstellen Sie die folgenden zwei Funktionen:
� ActionFunction(): Hier wird die Action für das Menü bereitgestellt. � MenuFunction(): Hier wird das Menü erzeugt und die Action aufgerufen.
140 2 Scriptfunktionen
[DeclareAction(“MenuAction”)]public void ActionFunction(){ MessageBox.Show(“Action wurde ausgeführt!”); return;}
In der neuen Funktion MenuFunction() erstellen wir nun ein Objekt der Klasse Menu, das im EPLAN-Namespace zu finden ist:
Eplan.EplApi.Gui.Menu menu = new Eplan.EplApi.Gui.Menu();
Es ist notwendig, den kompletten Namespace zur Klasse zu hinterlegen, da es z. B. in System.Windows.Forms auch eine Klasse Menu gibt.
Um einen einfachen Menüpunkt unter dem Dienstprogramm zu erstellen, nutzen wir die Methode AddMenuItem(). Dadurch wird das Menü Dienstprogramme durch den angegebenen Menüpunkt ergänzt. Die Methode besitzt folgende Eigenschaften:
� Name Menüpunkt � Name Action
Als Actionnamen tragen Sie die zuvor initialisierte MenuAction ein:
menu.AddMenuItem( “Menüpunkt am Ende von Dienstprogramme”, // Name: Menüpunkt “MenuAction” // Name: Action );
Sie können diesen Programmcode auch in einer Zeile schreiben. Wegen der bes-seren Lesbarkeit habe ich den Code hier aufgeteilt.
HINWEIS: Der Action können auch gleich die Parameter mitgegeben werden (ähnlich wie bei einer ToolbarBefehlszeile).
Da bei späteren Methoden nicht immer klar ist, für was eine Eigenschaft zuständig ist, füge ich die Beschreibung immer als Kommentar hinzu.
Wie schon beschrieben, ist es bei Menü-Scripten wichtig, diese zu laden. Haben Sie alles richtig gemacht, erscheint ein neuer Menüpunkt unter Dienstprogramme (Bild 2.99).
1412.6 Menüs
Bild 2.99 Neuer Menüpunkt unter Dienstprogramme
Das komplette Script sieht wie folgt aus:
using System.Windows.Forms;using Eplan.EplApi.Scripting; public class _06_Menues_01_Menuepunkt_in_Dienstprogramme{ [DeclareAction(“MenuAction”)] public void ActionFunction() { MessageBox.Show(“Action wurde ausgeführt!”); return; } [DeclareMenu] public void MenuFunction() { Eplan.EplApi.Gui.Menu menu = new Eplan.EplApi.Gui.Menu(); menu.AddMenuItem( “Menüpunkt am Ende von Dienstprogramme”, // Name: Menüpunkt “MenuAction” // Name: Action ); return; }}
142 2 Scriptfunktionen
2.6.2 Bestehendes Menü erweitern
Für die zweite Variante der Menü-Klasse kopieren Sie das erste Script und verge-ben den Namen 02_Bestehendes_Menü_erweitern.cs. Lassen Sie die erste Funk-tion unberührt, und verändern Sie nur die Methode des Menü-Objekts.
Damit ein bestehendes Menü erweitert werden kann, steht die Methode AddMenuItem() bereit. Folgende Eigenschaften stehen zur Verfügung:
� Name Menüpunkt � Name Action � Statustext � Menü-ID � Hinter/vor Menüpunkt
Der Statustext wird in der Fußzeile von EPLAN angezeigt und kann eine längere Beschreibung enthalten (Bild 2.100).
Bild 2.100 Statustext
Die Menü-ID (Integer) dient als Referenz-Menüpunkt, um die Position festzulegen. Über den Diagnose-Dialog (Strg + ^) können wir nach dem Aufrufen des Menü-punkts die Menü-ID herausfinden. Führen Sie dazu zuerst Einfügen > Fensterma-kro aus und öffnen dann den Diagnose-Dialog (Bild 2.101).
Bild 2.101 Menü-ID über den Diagnose-Dialog herausfinden
1432.6 Menüs
Mit der letzten Eigenschaft können Sie festlegen, ob der neue Menüpunkt vor oder hinter dem Referenz-Menüpunkt eingefügt werden soll:
� 1: hinter Menüpunkt � 0: vor Menüpunkt
Die beiden letzten Überladungen „Separator davor/dahinter“ zeigen eine Trenn-linie im Menü an. Dieser boolesche Wert hat die bekannten Zustände true oder false.
Ändern Sie das Script wie folgt:
using System.Windows.Forms;using Eplan.EplApi.Scripting; public class _06_Menues_02_Bestehendes_Menue_erweitern{ [DeclareAction(“MenuAction”)] public void ActionFunction() { MessageBox.Show(“Action wurde ausgeführt!”); return; } [DeclareMenu] public void MenuFunction() { Eplan.EplApi.Gui.Menu menu = new Eplan.EplApi.Gui.Menu(); menu.AddMenuItem( “Bestehendes Menü erweitern”, // Name: Menüpunkt “MenuAction”, // Name: Action “Statustext”, // Statustext 37024, // MenüID: Einfügen/Fenstermakro … 1, // 1 = hinter Menüpunkt, 0 = vor Menüpunkt false, // Separator davor anzeigen false // Separator dahinter anzeigen ); return; }}
Stellen Sie sicher, dass kein Script geladen ist, und laden Sie die neue Datei. Nach dem Eintrag Einfügen > Fenstermakro erscheint nun ein neuer Untermenüpunkt (Bild 2.102).
Bild 2.102 Bestehendes Menü erweitern
144 2 Scriptfunktionen
2.6.3 Hauptmenü mit einem Untermenüpunkt
Kopieren Sie das Script erneut und vergeben den Namen 03_Hauptmenü_mit_Un-termenüpunkt.cs. Die erste Methode lassen Sie unverändert, da die Action erneut aus-geführt wird. In diesem Beispiel erzeugen Sie ein neues Hauptmenü in der EPLAN-Oberfläche. Zusätzlich müssen Sie diesem Menü einen Menüpunkt hinzufügen.
Dafür verwenden Sie die Methode AddMainMenu() mit folgenden Eigenschaften:
� Name Menü � Neben Menüpunkt � Name Menüpunkt � Name Action � Statustext � Hinter/vor Menüpunkt
Mit neben Menüpunkt geben Sie an, an welcher Stelle das Menü eingefügt wird. Es handelt sich hier um eine sogenannte Enumeration, welche immer eine feste Auf-listung ist. Alternativ können Sie einen String angeben, der den Menünamen trägt.
Zusätzlich können Sie festlegen, ob das Menü davor oder dahinter platziert werden soll:
� hinter Hauptmenüpunkt: 1 � vor Hauptmenüpunkt: 0
Möchten Sie z. B. das Menü an erster Stelle erzeugen, müssten Sie „Projekt“ und „0“ angeben.
Es ist allerdings ratsam, die Reihenfolge der Grundeinstellung von EPLAN nicht zu verändern. Sonst finden sich andere User meist nicht so schnell zurecht. Aus die-sem Grund füge ich neue Menüs immer hinter dem Menü Hilfe ein.
menu.AddMainMenu( “Menü 1”, // Name: Menü Eplan.EplApi.Gui.Menu.MainMenuName.eMainMenuHelp, // neben Menüpunkt “Hauptmenü mit einem Menüpunkt”, // Name: Menüpunkt “MenuAction”, // Name: Action “Statustext”, // Statustext 1 // 1 = hinter Menüpunkt, 0 = vor Menüpunkt );
Stellen Sie sicher, dass kein Script geladen ist, und laden Sie die neue Datei. Nun er-scheint ein neues Hauptmenü mit dem Namen Menü 1 auf der Oberfläche (Bild 2.103).
Bild 2.103 Eigenes Hauptmenü
1452.6 Menüs
Das komplette Script sieht so aus:
using System.Windows.Forms;using Eplan.EplApi.Scripting; public class _06_Menues_02_Bestehendes_Menue_erweitern{ [DeclareAction(“MenuAction”)] public void ActionFunction() { MessageBox.Show(“Action wurde ausgeführt!”); return; } [DeclareMenu] public void MenuFunction() { Eplan.EplApi.Gui.Menu menu = new Eplan.EplApi.Gui.Menu(); menu.AddMenuItem( “Bestehendes Menü erweitern”, // Name: Menüpunkt “MenuAction”, // Name: Action “Statustext”, // Statustext 37024, // MenüID: Einfügen/Fenstermakro … 1, // 1 = hinter Menüpunkt, 0 = vor Menüpunkt false, // Separator davor anzeigen false // Separator dahinter anzeigen ); return; }}
2.6.4 Bestehendes Menü mit Popup-Menü erweitern
Kopieren Sie das erste Beispiel aus Abschnitt 2.6, „Menüs“. Vergeben Sie den Na-men 04_Bestehendes_Menü_mit_Popup-Menü_erweitern.cs. EPLAN verfügt über die Möglichkeit, ein Popup-Menü zu erstellen. Dies ist ein geschachteltes Steuerele-ment. Es können mehrere Menüpunkte hinter einem Popup-Menü erstellt werden.
Das Popup-Menü funktioniert ähnlich wie die Erweiterung eines bestehenden Me-nüs. Es kommt jedoch der Name des Menüs als Überladung hinzu. Im folgenden Beispiel wird ein Popup-Menü mithilfe der Methode AddPopupMenuItem() unter Ein-fügen erstellt (Bild 2.104):
using System.Windows.Forms;using Eplan.EplApi.Scripting; public class _06_Menues_04_Bestehendes_Menue_mit_Popup_Menue_erweitern{ [DeclareAction(“MenuAction”)]
Symbole
.NET 28, 29
A
Action 3, 39ActionCallingContext 65Addition 79API 3, 5Arbeitsbereich 8Argumente 20Attribut 54Ausführen 39Automatisiert bearbeiten 222
B
Backup 277Befehlszeile 57, 260Benutzereinstellungen 124Beschriftung 222Betriebsmittel 272Bild 14Button 6, 167Bytecode 30
C
C# 29, 31, 37, 41Case 105Catch 84Checkbox 6, 169CommandLineInterpreter 57
Compiler 30Compilerfehler 48Compress 269Console 264ContextMenuLocation 151CSV 239Cursor 176
D
Dateiauswahl 219Datum 209Debugging 192Decider 117, 219DeclareAction 39, 52DeclareEventHandler 39, 54DeclareMenu 39, 139DeclareRegister 39, 55DeclareUnregister 39, 55Devicelist 271Diagnose-Dialog 54Dialog Toolbar anpassen 13Division 79
E
Ebenen 271Edit 272Einstellungen 124EnhancedProgress 156Entwicklungsumgebung 31EnumDecisionReturn 117EplanRemoteClient 264Ereignis 234
Index
294 Index
Escapezeichen 203Event 234ExecuteScript 273Externe Programme 20
F
Fehler 46, 194FileSelectDecisionContext 219Flache Schaltflächen 7Float 82Forms 158Formular 159Funktion 42
G
GetBoolSetting() 130GetNumericSetting() 131
H
Haltepunkt 193
I
Icon 6, 119Integer 78IntelliSense 41, 116
K
Klassen 96Kommentare 43Konsolen-App 264Konstruktor 98Kontextmenü 148
L
Label 172Laden 39Lambda 264LINQ 264ListView 177
M
Mauszeiger 176Meldungen 46Menü 139Menü-ID 146Menüpunkt 139MessageBox 42, 93, 117Multiplikation 79
O
Objekte 69Objektorientierte Programmierspra-
che 96Objektorientierte Programmierung 69OpenFileDialog 214, 220Operator 101out 122
P
Parameter 16, 64, 260PathMap 173PDF 199, 234Pfadvariable 77Popup-Menü 139, 145, 147Print 274Programmierschnittstelle 3Progressbar 174ProjectAction 275projectmanagement 281Projekteigenschaften 251, 276Prozess 192, 199
Q
QuickInfo 7
R
ReadSettings 132ref 122region 160Reguläre Ausdrücke 217
295Index
Restore 279Rückgabewert 122
S
SaveFileDialog 211, 219Schaltflächen 10Schnellaktion 97, 109Script 39selectionset 284Semikolon 41, 48SetBoolSetting() 127SetNumericSetting() 128SetStringSetting() 124Settings 124SimpleProgress 153Sonderzeichen 246Start 39Steuerzeichen 70String 70Subtraktion 79Switch 105Syntax 30Systemmeldungen 48
T
Tab 6TabIndex 173TabStop 173Text 70Textdatei 239Toolbar 5, 53Try 84
U
Umlaute 246Unicode 246Unterdrückte Dialoge 120Using-Direktive 46, 47
V
Variante 18VB.NET 3Verknüpfung 260Verweise 41Visual Studio 32
W
W3C 241Warnungen 46
X
XML 241
Z
Zeilenumbruch 71, 73
