Ich habe ja schon beschrieben wie man die COM-Schnittstelle von EPLAN nutzen kann. Nun ist es aber wichtig zu wissen dass diese in 32bit und 64bit vorliegt.
Die zuerst gestartete EPLAN Instanz startet auch den COM-Server in der jeweiligen Variante.
Somit ist zu beachten dass für 64bit EPLAN eure Applikation auch in 64bit kompiliert werden muss.
Ich habe mehrere EPLAN-Versionen im Einsatz somit habe ich auch verschiedene (eigene) Applikationen installiert.
Ist gibt immer Technologien welche man nicht mag… denke bei mir ist es Drag & Drop.
Finde es als Bedienkonzept sehr gut, da man hierdurch die User-Experience erhöhen kann.
Aber zum programmieren ist es nicht schön.
GongSolutions.WPF.DragDrop nimmt hier viel Arbeit ab und funktioniert mit primitiven Datentypen sofort.
Kostenlos, frei und auf GitHub zu finden, was will man mehr.
Mit den Emailadressen das ist immer so eine Sache… Seit Jahren betreibe ich meinen eigenen Mailserver auf den unterschiedliche Domains aufgeschalten sind.
Aber dennoch musste ich meine aller erste Emailadresse bei GMX immer aktiv halten, da viele Leute noch auf diese Adresse schreiben. Die Werbung und die nicht vorhandene Kontrolle über mein Postfach zwangen mich aber dazu den Schritt zu wagen und die Emailadresse auf Eis zu legen. Sie läuft jetzt auf ein GMAIL Konto welches ich ab und zu mal abrufe.
Man fühlt sich richtig befreit und der Spam ist viel weniger… GMX spamt ja selbst die User zu, mit fast täglichen Emails.
Hatte bereits eine Email für mich privat unter der Suplanus Domain eingerichtet… aber netter wäre doch eine mit meinem Namen :)
Da Weiher.de schon weg ist und nur durch unverschämt hohen Preis zu erwerben wäre habe ich mich mir die neuen Domain angeschaut: Es hat mir aber keine so richtig zugesagt.
Aus diesem Grund habe ich mir eine .io-Domain geholt. Leider sind diese relativ teuer, zumindest bei den deutschen Hostern. Mein Domain-Hoster ist Hosteurope, Daten liegen aber auf Uberspace.
Ich bin auf die Suche gegangen und habe Preise verglichen. Mit Gandi.net hat man einen fairen Preis, vor allem wenn man wie ich gleich einen Mehrjahresplan aufstellt.
Soll keine Werbung sein, sondern eine Empfehlung wenn jemand in der Richtung was sucht.
Frank Schöneck hat wieder ein super Script geschrieben um Anschlussbezeichnungen zu drehen.
Das Script ist im Kontextmenü ausführbar. Vielen Dank!
// ConnectionPointDesignationReverse.cs
//
// Erweitert das Kontextmenü von 'Anschlussbezeichnungen',
// im Dialog 'Eigenschaften (Schaltzeichen): Allgemeines Betriebsmittel',
// um den Menüpunkt 'Reihenfolge drehen'.
// Es wird die Eingabe im Feld 'Anschlussbezeichnungen' automatisch gedreht.
//
// Copyright by Frank Schöneck, 2015
// letzte Änderung:
// V1.0.0, 04.03.2015, Frank Schöneck, Projektbeginn
//
// für Eplan Electric P8, ab V2.3
using System;
using System.Windows.Forms;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Base;
using Eplan.EplApi.Scripting;
public class ConnectionPointDesignationReverse
{
[DeclareMenu]
public void ProjectCopyContextMenu()
{
//Context-Menüeintrag
string menuText = getMenuText();
Eplan.EplApi.Gui.ContextMenu oContextMenu = new Eplan.EplApi.Gui.ContextMenu();
Eplan.EplApi.Gui.ContextMenuLocation oContextMenuLocation = new Eplan.EplApi.Gui.ContextMenuLocation("XDTDataDialog", "4006");
oContextMenu.AddMenuItem(oContextMenuLocation, menuText, "ConnectionPointDesignationReverse", true, false);
}
[DeclareAction("ConnectionPointDesignationReverse")]
public void Action()
{
try
{
string sSourceText = string.Empty;
string sReturnText = string.Empty;
string EplanCRLF = "¶";
//Zwischenablage leeren
System.Windows.Forms.Clipboard.Clear();
//Zwischenablage füllen
CommandLineInterpreter oCLI = new CommandLineInterpreter();
oCLI.Execute("GfDlgMgrActionIGfWind /function:SelectAll"); // Alles markieren
oCLI.Execute("GfDlgMgrActionIGfWind /function:Copy"); // Kopieren
if (System.Windows.Forms.Clipboard.ContainsText())
{
sSourceText = System.Windows.Forms.Clipboard.GetText();
if (sSourceText != string.Empty)
{
string[] sAnschlussbezeichnungen = sSourceText.Split(new string[] { EplanCRLF }, StringSplitOptions.None);
if (sAnschlussbezeichnungen.Length > 2) // Mehr als 2 Anschlussbezeichnungen
{
Decider eDecision = new Decider();
EnumDecisionReturn eAnswer = eDecision.Decide(EnumDecisionType.eYesNoDecision,
"Sollen die Anschlussbezeichnungen paarweise gedreht werden?",
"Reihenfolge drehen",
EnumDecisionReturn.eYES,
EnumDecisionReturn.eYES,
"ConnectionPointDesignationReverse",
true,
EnumDecisionIcon.eQUESTION);
if (eAnswer == EnumDecisionReturn.eYES)
{
// String neu aufbauen
for (int i = 0; i < sAnschlussbezeichnungen.Length; i = i + 2)
{
sReturnText += sAnschlussbezeichnungen[i + 1] + EplanCRLF + sAnschlussbezeichnungen[i] + EplanCRLF;
}
}
else
{
// String Array drehen
Array.Reverse(sAnschlussbezeichnungen);
// String neu aufbauen
foreach (string sAnschluss in sAnschlussbezeichnungen)
{
sReturnText += sAnschluss + EplanCRLF;
}
}
}
else // Nur 2 Anschlussbezeichnungen
{
// String Array drehen
Array.Reverse(sAnschlussbezeichnungen);
// String neu aufbauen
foreach (string sAnschluss in sAnschlussbezeichnungen)
{
sReturnText += sAnschluss + EplanCRLF;
}
}
// letztes Zeichen wieder entfernen
sReturnText = sReturnText.Substring(0, sReturnText.Length - 1);
//Zwischenablage einfügen
System.Windows.Forms.Clipboard.SetText(sReturnText);
oCLI.Execute("GfDlgMgrActionIGfWind /function:SelectAll"); // Alles markieren
oCLI.Execute("GfDlgMgrActionIGfWindDelete"); // Löschen
oCLI.Execute("GfDlgMgrActionIGfWind /function:Paste"); // Einfügen
}
}
}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message, "Reihenfolge drehen, Fehler", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return;
}
// Returns the menueitem text in the gui langueage if available.
private string getMenuText()
{
MultiLangString muLangMenuText = new MultiLangString();
muLangMenuText.SetAsString(
"de_DE@Reihenfolge drehen;" +
"en_US@rotate order;"
);
ISOCode guiLanguage = new Languages().GuiLanguage;
return muLangMenuText.GetString((ISOCode.Language)guiLanguage.GetNumber());
}
}
Aufgrund des Scriptes ConnectionPointDesignationReverse habe ich mal die Actions im Kontextmenü getestet. Anbei meine gefunden Actions mit Beschreibung.
Diese Aktionen können in Textfeldern verwendet werden. Übersetzung nur in Multilanguage-Eigenschaften verfügbar.
Kopieren
GfDlgMgrActionIGfWind /function:Copy
Ausschneiden
GfDlgMgrActionIGfWind /function:Cut
Einfügen
GfDlgMgrActionIGfWind /function:Paste
Alles markieren
GfDlgMgrActionIGfWind /function:SelectAll
Zeilenumbruch einfügen
GfDlgMgrActionIGfWind /function:InsertLineFeed
Sonderzeichen Einfügen
GfDlgMgrActionIGfWind /function:SpecialCharacterDlg
Text Löschen
GfDlgMgrActionIGfWindDelete
Mehrzeilige Eingabe
GfDlgMgrActionIGfWind /function:MultiLineDlg
Mehrsprachige Eingabe
GfDlgMgrActionIGfWind /function:MultiLanguageDlg
Übersetzen
EnfTranslateEditAction
Übersetzung Entfernen
EnfDeleteEditTranslationsAction
Nicht zu übersetzenden Text kennzeichnen
EnfSetNotTranslateAction
Kennzeichnung entfernen (“Nicht übersetzen”)
EnfDeleteNotTranslateAction
Frank hat ein super Script geschrieben, mit dem es möglich ist Platzhalter zu Übersetzen.
Vielen Dank.
// PlaceHolderTranslateAction.cs
//
// Erweitert das Kontextmenü vom Platzhalterobjekt (Reiter Werte) um den Menüpunkt "Übersetzen"
// und um den Menüpunkt "Übersetzungen entfernen"
//
// Copyright by Frank Schöneck, 2015
// letzte Änderung:
// V1.0.0, 23.10.2015, Frank Schöneck, Projektbeginn
//
// für Eplan Electric P8, ab V2.5
//
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;
namespace EplanScriptingProjectBySuplanus.PlaceHolderTranslateAction
{
public class PlaceHolderTranslate
{
[DeclareMenu]
public void PlaceHolderTranslateContextMenu()
{
//Context-Menüeintrag (hier im Platzhalterobjekt)
Eplan.EplApi.Gui.ContextMenu oContextMenu = new Eplan.EplApi.Gui.ContextMenu();
Eplan.EplApi.Gui.ContextMenuLocation oContextMenuLocation = new Eplan.EplApi.Gui.ContextMenuLocation("PlaceHolder", "1004");
oContextMenu.AddMenuItem(oContextMenuLocation, "Übersetzen", "PlaceHolderTranslateAction", false, false);
oContextMenu.AddMenuItem(oContextMenuLocation, "Übersetzungen entfernen", "PlaceHolderTranslateDeleteAction", false, false);
}
[DeclareAction("PlaceHolderTranslateAction")]
public void PlaceHolderTranslate_Action()
{
//Übersetzen
new CommandLineInterpreter().Execute("EnfTranslateEditAction");
}
[DeclareAction("PlaceHolderTranslateDeleteAction")]
public void PlaceHolderTranslateDelete_Action()
{
//Übersetzungen entfernen
new CommandLineInterpreter().Execute("EnfDeleteEditTranslationsAction");
}
}
}
Wir haben ein neues kostenloses Script im ShopForProcess:
Mit NewTranslationInstance haben Sie die Möglichkeit das Wörterbuch in einer eigenen Instanz zu öffnen. Sie können so den Dialog für das Wörterbuch immer geöffnet haben und gleichzeitig in Ihrem Projekt weiterarbeiten. Dadurch sind andere Fenster und Dialoge in EPLAN nicht mehr blockiert.
Man hat ja irgenwie auch Software auf die man stolz ist. Bei mir ist es im EPLAN Bereich das Script MenuCreator.
Schön einfach per Drag & Drop Menüs in EPLAN bauen… einfach toll.
Viele Kunden nutzen es sehr intensiv und haben Toolbars, welche nur selten genutzt wurden, durch ein Menü ersetzt.
Wir haben nun 20% Rabatt auf den tollen MenuCreator!
Hatte leider nicht viel Zeit, um was in der EPLAN API zu machen. Aber eine Sache kann ich euch zeigen…
OpenHyperlink
Listet alle Externen Dokumente der markierten Objekte. Dies gilt für Symbole, Makros oder sogar Seiten. Selbst das ganze Projekt kann gewählt werden.
Es werden alle Artikelnummern (einmal) aufgelistet mit den jeweiligen externen Dokumenten / Bilddateien.
Der Titel sagt schon dass es nicht gerade das ist was man gerne programmiert…
Kurz zu meiner Anwendung:
Ich möchte gerne Werte von einem Raspberry Pi auf meinem Uberspace in einer MySql Datenbank speichern. Erst wollte ich das auf Azure tun, leider wird hier Mono noch nicht korrekt unterstützt.
Dann eben in MySql… aber Uberspace lässt Zugriff auf die Datenbank nur per SSH zu.
Gut, dann bauen wir uns mal einen SSH-Tunnel in Mono. Hier gibt es ein schönes NuGet-Packeg namens SSH.NET
Die Objekte wie folgt initialisieren:
private const string passwordSsh = "myPassword";
private const string username = "myUsername";
private const string server = "my.server.de";
static ForwardedPort port = new ForwardedPortLocal("localhost", 3306, "localhost", 3306);
private static SshClient sshClient = new SshClient(server, 22, username, passwordSsh);Den Port benötigen wir um später die Daten durch Port 3306 zu tunneln.
Die Verbindung ist dann relativ einfach:
if (!sshClient.IsConnected)
{
sshClient.Connect();
// offline
if (sshClient.IsConnected)
{
// Start port if not started
if (!port.IsStarted)
{
// Add port if not added yet
if (!sshClient.ForwardedPorts.Contains(port))
{
sshClient.AddForwardedPort(port);
}
port.Start();
}
}
}Jetzt schnell noch das Entity Framework (Code First) einbinden und fertig … dachte ich.
Leider kommt mir das alle ziemlich buggy und nicht fertig vor. Drum weiß ich nicht ob ich das wirklich in einer Produktivumgebung einsetzten werde / würde.
Per NuGet gibt es MySql packages … aber welche brauche ich?
Bin selbst noch nicht durchgestiegen was für was ist, kann aber sagen, bei mir hat es nur mit folgenden geklappt:
<package id="EntityFramework" version="6.1.3" targetFramework="net4" /> <package id="MySql.Data" version="6.8.7" targetFramework="net4" /> <package id="MySql.Data.Entities" version="6.8.3.0" targetFramework="net4" />
Nun gibt es aber noch einen Bug der unter einer Mono-Runtime die Version des Servers falsch parsed, somit braucht man folgenden fix (hab es bisl erweitert dass jeder Server/Version richtig gewandelt wird):
using System.Data;
using System.Data.Common;
using System.Data.Entity.Infrastructure;
using System.Text.RegularExpressions;
namespace OpenHop.Database
{
public class ManifestTokenResolver : IManifestTokenResolver
{
public string ResolveManifestToken(DbConnection connection)
{
try
{
connection.Open();
string version = OnlyNumbers(connection.ServerVersion);
return version;
}
finally
{
if (connection.State == ConnectionState.Open)
{
connection.Close();
}
}
}
private static readonly Regex digitsOnly = new Regex(@"[^\d]");
public static string OnlyNumbers(string text)
{
return digitsOnly.Replace(text, "");
}
}
}
In der app.config dann noch die Daten eintragen:
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<configSections>
<!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
<section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
</configSections>
<entityFramework>
<defaultConnectionFactory type="System.Data.Entity.Infrastructure.SqlConnectionFactory, EntityFramework" />
<providers>
<provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
<provider invariantName="MySql.Data.MySqlClient.EF6" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6, Version=6.8.3.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" />
<provider invariantName="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6, Version=6.9.8.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d">
</provider></providers>
</entityFramework>
<connectionStrings>
<add name="MyContext" providerName="MySql.Data.MySqlClient.EF6" connectionString="server=localhost;database=myDatabase;uid=myUsername;pwd=myPassword" />
</connectionStrings>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="MySql.Data" publicKeyToken="c5687fc88969c44d" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.8.7.0" newVersion="6.8.7.0" />
</dependentAssembly>
</assemblyBinding>
</runtime>
<system.data>
<DbProviderFactories>
<add name="MySQL Data Provider" invariant="MySql.Data.MySqlClient.EF6" description=".Net Framework Data Provider for MySQL" type="MySql.Data.MySqlClient.MySqlClientFactory,MySql.Data, Version=6.8.1.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" />
<remove invariant="MySql.Data.MySqlClient" /><add name="MySQL Data Provider" invariant="MySql.Data.MySqlClient" description=".Net Framework Data Provider for MySQL" type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data, Version=6.9.8.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" /></DbProviderFactories>
</system.data>
</configuration>
Das “Automatisiert Bearbeiten” dürfte vielen von euch ein Begriff sein.
Leider hat EPLAN hier nicht viel gemacht bzw. eher Features weggenommen.
Darum haben wir uns entschlossen das Script ActionList zu schreiben, welches es ermöglicht verschiedene Aktionen nacheinander auszuführen.
Das ganze schön per Drag & Drop festlegen und alle Aktionen werden automatisch ausgeführt.
Gerade in Kombination der automatischen Ausgabe von Beschriftungen oder PDF ist super!
Anbei eine Auflistung von Events, auf welche man sich per API & Script aufschalten kann.
Beispiel
Beim Projekt-Schließen wird die Action ausgeführt.
using System.Windows.Forms;
using Eplan.EplApi.Scripting;
public class MyEventHandler
{
[DeclareEventHandler("onActionStart.String.XPrjActionProjectClose")]
public void Action()
{
MessageBox.Show("Ich kann Scripten!");
return;
}
}
Eplan.EplApi.OnMainEnd
Send when the Main End starts.
Eplan.EplApi.OnMainStart
Send when the Main Start is done. This is when a mainframe is available. The event is not send when the application is started in offline modus or to execute an action.
Eplan.EplApi.OnPostOpenProject
Project management: After opening a project
Eplan.EplApi.OnUserPreCloseProject
Project management: Before closing a project
Ged.Redraw
Force a Redraw for the GED
NCSettingsMachineTools.Redraw
Force a Redraw for the NC Machine Tools settings tab
onActionEnd.String.*
Send after the end of any Action.
onActionStart.String.*
Send before the start of any Action.
Page.ConnectionDirty
Event when a Page gets dirty
Project.CablingDirty
Event when cabling gets dirty
Da ich demnächst mehr mit der EPLAN API arbeiten darf, hab ich die Entscheidung getroffen einen Teil davon Open Source zu stellen.
Es handelt sich um eine Standard Library um gewisse Abläufe zu vereinfachen.
Der Name ist nicht gerade kreativ gewählt, aber das Kind braucht ja einen Namen :)
Würde mich freuen wenn ihr auch daran mitarbeitet! Man findet alles auf GitHub…
Als erstes möchte ich gleich die Implementierung einer Offline-Application vorstellen.
Es ist nicht ganz einfach ein Programm mit EPLAN Anbindung zu schreiben. Der Aufruf mit Sepla erfolgt wie folgt:
string binPath = Starter.GetBinPath();
IntPtr handle = new WindowInteropHelper(this).Handle;
EplanOffline eplanOffline = new EplanOffline();
eplanOffline.Start(handle, binPath);
if (!eplanOffline.IsRunning)
{
throw new NotImplementedException();
}Geschlossen wird das ganze dann über:
eplanOffline.Close();
Im Hintergrund arbeiten zwei Klassen, damit eine Trennung gewährleistet ist. Denn der Resolver muss erst die Assemblies laden.
Starter.cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Eplan.EplApi.Starter;
namespace Suplanus.Sepla.Application
{
/// <summary>
/// EPLAN Starter Helper: No other EPLAN-Namespaces are allowd
/// </summary>
public class Starter
{
public static string GetBinPath()
{
List<EplanData> eplanVersions = new List<EplanData>();
List<EplanData> eplanVersions32bit = new List<EplanData>();
new EplanFinder().GetInstalledEplanVersions(ref eplanVersions32bit);
eplanVersions.AddRange(eplanVersions32bit);
List<EplanData> eplanVersions64bit = new List<EplanData>();
new EplanFinder().GetInstalledEplanVersions(ref eplanVersions64bit, true);
eplanVersions.AddRange(eplanVersions64bit);
eplanVersions = new List<EplanData>(eplanVersions
.Where(obj => obj.EplanVariant.Equals("Electric P8"))
.OrderBy(obj => obj.EplanVersion));
EplanData eplanData = eplanVersions.LastOrDefault();
var binPath = Path.GetDirectoryName(eplanData.EplanPath);
AssemblyResolver resolver = new AssemblyResolver();
resolver.SetEplanBinPath(binPath);
resolver.PinToEplan();
return binPath;
}
}
}
EplanOffline.cs
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using Eplan.EplApi.Starter;
using Eplan.EplApi.System;
namespace Suplanus.Sepla.Application
{
public class EplanOffline
{
public EplApplication Application;
public bool IsRunning
{
get { return Application != null; }
}
public void Start(IntPtr handle, string binPath)
{
if (Application == null)
{
try
{
EplApplication eplApplication = new EplApplication();
eplApplication.EplanBinFolder = binPath;
eplApplication.ResetQuietMode();
eplApplication.SetMainFrame(handle);
eplApplication.Init("", true, true);
Application = eplApplication;
}
catch
{
Application = null;
}
}
}
public void Close()
{
if (Application != null)
{
Application.Exit();
Application = null;
}
}
}
}
Irgendwie ist das total an mir vorbeigegangen und hab es zufällig im EPLAN Solution Center gelesen…
Falls es auch so geht, hier die offizielle Meldung:
Was das für Konsequenzen für EPLAN Electric P8 hat, weiß ich leider auch nicht. Ob die Funktion EPLAN 5 / 21 Import irgendwann wegfällt oder Ähnliches.
Ich habe im letzten Jahr, seit Veröffentlichung von EPLAN 2.4, viele Anfragen bzgl. der EPLAN API Erweiterung ToggleLayers erhalten.
Mit diesem API Addin das von allen EPLAN Anwendern, auch ohne API genutzt werden kann, ist es möglich Ebenen per Scripting zu steuern.
Leider habe ich keine Freigabe für den Download bekommen. Aber die Anmerkung dass User welche diese Funktion brauchen beim Support danach fragen sollen.
Somit ist geklärt: Auch mit EPLAN 64bit (2.4/2.5) ist es möglich die Ebenen umzuschalten.
Hier die Doku der Action:
Actionname
ToggleLayers
Parameter
LAYERSTATE
Werte
Beispiel:
ToggleLayers /LAYERSTATE:"EPLAN491|1,0|y|y|102"
Ich hab ja die Superkraft in Probleme zu laufen die wohl sonst keiner hat…
Wenn man unter Mono auf den Dienst Pushover zugreifen will dann ist es notwendig das Zertifikat zu registrieren (Shell):
certmgr -ssl https://api.pushover.net --machine
Mir ist es aufgefallen als ich mit der .NET-Library NPushOver gearbeitet habe… kann ich sehr empfehlen.
Da hatte ich aber auch das Problem dass ich Push-Notifications ohne Inhalt (Body) versenden wollte. Bekam dann immer einen 400er Fehler. Liegt daran dass Pushover keine leeren Notifications erlaubt.
EPLAN hat ja die Handhabung mit benutzerdefinierten Eigenschaften geändert.
Diese können nun über Optionen > Eigenschaften konfigurieren… geändert werden.
Leider hat EPLAN nicht gesagt wie man diese Eigenschaften dann auch Schreiben kann.
In der Action XEsSetProjectPropertyAction ist nur dokumentiert wie man die ID-bezogenen Eigenschaften setzt.
Es gibt, wie so oft, einen nicht dokumentierten Parameter namens PropertyIdentName mit dem man die Eigenschaften ansprechen kann.
Beispiel:
XEsSetProjectPropertyAction /PropertyIdentName:"EPLAN.Project.UserSupplementaryField1" /PropertyIndex:0 /PropertyValue:"My project property" XEsSetPagePropertyAction /PropertyIdentName:"EPLAN.Page.UserSupplementaryField1" /PropertyIndex:0 /PropertyValue:"My page property" XEsSetPropertyAction /PropertyIdentName:"EPLAN.Function.UserSupplementaryField1" /PropertyIndex:0 /PropertyValue:"My function property" XEsSetPropertyAction /PropertyIdentName:"EPLAN.ArticleRef.EPLAN.PartRef.UserSupplementaryField1" /PropertyIndex:1 /PropertyValue:"My articlereference property"
Da schreibt man ein Buch… denkt man kennt sich einigermaßen aus mit dem Thema…
Und fast eineinhalb Jahre später, kann man Scripte debuggen und ich weiß von nichts… keiner schreibt was in dieses Internet. Dann mach ich das mal.
Seit EPLAN 2.4 ist es möglich Scripte zu debuggen. Es gibt kleine Einschränkungen aber man kann sich endlich die unendlichen MessageBoxen und Scripte Neulad-Szenarien sparen.
Es gibt, wie so oft, eine versteckte Einstellung welche gesetzt werden muss, damit das Debuggen funktioniert.
Ich habe es mal in das kostenlose Script ExtendedSettings gepackt.
Der Einstellungspfad ist folgender:
USER.EplanEplApiScriptLog.DebugScripts
In Visual Studio dann einfach:
In EPLAN:
EPLAN kopiert beim Laden/Ausführen eines Scriptes das Script in den Temp-Ordner.
Der Dateiname ist wie folgt aufgebaut:
Debug_[Scriptname]
Leider können dadurch keine Haltepunkte in EPLAN gesetzt werden. Dies muss per Code geschehen:
System.Diagnostics.Debugger.Break();
Aber: Ist einmal ein Breakpoint gesetzt worden, kann auch wie gewohnt in Visual Studio ein Haltepunkt gesetzt werden.
Wichtig: Wenn die EPLAN-Einstellung bzgl. Script Debugging nicht gesetzt ist, müssen diese Haltepunkte entfernt werden.
Als Workaround habe ich folgendes herausgefunden:
Mit der Compiler-Abfrage auf #if DEBUG kann dieses Problem umgangen werden.
#if DEBUG System.Diagnostics.Debugger.Break(); #endif
Hier noch ein kleines Demo Video:
Ich bin ziemlich traurig darüber dass ich das jetzt erst erfahren habe. Ich sollte mal die Emails zählen welche ich die letzten 1,5 Jahre beantwortet habe mit der Frage “ist debugging bei Scripten nicht möglich?”.
Vielleicht denkt jeder der diesen Weg schon kannte einfach dass ich das schon wüsste…
Naja, ich bin einfach nur froh um diese Funktion!
Anbei noch mein Beispiel:
using System;
using System.Linq;
using System.Windows.Forms;
using Eplan.EplApi.Base;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;
using System.Windows.Forms;
using Eplan.EplApi.Scripting;
namespace ibKastl.Scripts.Test
{
public class Test
{
[Start]
public void Action()
{
#if DEBUG
System.Diagnostics.Debugger.Break();
#endif
MessageBox.Show("Start walking...");
#if DEBUG
System.Diagnostics.Debug.WriteLine("Walk 500 miles...");
#endif
for (int i = 1; i <= 500; i++)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine("Mile {0}: still walking...", i);
#endif
}
MessageBox.Show("End");
}
}
}
Ach… auf meine alten P8 Tage darf ich noch EPLAN5 Projekte konvertieren… das freut mich.
Weniger freut es mich dass man im Scripting dann garnicht weiß, wo EPLAN die *.elk Datei erzeugt.
Komischerweise wird hier eine Großbuchstabenkonvertierung gemacht…
Darum hier mal die Routine wie man von einem EPLAN5 Projekt die Projektdatei von P8 ermittelt:
private string GetNewP8ProjectFromEplan5Import(string path)
{
var diffWithFilename = path.Replace(ProjectsPath, ""); // FolderA\ProjectA.P
FileInfo fi = new FileInfo(diffWithFilename);
var diffWithoutFilename = diffWithFilename.Replace(fi.Name, "").ToUpper(); // FOLDERA\ProjectA.P
var filename = fi.Name.Replace(".P", ".elk"); // ProjectA.elk
var project = Path.Combine(DestinationPath, diffWithoutFilename, filename);
return project;
}Danach kann z.B. das Projekt geöffnet, oder auch Actions ausgeführt werden.
Ich hatte mir ja mal (2010) die Arbeit gemacht und alle Pfadvariablen aufgeschrieben.
Nun ist mir aufgefallen dass hier einige dazugekommen und eine (Revisionen) weggekommen sind.
Das Update findet ihr am Orginalartikel.