Mit dieser inoffiziellen Action ist es möglich per Script aus einem Projekt ein Basisprojekt zu erstellen:

XPrjActionProjectCreateBaseProject

Parameter:

• PROJECT: full name of the project
• TARGET: full name of the target file

Es stimmt wohl was die Leute immer sagen: “Mit dem Alter vergeht die Zeit schneller”

Jedes Jahr verzieht spürbar schneller und ich bin schon der Typ Mensch, der sich am Ende des Jahres fragt, was denn alles passiert ist.

Privat ist das heuer ziemlich einfach: Habe im Sommer geheiratet, was einem natürlich am besten in Erinnerung bleibt.

Beruflich ist es eigentlich eine Kombination aus unterschiedlichen Eindrücken & Erlebnissen.
Was mich das ganze Jahr über bewegt hat, war der Release unseres ShopForProcess.com, der mich sehr positiv überrascht hat.

Mir war klar dass die Tools viele EPLAN Anwender benötigen, aber die Schwierigkeit ist die Anwender zu erreichen dass es solche Lösungen gibt. Die Rückmeldungen der Kunden waren sehr positiv. Darüber sind wir sehr glücklich, denn Qualität und die Leistung liegt uns sehr am Herzen.
In diesem Zusammenhang war es auch das 2. Jahr bei Firma ibKastl und ich bin sehr glücklich und dankbar über den tollen Arbeitsplatz.

Auch die neuen Kontakte und Kunden die man über das Jahr kennengelernt hat, haben mir sehr viel Freude bereitet. Viele Eindrücke erhalten und vielen EPLAN Anwendern helfen können. Diese Kombination macht einen als Consultant glücklich.

Freue mich sehr auf nächstes Jahr, beruflich wie privat. Aber das ist eh nicht so klar zu unterscheiden bzw. will ich nicht unterscheiden. Irgendwie ist es eigentlich ein Hobby für das man Geld bekommt, denn es macht so viel Spaß dass man sich gerne auch am Wochenende / Abend damit beschäftigt. Meiner Meinung nach ist das auch die beste Kombination aus persönlicher Sicht bzw. der Sicht der Kunden. Denn ich hoffe man bemerkt das Herzblut dass in unserer Arbeit, Leistungen und Produkten steckt.

Bin dankbar über jeden Menschen der mich dieses Jahr unterstützt, gefördert & geholfen hat, allem voran Michael Kastl, der Chef  und Freund meines Vertrauens.

Auch danke an die EPLAN Community, die immer wieder neue Ideen und Lösungen entwickelt.

In diesem Sinne einfach Danke!

Ich hatte mal schon geschrieben wie man die Projekt-Sprachen rausfindet…

Hier noch ein Script wie man die variable Sprache herausfindet.
Einfach das Script laden und in einem anderen Script das Usage ausführen.

using System.IO;
using System.Xml;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Base;
using Eplan.EplApi.Scripting;

class GetProjectVariableLanguage
{
	/* Usage
	private static string GetProjectVariableLanguage()
	{
		string value = null;
		ActionCallingContext actionCallingContext = new ActionCallingContext();
		new CommandLineInterpreter().Execute("GetProjectVariableLanguage", actionCallingContext);
		actionCallingContext.GetParameter("value", ref value);
		return value;
	}
	*/

	private readonly string TempPath = Path.Combine(
		PathMap.SubstitutePath("$(TMP)"), "GetProjectLanguages.xml");

	[DeclareAction("GetProjectVariableLanguage")]
	public void Action(out string value)
	{
		ActionCallingContext actionCallingContext = new ActionCallingContext();
		actionCallingContext.AddParameter("prj", FullProjectPath());
		actionCallingContext.AddParameter("node", "TRANSLATEGUI");
		actionCallingContext.AddParameter("XMLFile", TempPath);
		new CommandLineInterpreter().Execute("XSettingsExport", actionCallingContext);

		if (File.Exists(TempPath))
		{
			string languagesString = GetValueSettingsXml(TempPath,
				"/Settings/CAT/MOD/Setting[@name='VAR_LANGUAGE']/Val");

			if (languagesString != null)
			{
				value = languagesString;
				return;
			}
		}

		value = null;
		return;
	}

	// Returns the EPLAN Project Path
	private static string FullProjectPath()
	{
		ActionCallingContext acc = new ActionCallingContext();
		acc.AddParameter("TYPE", "PROJECT");

		string projectPath = string.Empty;
		new CommandLineInterpreter().Execute("selectionset", acc);
		acc.GetParameter("PROJECT", ref projectPath);

		return projectPath;
	}

	// Read EPLAN XML-ProjectInfo and returns the value
	private static string GetValueSettingsXml(string filename, string url)
	{
		XmlDocument xmlDocument = new XmlDocument();
		xmlDocument.Load(filename);

		XmlNodeList rankListSchemaName = xmlDocument.SelectNodes(url);
		if (rankListSchemaName != null && rankListSchemaName.Count > 0)
		{
			// Get Text from MultiLanguage or not :)
			string value = rankListSchemaName[0].InnerText;
			return value;
		}
		else
		{
			return null;
		}
	}
}

Alle guten Dinge sind drei…
Ich war nie zufrieden mit den Pushservices Pushover und Pushbullet.

Pushbullet würde die Bilder schön darstellen, aber pushed ab und zu unzuverlässig.

Da wir bei ibKastl derzeit für die interne Kommunikation Slack testen, kam mir die Idee meine Türklingel auch dort mal an die API anzubinden.

Das schöne an Slack ist, dass es für alle Mobile-/Desktop-Betriebssysteme Apps gibt!

Die API ist auch schön einfach… Einfach ein Team + Channel erstellen und den API-Key eintragen… mit drei Zeilen im Code ist es getan.

from slacker import Slacker

# Slack
slack = Slacker('myApiKey')
slack.files.upload('/home/pi/Desktop/doorbell/web/photos/' +  filename, title=now, channels='#doorbell')

Was der Code macht: Import von Slacker (Python-Lib) und dann einfach den Upload des Fotos mit dem Titel der aktuellen Zeit in den Channel #doorbell.

Auf dem Screenshot sieht man auch dass ich noch im alten Pythoncode die falsche Uhrzeit abgefragt habe… Das könnt ihr wie folgt korrigieren:

now=strftime("%Y-%m-%d %H:%M:%S", gmtime())

Schön sieht man auch wie die IR-Kamera des Raspberry Pi im dunklen fotografiert, sogar mit Gegenlicht :^)

Mit der Offline Applikation hat man man vielen Problemen zu kämpfen, angefangen beim Start…

Ich hab auf GitHub mal Methoden bereitgestellt um das zu vereinfach.

Verwendung WPF

var eplanOffline = new EplanOffline();
eplanOffline.StartWpf(this);
if (!eplanOffline.IsRunning)
{
	throw new NotImplementedException();
}
eplanOffline.Close();

Verwendung Windows Forms

var eplanOffline = new EplanOffline();
eplanOffline.StartWindowsForms(this);
if (!eplanOffline.IsRunning)
{
	throw new NotImplementedException();
}
eplanOffline.Close();

Ich habe bewusst darauf verzichtet dass alles im Konstruktor zu machen, da sonst WindowsForms in WPF und anders herum hinzugefügt werden muss.

Hier mal der Code dazu (Starter ist zum registrieren der Lizenz/DLLs):

using System.Collections.Generic;
using System.IO;
using System.Linq;
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 GetBinPathLastVersion()
        {
            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;
        }
    }
}

using System;
using System.Windows;
using System.Windows.Forms;
using System.Windows.Interop;
using Eplan.EplApi.System;
using Suplanus.Sepla.Gui;

namespace Suplanus.Sepla.Application
{
    public class EplanOffline
    {
        public EplApplication Application;

	    public Preview Preview;

		/// <summary>
		/// Starts EPLAN with the last version of Electric P8 and attach to (WPF) window
		/// </summary>
		/// <param name="window"></param>
		public void StartWpf(Window window)
	    {
			IntPtr handle = new WindowInteropHelper(window).Handle;
			string binPath = Starter.GetBinPathLastVersion();
			Start(handle,binPath);
		}

		/// <summary>
		/// Starts EPLAN with the last version of Electric P8 and attach to (WF) form
		/// </summary>
		/// <param name="form"></param>
		public void StartWindowsForms(Form form)
		{
			IntPtr handle = form.Handle;
			string binPath = Starter.GetBinPathLastVersion();
			Start(handle, binPath);
		}

		/// <summary>
		/// Starts EPLAN with the given version of program variant and attach to (WPF) window
		/// </summary>
		/// <param name="window"></param>
		/// <param name="binPath"></param>
		public void StartWpf(Window window, string binPath)
		{
			IntPtr handle = new WindowInteropHelper(window).Handle;
			Start(handle, binPath);
		}

		/// <summary>
		/// Returns if the EPLAN-Application is running
		/// </summary>
		public bool IsRunning
        {
            get { return Application != null; }
        }

	    

	    /// <summary>
		/// Starts the application
		/// </summary>
		/// <param name="handle"></param>
		/// <param name="binPath"></param>
        private 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;
                } 
            }
        }

		/// <summary>
		/// Release all objects
		/// </summary>
        public void Close()
        {
            if (Application != null)
            {
                Application.Exit();
                Application = null;
            }
        }
    }
}

In diesem Code wird immer die aktuellste Version von EPLAN Electric P8 verwendet. Ich bau irgendwann noch Methoden zur Auswahl von der Lizenz / Version.

Ich hatte ja schon erklärt wie man EPLAN per COM-Schnittstelle ansprechen kann.

Nachteil: Bei 32/64bit gewinnt der Server der als erstes gestartet wurde.
Aber es gibt einen Weg mit dem man sogar die Version auswählen kann (wenn z.B. mehrere EPLAN Versionen installiert bzw. geöffnet sind).

Diese Schnittstelle ist nicht offiziell dokumentiert!

Ihr müsst eine Referenz auf die DLL Eplan.EplApi.RemoteClientu.dll machen, welche sich im Installationsverzeichnis von EPLAN befindet, z.B.:

C:\Program Files\EPLAN\Platform\2.5.4\Bin\

Hier ein Beispiel wie man die aktuellen EPLAN Versionen erhält und bei der aktuellsten das Projekt schließt:

EplanRemoteClient eplanRemoteClient = new EplanRemoteClient();
List eplanServerDatas = new List();
eplanRemoteClient.GetActiveEplanServersOnLocalMachine(out eplanServerDatas);
if (eplanServerDatas.Count > 0)
{
	var eplanServerDataLast = eplanServerDatas.OrderBy(obj=>obj.EplanVersion).LastOrDefault();
	if (eplanServerDataLast != null)
	{
		eplanRemoteClient.Connect("localhost", eplanServerDataLast.ServerPort.ToString(),new TimeSpan(0,0,0,5));
		eplanRemoteClient.ExecuteAction("XPrjActionProjectClose");
		eplanRemoteClient.Disconnect();
	}
}

Localhost für den lokalen Rechner verwenden, den Timespan brauchte ich, da EPLAN zu langsam reagierte.

Da es nicht ganz so einfach ist in WPF eine Vorschau im Offline Programm zu implementieren, habe ich das mal in eine Klasse gepackt.

Mir ist aufgefallen dass der Speicher hochläuft und habe hier auf EPLAN getippt… Nach Rücksprache mit dem API-Support wurde mir gesagt dass es nicht der Speicher von EPLAN ist, sondern der Applikation, bzw. WPF.

Ich habe hier mal die Generierung der Bitmap in Verdacht gezogen und siehe da, bekannter Bug.
Hier mal im Vergleich:

Auf GitHub findet ihr auch eine Demo-Applikation dazu.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Forms;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using Eplan.EplApi.DataModel;
using System.Runtime.InteropServices;
using Eplan.EplApi.DataModel.MasterData;
using Eplan.EplApi.HEServices;

namespace Suplanus.Sepla.Gui
{
	public class Preview
	{
		private readonly Border _border;
		private readonly DrawingService _drawingService;
		private readonly Project _project;

		/// <summary>
		/// Init Preview object for WPF
		/// </summary>
		/// <param name="border"></param>
		/// <param name="projectFile"></param>
		public Preview(Border border, string projectFile)
		{
			var projectManager = new ProjectManager();
			projectManager.LockProjectByDefault = false;
			_project = projectManager.OpenProject(projectFile, ProjectManager.OpenMode.Exclusive);

			_drawingService = new DrawingService();
			_drawingService.DrawConnections = true;

			_border = border;
		}

		/// <summary>
		/// Display a file
		/// </summary>
		/// <param name="path">Full filename</param>
		/// <param name="previewType">Type of file</param>
		public void Display(string path, PreviewType previewType)
		{
			switch (previewType)
			{
				case PreviewType.WindowMacro:
					WindowMacro windowMacro = new WindowMacro();
					windowMacro.Open(path, _project);
					_drawingService.CreateDisplayList(windowMacro);
					DrawEplan();
					windowMacro.Dispose();
					break;

				case PreviewType.SymbolMacro:
					SymbolMacro symbolMacro = new SymbolMacro();
					symbolMacro.Open(path, _project);
					_drawingService.CreateDisplayList(symbolMacro);
					DrawEplan();
					symbolMacro.Dispose();
					break;

				case PreviewType.PageMacro:
					PageMacro pageMacro = new PageMacro();
					pageMacro.Open(path, _project);
					_drawingService.CreateDisplayList(pageMacro.Pages);
					DrawEplan();
					pageMacro.Dispose();
					break;

				default:
					throw new ArgumentOutOfRangeException(nameof(previewType), previewType, null);
			}

		}

		/// <summary>
		/// Draw EPLAN files
		/// </summary>
		private void DrawEplan()
		{
			int width = Convert.ToInt16(_border.ActualWidth);
			int height = Convert.ToInt16(_border.ActualHeight);

			if (width > 0 && height > 0)
			{
				System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(width, height);
				System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(bitmap);
				System.Drawing.Rectangle rectangle = new System.Drawing.Rectangle(0, 0, width, height);
				PaintEventArgs paintEventArgs = new PaintEventArgs(graphics, rectangle);

				_drawingService.DrawDisplayList(paintEventArgs);

				IntPtr hBitmap = bitmap.GetHbitmap();
				BitmapSource bitmapSource = Imaging.CreateBitmapSourceFromHBitmap(hBitmap,
					IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());

				_border.Background = new ImageBrush(bitmapSource);

				bitmap.Dispose();
				graphics.Dispose();
				paintEventArgs.Dispose();
				DeleteObject(hBitmap);
			}
			else
			{
				_border.Background = null;
			}

		}

		/// <summary>
		/// Memory Leak: http://stackoverflow.com/questions/1546091/wpf-createbitmapsourcefromhbitmap-memory-leak
		/// </summary>
		/// <param name="hObject"></param>
		/// <returns></returns>
		[DllImport("gdi32.dll")]
		public static extern bool DeleteObject(IntPtr hObject);
	}

	
	/// <summary>
	/// Filetype to preview
	/// </summary>
	public enum PreviewType
	{
		WindowMacro,
		SymbolMacro,
		PageMacro
	}
}

Ich generiere gerade bisschen mit der API um ein Gefühl zu bekommen was alles möglich ist. Leider ist es nicht ganz trivial Seitenmakros einzufügen.

Problem: Äquivalent zur EPLAN GUI wird das Makro einfach eingefügt. Seiten werden überschrieben, oder auch nicht.

Als Workaround kann man die Seiten im Makro in der API davor anpassen und trotzdem die Strukturkennzeichen beibehalten.
Im Beispiel zähle ich einfach die Seiten vom Projekt hoch (Basisprojekt muss somit durchnummeriert sein).

Insert insert = new Insert();
var pageCount = project.Pages.Length; // needed cause of overwrite
foreach (var pageMacroFile in pageMacros)
{
	// Load pages from macro
	PageMacro pageMacro = new PageMacro();
	pageMacro.Open(pageMacroFile, project);
	foreach (var page in pageMacro.Pages)
	{
		// Rename
		pageCount++;
		PagePropertyList pagePropertyList = page.NameParts;
		pagePropertyList[Properties.Page.DESIGNATION_PLANT] = "TEST";
		pagePropertyList[Properties.Page.PAGE_COUNTER] = pageCount;
		page.NameParts = pagePropertyList;
		new NameService(page).EvaluateAndSetAllNames();
	}

	// Insert pagemacro
	insert.PageMacro(pageMacro, project, null, PageMacro.Enums.NumerationMode.Number);
}

Das hin und her bei Rename muss leider sein, da es nicht möglich ist direkt auf die Properties des Objektes zu gehen.

NameService.EvaluateAndSetAllNames()

Ich bau mal was zusammen damit man die Strukturkennzeichen schön von außen mit übergeben kann :^)
Ist wie gewohnt auf GitHub zu finden.

Ich hab mal die Methode zum Generieren erweitert. Man kann nun die Struktur mit übergeben.

Beispiel:

string projectLinkPath = @"\\Mac\Home\Desktop\Test.elk";
string projectTemplatePath = @"\\Mac\Home\Documents\GitHub\ibKastl.MechatronicsConfigurator\DemoData\Templates\IEC_bas001.zw9";

List<GeneratablePageMacro> generatablePageMacros = new List<GeneratablePageMacro>();
generatablePageMacros.Add(new GeneratablePageMacro(
	@"\\Mac\Home\Documents\GitHub\ibKastl.MechatronicsConfigurator\DemoData\Macros\PageMacro_Axis-X.emp",
	new LocationIdentifierIdentifier
	{
		FunctionAssignment = "TEST1",
		Plant = "TEST11",
		PlaceOfInstallation = "TEST111",
		Location = "TEST1111",
		UserDefinied = "TEST11111",
	}));

generatablePageMacros.Add(new GeneratablePageMacro(
	@"\\Mac\Home\Documents\GitHub\ibKastl.MechatronicsConfigurator\DemoData\Macros\PageMacro_Supply.emp",
	new LocationIdentifierIdentifier
	{
		FunctionAssignment = "TEST2",
		Plant = "TEST22",
		PlaceOfInstallation = "TEST222",
		Location = "TEST2222",
		UserDefinied = "TEST22222",
	}));

// check overwrite
generatablePageMacros.Add(new GeneratablePageMacro(
	@"\\Mac\Home\Documents\GitHub\ibKastl.MechatronicsConfigurator\DemoData\Macros\PageMacro_Axis-X.emp",
	new LocationIdentifierIdentifier
	{
		FunctionAssignment = "TEST1",
		Plant = "TEST11",
		PlaceOfInstallation = "TEST111",
		Location = "TEST1111",
		UserDefinied = "TEST11111",
	}));

generatablePageMacros.Add(new GeneratablePageMacro(
	@"\\Mac\Home\Documents\GitHub\ibKastl.MechatronicsConfigurator\DemoData\Macros\PageMacro_Supply.emp",
	new LocationIdentifierIdentifier
	{
		FunctionAssignment = "TEST2",
		Plant = "TEST22",
		PlaceOfInstallation = "TEST222",
		Location = "TEST2222",
		UserDefinied = "TEST22222",
	}));

ProjectUtility.Generate(projectLinkPath, projectTemplatePath, generatablePageMacros);

Hier sieht man recht schön dass die Seiten nicht überschrieben werden, sondern nacheinander eingefügt werden. Sind im Projekt Strukturkennzeichen nicht aktiv (z.B. Funktionale Zuordnung) dann werden diese einfach ignoriert:

Ich hatte ja beschrieben wie man mit (viel Aufwand und) WPF eine Vorschau von Makros für EPLAN erzeugen kann.

Hier gab es aber ein Problem: Seitenmakros konnten nicht gruppiert dargestellt werden, da es einen Bug in der API gibt, wenn WPF verwendet wird.

Nun habe das Ganze aber zerlegt:
Alle Darstellungsarten und alle Varianten (bzw. Seiten) können ausgewählt werden.

Hier im Video sieht man das Ergebnis, Makros sind nur Testdaten, bitte nicht darauf achten :^)

Habe auch soweit noch optimiert, dass man nur noch einmal die Preview machen muss (Größenveränderungen werden automatisch erkannt).

Verwendung

// start eplan
_eplanOffline = new EplanOffline();

// Needed if its an OfflineApplication
_eplanOffline.StartWpf(this);
if (!_eplanOffline.IsRunning)
{
	throw new Exception("EPLAN not running");
}

// Init preview
_eplanOffline.Preview = new Preview(previewBorder, _previewProject);

// display
_eplanOffline.Preview.Display(_macroPath, PreviewType.WindowMacro);

Wie gewohnt auf GitHub zu finden…

Man merkt wohl anhand der Beiträge dass ich derzeit Vieles mit der EPLAN API mache :)

Fertiggestellt habe ich mal zwei Prüfläufe.

LinkToPartsDbVerification

Überprüft ob ein Artikel in der Datenbank vorhanden ist. Der Prüflauf von EPLAN (007012) zeigt leider Artikel nicht an, die schon mal im Projekt eingelagert wurden.
Wenn zum Beispiel eine Artikelnummer geändert wird, taucht dieser nie in der Meldungsverwaltung auf.

LocationDescriptionVerification

Prüft ob ein Strukturkennzeichen eine leere Beschreibung hat.

Ach… das mit der Dokumentation der Actions ist bei EPLAN immer so eine Sache.

In der API Dokumentation steht es drin, in der EPLAN Hilfe nicht.

Die Aktion

projectmanagement

projectmanagement /TYPE:CREATESNAPSHOTCOPY /FILENAME:"C:\Test\Copy.elk"

Dadurch wird das aktuelle Projekt unter neuem Pfad gespeichert. Hier kann auch noch

/PROJECTNAME

Es gibt auch noch die Typen

/PUBLISHTODISK

/PUBLISHTOEMAIL

/SCHEME

Ich hab mal drei Templates für die EPLAN API Programmierung erstellt.

Dadurch können Addins/Verfications und Actions sehr schnell eingefügt werden:

• Suplanus.ActionTemplate
• Suplanus.EplAddin.AddinTemplate
• Suplanus.EplAddin.VerificationTemplate

Beim ActionTemplate wird gleich der Klassenname als Actionname verwendet, was ich immer sehr praktisch finde.

Einfach in euer Template Verzeichnis packen (z.B. Documents\Visual Studio 2015\My Exported Templates) und freuen :^)

Wenn man wie ich EPLAN in Deutsch und Englisch lizensiert hat, möchte man die Variante jeweils schnell starten.

Das geht über den Aufrufparameter

/Language

"C:\Program Files\EPLAN\Platform\2.5.4\Bin\Eplan.exe" /Variant:"Electric P8" /Language:en_US

Wichtig: Die Einstellung für Dialogsprache wird nicht verändert, was schlimm ist wenn man wie ich die Dialogsprache per Script ermitteln will.

Naja, aber wir haben ja die Möglichkeit es manuell zu setzen:

"C:\Program Files\EPLAN\Platform\2.5.4\Bin\Eplan.exe" /Variant:"Electric P8" /Language:en_US XAfActionSetting /set:"USER.SYSTEM.GUI.LANGUAGE" /value:"en_US" /index:0

Ich habe mir einfach eine weitere Verknüpfung ins Startmenü gemacht :^)

Nicht ganz so einfach wie man es sich vorstellt, ist das arbeiten mit Platzhaltern.
Vielen Dank an Fritz für die Zusendung. Ich hab mal die Helperklassen erweitert.

using System.Collections.Generic;
using System.Linq;
using Eplan.EplApi.DataModel;
using Eplan.EplApi.DataModel.Graphics;

namespace Suplanus.Sepla.Helper
{
	public class PlaceHolderUtility
	{
		/// <summary>
		/// Apply a record to placeholder by name
		/// </summary>
		/// <param name="placeHolders"></param>
		/// <param name="placeHolderName"></param>
		/// <param name="recordName"></param>
		/// <returns></returns>
		public bool ApplyRecord(PlaceHolder[] placeHolders, string placeHolderName, string recordName)
		{
			List<PlaceHolder> foundPlaceHolder = placeHolders
				.Where(placeHolder => placeHolder.Name.Equals(placeHolderName)) // name
				.Where(placeHolder => placeHolder.FindRecord(recordName) != -1) // record
				.ToList();

			using (Transaction transaction = new TransactionManager().CreateTransaction())
			{
				foreach (PlaceHolder placeHolder in foundPlaceHolder)
				{
					placeHolder.ApplyRecord(recordName, true); // apply (with page data)
					transaction.Commit(); // needed if not placed in project
				}
			}

			return foundPlaceHolder.Any(); // true == found | false == not found
		}

		/// <summary>
		/// Create a record to a placeHolder by name and apply a record
		/// </summary>
		/// <param name="placeHolders"></param>
		/// <param name="placeHolderName"></param>
		/// <param name="recordName"></param>
		/// <param name="variableName"></param>
		/// <param name="value"></param>
		/// <returns></returns>
		public bool CreateRecordWithValueAndApply(PlaceHolder[] placeHolders, string placeHolderName, string recordName, string variableName, string value)
		{
			List<PlaceHolder> foundPlaceHolder = placeHolders
				.Where(placeHolder => placeHolder.Name.Equals(placeHolderName)) // name
				.ToList();

			foreach (PlaceHolder placeHolder in foundPlaceHolder)
			{
				placeHolder.AddRecord(recordName);
				placeHolder.set_Value(recordName, variableName, value);
				using (Transaction transaction = new TransactionManager().CreateTransaction())
				{
					placeHolder.ApplyRecord(recordName, true); // apply (with page data)
					transaction.Commit(); // needed if not placed in project
				}
			}

			return foundPlaceHolder.Any(); // true == found | false == not found
		}
	}
}

Nochmals ein tolles API-Beispiel von Fritz, vielen Dank.

Arbeiten mit Formularen ist (mit dem Helper) nicht schwer!

using System.Collections.Specialized;
using Eplan.EplApi.DataModel;
using Eplan.EplApi.HEServices;

namespace Suplanus.Sepla.Helper
{
	public class MasterdataUtility
	{
		bool IsFormInProject(Project project, string formName)
		{
			return new Masterdata().get_ProjectEntries(project).Contains(formName);
		}

		bool IsFormInSystem(string formName)
		{
			return new Masterdata().SystemEntries.Contains(formName);
		}

		bool AddFormToProject(Project project, string formName)
		{
			Masterdata masterdata = new Masterdata();
			StringCollection newForms = new StringCollection();
			StringCollection projectForms = masterdata.get_ProjectEntries(project);

			if (!IsFormInSystem(formName))
			{
				return false;
			}

			if (!projectForms.Contains(formName))
			{				
				newForms.Add(formName);
				masterdata.AddToProjectEx(project, newForms);
			}
			return true;
		}
	}
}

Ich hab mir mal ne kleine API Methode um die Anzeigesprachen zu bekommen:

public static StringCollection DisplayLanguages()
{
	using (new LockingStep())
	{
		var project = ProjectUtility.GetCurrentProject();
		ProjectSettings projectSettings = new ProjectSettings(project);
		var displayLanguagesString = projectSettings.GetStringSetting("TRANSLATEGUI.DISPLAYED_LANGUAGES", 0);

		var languages = new StringCollection();
		var displaylanguages = displayLanguagesString.Split(';')
			.Where(s => !string.IsNullOrWhiteSpace(s)).Distinct().ToArray(); // remove empty
		languages.AddRange(displaylanguages);

		return languages;
	}
}

Habe mich hier für ne StringCollection entschieden, da man diese oft in der API braucht (z.B. Fehlwortliste exportieren).

Die benutzerdefinierten Eigenschaften… die Idee von EPLAN war gut, aber die Umsetzung ist in meinen Augen nicht optimal.

Nichts desto Trotz müssen wir damit leben und das auch in der API. Es ist nicht ganz so einfach wie mit den „normalen“ Eigenschaften.

Ich hab hier mal paar Methoden geschrieben um (Projekt-) Eigenschaften zu Lesen/Schreiben:

using System;
using System.Linq;
using Eplan.EplApi.Base;
using Eplan.EplApi.DataModel;

namespace Suplanus.Sepla.Helper
{
	public class UserDefiniedPropertyUtility
	{
		public static PropertyValue GetProjectPropertyValueAndCheckIfEmpty(Project project, string identName)
		{
			PropertyValue propertyValue = GetProjectPropertyValue(project, identName);
			if (propertyValue.IsEmpty)
			{
				return null;
			}
			return propertyValue;
		}

		public static PropertyValue GetProjectPropertyValue(Project project, string identName)
		{
			UserDefinedPropertyDefinition userDefProp = project.Properties.ExistingIds
				.Select(anyPropertyId => anyPropertyId.Definition)
				.OfType<UserDefinedPropertyDefinition>()
				.FirstOrDefault(obj => obj.IdentifyingName.Equals(identName));
			if (userDefProp != null)
			{
				AnyPropertyId anyPropertyId = userDefProp.Id;
				PropertyValue propertyValue = project.Properties[anyPropertyId];
				return propertyValue;
			}
			return null;
		}

		public static void SetProjectPropertyValue(Project project, string identName, object value)
		{
			PropertyValue propertyValue = GetProjectPropertyValue(project, identName);
			if (propertyValue != null)
			{
				if (value is bool)
				{
					propertyValue.Set((bool)value);
					return;
				}
				if (value is double)
				{
					propertyValue.Set((double)value);
					return;
				}
				if (value is MultiLangString)
				{
					propertyValue.Set((MultiLangString)value);
					return;
				}
				if (value is PointD)
				{
					propertyValue.Set((PointD)value);
					return;
				}
				if (value is int)
				{
					propertyValue.Set((int)value);
					return;
				}
				if (value is string)
				{
					propertyValue.Set((string)value);
					return;
				}
				if (value is DateTime)
				{
					propertyValue.Set((DateTime)value);
					return;
				}

				throw new Exception("Type not supported");
			}
			throw new Exception("Property not found");
		}
	}
}

Bei der Version 2.4 sind in EPLAN benutzerdefinierte Eigenschaften hinzugekommen.
Erst habe ich mich gefreut. Leider gibt es mit diesen Eigenschaften viele Probleme. Übernimmt man z.B. aus einer alten Versionen einen Schaltplan, hat man keine Möglichkeit mehr den Namen zu ändern.

Darum habe ich mir eine kleine API-Erweiterung geschrieben welche eine Übernahme über eine Mapping-Tabelle macht.
Man kann festlegen welche Eigenschaft zu welcher konvertiert werden soll.

Es kann auch angegeben werden ob Werte nach der Konvertierung gelöscht werden sollen oder nicht.

SetUserDefProp

Die Betaversion für EPLAN 2.6 ist nun verfügbar und ich schreibe hier mal was ich bzgl. Scripting aus den News und der Hilfe lesen konnte.

Die Actions

CreateTopologyFunctions

Folgende Actions sind nun (offiziell) hinzugekommen:

Die Action

projectmanagement

Projekt Korrigieren

/TYPE:CORRECTPROJECTITEMS
/SCHEME:"My scheme"

Projekt reorganisieren

/TYPE:REORGANIZE
/EXTENDEDMODE:1