---

Hallo zusammen,

Ich bin in der Eplan-Skriptingwelt ganz neu und hätte nun endlich eine Anwendung, um mich in das Thema richtig einzuarbeiten 

Schlussendlich möchte ich ein Skript haben, das ich aus Eplan heraus aufrufen kann, das mir die Seitenmakros 1.emp, 2.emp und 3.emp aus dem Verzeichnis D:\Makros\ ins Schema einfügt.

Inzwischen habe ich herausgefunden, dass der Action-Aufruf dazu XMInsertPageMacro lautet, bzw. XMInsertPageMacro /filename:"D:\Makros\1.emp"

Wie bastle ich mir nun das Skript zusammen, dass alle drei Makros nacheinander einfügt, und zwar jedesmal mit den Original-Seitenzuordnungen (ich möchte nicht im Dialog "Struktur anpassen" auf "Zurücksetzen" und "OK" klicken müssen) und der Einfügemodus soll auch mit "nicht verändern" bestätigt werden.

Kann mir dazu jemand Starthilfe geben?

Muss meinen Chef noch davon überzeugen, dass ich das Buch von Jonny Wire als Weihnachtsgeschenk bekomme 

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Puh,
da muss ich passen, weiß keinen Parameter.

Meines Wissens ist das nur mit der API möglich, dort kannst du auch den Namen bestimmen.

Gruß
Jonny

------------------
Suplanus.de - Scripting in Eplan ist einfach (toll)

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Jonny,

Hmmm, und mal abgesehen vom automatischen Bestätigen der Fenster würde es klappen?

Also Skript erstellen, Skript laden/ausführen, Dialogfenster öffnen sich -> bestätigen und fertig?

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Jo einfach eine Schleife (z.B. foreach) über die Makros machen und alle nacheinander einfügen.

------------------
Suplanus.de - Scripting in Eplan ist einfach (toll)

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo,

auch wenn dieser Beitrag nun schon etwas älter ist, würde ich das Thema doch noch gerne erneut aufgreifen.
Hast du zufällig ein Beispiel Script, in dem die Makros über foreach eingefügt werden?

Ich möchte gerne drei Seitenmakros einfügen, aber wie kann ich das Script so gestalten, dass ein Makro eingefügt wird und das nächste erst eingefügt wird, wenn die Einstellungen für das vorige Makro abgeschlossen sind? 

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Function.txt

Hat sich erledigt, ich hatte nur nen Tippfehler im Code.

Aber jetzt stehe ich vor dem nächsten Problem.

Leider übernimmt mein Script die Änderungen für den ersten Plan im Seitennavigator anstatt für den zuletzt geöffneten.

Anbei ein Ausschnitt aus meinem Code, mir der entsprechenden Funktion.

Ich Rufe diese Funktion dann beim Klick auf den OK Button meiner Forms Anwendung auf.

Zuvor wird eine Vorauswahl via ComboBox getroffen.

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo,
damit beim Einfügen die Orginal-Seitenzuordnung von EPLAN ausgewählt wird, muss vor dem Einfügen des Seitenmakros eine Seite ausgewählt sein.
Mit dem Befehl "Edit" kann eine Seite, die immer verwendet wird, wie zum Beispiel das Deckblatt geöffnet werden. Bevor über das Script das/ die Seitenamkros geladen werden. So muss das Dialogfenster nur mit OK bestätigt werden und nicht auf die korrekte Seitenzuordnung geachtet werden.
.
.
.
CommandLineInterpreter eBefehlszeile = new CommandLineInterpreter();
ActionCallingContext eParameter = new ActionCallingContext();

eParameter.AddParameter("PAGENAME", "&EFS=A1+MP01/1");
eParameter.AddParameter("FORMAT", "XDLTxtImporterExporter");
eParameter.AddParameter("X", "0");
eParameter.AddParameter("Y", "0");

eBefehlszeile.Execute("edit", eParameter);
.
.
.
Laden des Seitenmakros 

[Diese Nachricht wurde von Kolb1234 am 02. Dez. 2015 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Zusammen,
ich bin relativ neu im Skripting in EPLAN.
Ich würde mir gerne viele verschiedene Seitenmakros erstellen und die in einem Verzeichnis ablegen. Das einfache einfügen eines Seitenmakros funktioniert schon. Jedoch würde ich noch gerne den Seitennamen bzw. die Struktur im Skript vorgeben, an welchem Ort und welcher Funktion die Seite eingefügt werden muss.
Mein langfristiges Ziel wäre, dass ich in einer Excel eine Vorkonfiguration einer Anlage machen kann, also verschieden Zylindern und Motoren schon das BMK zuweisen kann. Diese Excel würde ich dann als CSV, später evtl. auch als XML abspeichern.
Diese CSV lese ich über Skript aus (funktioniert schon), das richtige Makro wird schon gefunden, bloß ich habe aktuell keine Möglichkeit den vorkonfigurierten Seitennamen beim Einfügen zu setzen. Die Seite wird in einer ganz flachen Struktur mit 1, 2, 3, usw. eingefügt.
Gibt es eventuell auch eine Möglichkeit, nachdem die Seite eingefügt wurde, nochmal auf die Parameter zuzugreifen und diese im Nachhinein zu ändern?
Ich wäre sehr dankbar, wenn ich ein paar Tipps bekommen würde.
Vielleicht ist seit 2012 wieder einiges mehr möglich im Scripting bzw. vielleicht kann man es ja auch mit APIs umsetzen?
Vielen Dank schon mal für Eure Unterstützung und Tipps.
Viele Grüße
Jonas

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

hallo,

das seitenmakro mit variablen erstellen:

z.b:  XXX statt des nalagenkennzeichens
YYY statt des ortkennzeichens.

vor dem import der seitenmakros diese kopieren und in den kopien XXX und YYY mit den gewünschten werten ersetzen, dan den import starten.

------------------
ruplan4.70
eplan5.x
P8 V1.9 bis V2.7

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Jonas

dieser Code könnte hierbei von nützen sein:

Update 15/05/23:
- Fehler beseitigt und neue Funktion: Zusammenführung der Dateien eingefügt.
- Ist aber nur ein Snippet und braucht noch ein wenig Geschick um es zum laufen zu bringen. Deshalb im Thread kopiert.
- Typicals, CSV-Daten und Resultat im Anhang. (alles Text Format)

Mit freundlichem Gruß

Code:

---

/*
    -------------------------------------------------------------------------------------------------------------------------------------------------------------------
    This snippet merges data into multiple typicals to create new files.
    The data is read from a list (e.g. Data2drawing.csv) that is built up according to a certain structure.
    The first line must contain the letters "V2.4" in the first field. The next fields are the placeholder descriptions.
    The second line contains the placeholders without prefix (<X) nor suffix (>). These placeholders are searched for in the copied macros
    then replaced with the value in the same column from line 3 and following. If a placeholder contains "!" it is not searched for.
    There should be a placeholder with the value "Macroname" in line 2. In line 3 and following, this column should contain the name of the typical (source).
    From line 3 on, you will find the data that must be merged into the page macros. Lines containing an "!" in the first column are skipped by the routine.
 
   
    1  2              3              4            5      6     
    The basic structure of the control list is therefore as follows:
    -------------------------------------------------------------------------------------------------------------------------------------------------------------------
    V2.4  FunDesig      column3          LocDesig  column5  Typical      ! line 1 : description of the placeholders
    ID  word1        word2            (word3)  word4    Macroname    ! line 2 : placeholders that must also appear in the typicals (between prefix and suffix)
    1  The          quick            brown    fox      Horizontal  ! line 3 : line 3 to ..... data, each line becomes a page macro
    2  jumps        over            the lazy      dog      Vertical    ! line 4
    -------------------------------------------------------------------------------------------------------------------------------------------------------------------   
        this will create the files =The+brown_1.??? and jumps+a lazy_2.???
    The placeholder "word3" will be replaced with the value of column 4 (Typical).
    -------------------------------------------------------------------------------------------------------------------------------------------------------------------
    Typical Horizontal:
    <XV2.4> <Xword1> <Xword2> <XHorizontal> <Xword4> : <XHorizontal> is converted to : 1 The quick brown fox : brown in file =The+brown_1.???
    -------------------------------------------------------------------------------------------------------------------------------------------------------------------
    Typical Vertical:
    <XV2.4>            is converted to :  2
    <Xword1>                            jumps
    <Xword2>                            over
    <XVertical>                        a lazy
    <Xword4>                            dog        in file =jumps+a lazy_2.???
    -------------------------------------------------------------------------------------------------------------------------------------------------------------------

    If selected, all files generated will be packed in 1 file.
    The typical must-have the following structure:
    -------------------------------------------------------------------------------------------------------------------------------------------------------------------
    HEADER
    EOH

    body with placeholders

    BOF
    FOOTER
    -------------------------------------------------------------------------------------------------------------------------------------------------------------------
    */
    {
        // Declare variables and constants
        // Here are some parameters you may want to change
        string typical_name_Ext = ".txt";
        bool filetype_XML = true;
        string strFilename = "Data2drawing"; // This is the default name of the data list
        string Fileident = "V2.4"; // This identifier must be in the beginning of the dataset
        string data_delimiter = "\t"; // TAB
        //string data_delimiter = ";"; // semicolon
        string Prefix = "<X";
        string Suffix = ">";
        string endOfHeader = "EOH";
        string beginOfFooter = "BOF";
        string mergedFile = "All";
        bool concatenateAll = true;

#if SCRIPTENV // Is this valid in scripting?
        // Use these folders for debugging with visual studio
        string sMacropath_Typicals = @"C:\Temp\Typicals\";
        string sMacropath_Tags = @"C:\Temp\Typicals\Tags\";
        string strProjectpath = @"C:\Temp\Typicals\";
#else
        // First thing to do: create this folders
        // Use these folders with eplan scripting
        string sMacropath_Typicals = PathMap.SubstitutePath("$(MD_MACROS)") + @"\Typicals\";
        string sMacropath_Tags = PathMap.SubstitutePath("$(MD_MACROS)") + @"\Typicals\Tags\";
        // This is the path where the data list is located
        string strProjectpath = PathMap.SubstitutePath("$(MD_MACROS)") + @"\Typicals\";
#endif

        // Initialize variables
        int row_counter = 0;
        int col_counter = 0;
        int Index_macroname = 0;
        int tag_counter = 0;
        int dummy_counter = 0;
        int var_counter = 0;
        string dataset_name = strFilename + ".csv";
        string[][] dataset;
        string[] dataset_line;
        string typical_name_page = "";
        string typical_name = "";  // Name of the file that serves as the source
        string tagname = "";  // File name of the macro being created including path
        string pagename = "";  // File name of the macro created without a path
        string tagnumber = "";  // Tag number from the index list
        string errorcode = "";
        string page_is_unique = "";
        string missing_typical = "";
        //bool test_typical_is_missing = false;

        // code
        List<string> typical_is_unique = new List<string>
        {
            "Summary Typicals"
        };

        List<string> IsDummy = new List<string>
        {
            "Missing Typicals"
        };

        // Prompt to open a data list
        OpenFileDialog ofd = new OpenFileDialog();
        ofd.DefaultExt = "csv";
        ofd.FileName = strFilename;
        ofd.Filter = "All Data Files (*.csv)|*.csv";
        ofd.InitialDirectory = strProjectpath;
        ofd.Title = "Select data set:";
        ofd.ValidateNames = true;

        if (ofd.ShowDialog() == DialogResult.OK)
        // The data list is selected
        {
            strFilename = ofd.FileName;
        }
        dataset_name = strFilename;

        // Start the chronometer
        DateTime startingtime = DateTime.UtcNow;

        // The data list exists, find the second line and test the delimiter
        dataset_line = File.ReadAllLines((dataset_name));
        if (dataset_line[1].Contains(data_delimiter))
        {
            dataset = File.ReadAllLines((dataset_name))
            .Select(line => line.Split(data_delimiter.ToCharArray()).ToArray()).ToArray();
        }
        else  // The delimiter is not correct
        {
            errorcode = "The data delimiter is not correct ";
            goto error;
        }

        // Count lines and columns
        row_counter = dataset.GetLength(0);
        col_counter = dataset[1].GetLength(0);

        // The data list contains too few lines
        if (row_counter < 3)
        {
            errorcode = "The data list contains too few lines ";
            goto error;
        }

        // The identifier in the first column of the first line is not correct
        if (dataset[0][0] != Fileident)
        {
            errorcode = "The identifier in the first column of the first line is not correct ";
            goto error;
        }

        Index_macroname = System.Array.IndexOf(dataset[1], "Macroname");

        // The second line does not contain: 'Macroname'
        if (Index_macroname == -1)
        {
            errorcode = "The second line does not contain: 'Macroname' ";
            goto error;
        }

        // The Data list is usable, first create new folder
        string myTime = System.DateTime.Now.ToString("yyyy_MM_dd");
        string hour = System.DateTime.Now.Hour.ToString();
        string minute = System.DateTime.Now.Minute.ToString();
        string seconde = System.DateTime.Now.Second.ToString();
        string timestamp = (myTime + "_" + hour + "_" + minute + "_" + seconde);
        string strDestination = (sMacropath_Tags + timestamp);
        Directory.CreateDirectory(strDestination);

        // Complete file path
        sMacropath_Tags = strDestination + @"\";

        // Create a batch file to copy the unique macros, used to simplify the testing of the typicals
        using (System.IO.StreamWriter batchfile1 = new System.IO.StreamWriter(sMacropath_Tags + "uni.bat", true))
        {
            batchfile1.WriteLine("cd ..");
            batchfile1.WriteLine("del *" + typical_name_Ext);
            batchfile1.WriteLine("cd " + sMacropath_Tags);
        }

        // Create Batch File to copy all macros
        using (System.IO.StreamWriter batchfile2 = new System.IO.StreamWriter(sMacropath_Tags + "all.bat", true))
        {
            batchfile2.WriteLine("cd ..");
            batchfile2.WriteLine("del *" + typical_name_Ext);
            batchfile2.WriteLine("cd " + sMacropath_Tags);
            batchfile2.WriteLine("copy *" + typical_name_Ext + " ..");
        }
#if !SCRIPTENV
        // This part only works in an eplan script
        // Create pop-up screen with progress bar -
        Progress oProgress = new Progress("SimpleProgress");
        oProgress.SetAllowCancel(false);
        oProgress.SetAskOnCancel(false);
        oProgress.SetNeededSteps(row_counter);
        oProgress.SetOverallActionText("System.String");
        oProgress.SetTitle("EplanMerger");
        oProgress.ShowImmediately();
        if (!oProgress.Canceled())
#endif
        {
            //  Preprocessing of the data file
            for (int i = 0; i < col_counter; i++)
            {
                dataset[1][i] = Prefix + dataset[1][i] + Suffix; // Add pre- and suffix to the second line of the dataset
            }
            // Escape the data if the typical is in XML format
            if (filetype_XML)
            {
                for (int j = 1; j < row_counter; j++)
                {
                    for (int i = 0; i < col_counter; i++)
                    {
                        dataset[j][i] = dataset[j][i].Replace("&", "&").Replace("<", "<").Replace(">", ">").Replace("\"", """).Replace("'", "'");
                    }
                }
                Prefix = Prefix.Replace("&", "&").Replace("<", "<").Replace(">", ">").Replace("\"", """).Replace("'", "'");
                Suffix = Suffix.Replace("&", "&").Replace("<", "<").Replace(">", ">").Replace("\"", """).Replace("'", "'");
            }

            // Process all data lines of the data file: merging data and creating new files
            for (int j = 2; j < row_counter; j++)
            {
                //test_typical_is_missing = false;

                // Skip lines that contain '!' in the first column  or typicalname is "na"
                if (dataset[j][0].Contains("!") == false & dataset[j][Index_macroname] != "na")
                {
                    tagnumber = (dataset[j][1] + dataset[j][2] + dataset[j][3] + dataset[j][4]);
                    typical_name = "none";

                    // Replace place holder in line 2 column 4 with the name of the Typical
                    dataset[1][3] = Prefix + dataset[j][Index_macroname] + Suffix;

                    // Create name of the page or window macro
                    typical_name_page = sMacropath_Typicals + dataset[j][Index_macroname] + typical_name_Ext;
                    typical_name = typical_name_page;

                    // Count Number of Tags
                    tag_counter++;

                    // The requested macro does not exist: use dummy
                    if (!File.Exists(typical_name))
                    {
                        // Update list of missing typicals
                        if (!IsDummy.Contains(dataset[j][Index_macroname]))
                        {
                            IsDummy.Add(dataset[j][Index_macroname]);
                        }

                        // Using the Dummy macro
                        missing_typical = dataset[j][Index_macroname];
                        dataset[1][3] = Prefix + "Dummy" + Suffix;
                        typical_name = sMacropath_Typicals + "Dummy" + typical_name_Ext;
                        //test_typical_is_missing = true;
                        dummy_counter++;
                        errorcode = "Some typicals are missing!: " + "\n";
                    }

                    // The name of the file created without the path. Maybe you would like to change this
                    pagename = "=" + dataset[j][1] + "+" + dataset[j][3] + "_" + dataset[j][0] + typical_name_Ext;

                    // Create full name of the file
                    tagname = sMacropath_Tags + pagename;

                    // Update the list of unique page numbers, needed to create subpages if needed
                    if (!page_is_unique.Contains(pagename))
                    {
                        page_is_unique = page_is_unique + ";" + pagename;
                    }
                    else
                    {
                        errorcode = "At least 1 page number is not unique, concatenation is impossible";
                    }
                    //
                    // If the file already exists, it will be renamed
                    if (File.Exists(tagname))
                    {
                        //File.Delete(tagname);
                        pagename = "=" + dataset[j][1] + "+" + dataset[j][3] + "_" + dataset[j][0] + "_" + j + typical_name_Ext;
                        tagname = sMacropath_Tags + pagename;
                        //concatenateAll = false; // Skip concatenation if desired
                    }

                    // Update the list of unique Typicals and extend the batch file
                    if (!typical_is_unique.Contains(dataset[j][Index_macroname]))
                    {
                        typical_is_unique.Add(dataset[j][Index_macroname]);

                        using (System.IO.StreamWriter batchfile1 = new System.IO.StreamWriter(sMacropath_Tags + "uni.bat", true))
                        {
                            batchfile1.WriteLine("copy \"" + pagename + "\" ..");
                        }

                    }

                    // Show tag number above the progress bar
#if !SCRIPTENV
                    oProgress.SetActionText(tagnumber);
#endif

                    // Routine for replacing the placeholders with the data from the dataset
                    string sReplace = "";
                    string Placeholder = "";

                    StreamReader srReplace = new StreamReader(typical_name, System.Text.Encoding.UTF8);
                    sReplace = srReplace.ReadToEnd();

                    // Count the number of placeholders
                    var_counter = col_counter;

                    // Write time to file
                    sReplace = sReplace.Replace((Prefix + "TIME_STAMP" + Suffix), timestamp);

                    //Replace all placeholders
                    for (int i = 0; i < col_counter; i++)
                    {
                        // Skip columns containing "!' in the second row of the dataset
                        if (dataset[1][i].Contains("!") == false)
                        {
                            Placeholder = dataset[1][i];
                            sReplace = sReplace.Replace(Placeholder, dataset[j][i]);
                        }
                        else
                        {
                            var_counter--;
                        }
                    }
                    //Write new macrofile
                    srReplace.Close();
                    StreamWriter swReplace = new StreamWriter(tagname);
                    swReplace.Write(sReplace);
                    swReplace.Close();
                }
#if !SCRIPTENV
                oProgress.Step(1);
#endif
            }
            //end of loop
        }
#if !SCRIPTENV
        oProgress.EndPart(true);
#endif

    //error handling
    error:;
        //Stop stopwatch
        DateTime finish = DateTime.UtcNow;
        MessageBox.Show("Runtime: " + (finish - startingtime).TotalSeconds + " seconds" +
            System.Environment.NewLine + errorcode +
            System.Environment.NewLine +
            System.Environment.NewLine + "Number of files generated: " + tag_counter +
            System.Environment.NewLine + "including dummies: " + dummy_counter +
            System.Environment.NewLine + "number of placeholders: " + var_counter, "Notifications");
        // logfile schrijven
        using (System.IO.StreamWriter logfile = new System.IO.StreamWriter(sMacropath_Tags + "merger.log", true))
        {
            logfile.WriteLine("Runtime: " + (finish - startingtime).TotalSeconds + " seconds");
            logfile.WriteLine("Number of files generated: " + tag_counter + " including " + dummy_counter + " with dummy");
            logfile.WriteLine(" ");
            logfile.WriteLine("Number of placeholders: " + var_counter);
            logfile.WriteLine(dataset_name);
            logfile.WriteLine(" ");
            logfile.WriteLine("Concatenate: " + concatenateAll);
            logfile.WriteLine(" ");

            typical_is_unique.ForEach(delegate (String name1)
            {
                logfile.WriteLine(name1);
            });
            logfile.WriteLine(" ");
            IsDummy.ForEach(delegate (String name)
            {
                logfile.WriteLine(name);
            });
            logfile.WriteLine(" ");
            logfile.WriteLine("Fault: " + errorcode);
        }

        // Concatenate files
        if (concatenateAll)
        {
            // Declare Variables and constants
            string errorTracer = "";
            string allTypicals;
            string Header;
            string Body;
            string Footer = "";
            string LResult;
            string[] Total;
            string[] stringSeparators = new string[2];

            try
            {
                errorTracer = " Erase existing file ";
                // Concatenate files.
                allTypicals = sMacropath_Tags + mergedFile + typical_name_Ext;
                //Erase file if exists
                if (File.Exists(allTypicals))
                {
                    File.Delete(allTypicals);
                }
                errorTracer = " Build separator ";
                stringSeparators[0] = endOfHeader + "\r\n";
                stringSeparators[1] = beginOfFooter;

                //Initiate filecounter
                int i = 1;
                //Find files to concatenate
                errorTracer = " Scan folder ";
                string[] strFile = Directory.GetFiles(sMacropath_Tags, "*" + typical_name_Ext);
                errorTracer = " Itinerate files ";
                foreach (string name in strFile)
                {
                    if (name == allTypicals)
                    {
                        // nop
                    }
                    else
                    {
                        //Open file
                        StreamReader srReplace = new StreamReader(name, System.Text.Encoding.UTF8);
                        string sReplace = srReplace.ReadToEnd();
                        srReplace.Close();

                        if (i == 1) //First file save header and body
                        {
                            errorTracer = "Split file on " + endOfHeader + " and " + beginOfFooter;
                            Total = sReplace.Split(stringSeparators, StringSplitOptions.None);
                            Header = Total[0] + stringSeparators[0];
                            Body = Total[1];
                            Footer = beginOfFooter + Total[2];
                            LResult = Header + Body;
                            //Save data
                            errorTracer = " Write file ";
                            StreamWriter swAll = new StreamWriter(allTypicals, append: true, Encoding.UTF8);        //Encoding.UTF8
                            swAll.Write(LResult);
                            swAll.Flush();
                            swAll.Close();
                        }
                        else //rest of files save body only
                        {
                            //Total = sReplace.Split(charendOfHeader);
                            errorTracer = "Split file on " + endOfHeader + " and " + beginOfFooter;
                            Total = sReplace.Split(stringSeparators, StringSplitOptions.None);
                            Body = Total[1];
                            //compose data for output
                            LResult = Body;
                            //Save data
                            errorTracer = " Write file ";
                            StreamWriter swAll = new StreamWriter(allTypicals, append: true, Encoding.UTF8);        //Encoding.UTF8
                            swAll.Write(LResult);
                            swAll.Flush();
                            swAll.Close();
                        }
                    }
                    //Prepare for next file
                    i += 1;
                }
                //All files done, add footer
                LResult = Footer;
                //Save data
                errorTracer = " Write file ";
                StreamWriter swReplace = new StreamWriter(allTypicals, append: true, Encoding.UTF8);        //Encoding.UTF8
                swReplace.Write(LResult);
                swReplace.Flush();
                swReplace.Close();
                MessageBox.Show((i - 1) + " files concatenated");
                // end concatenate

            }
            catch (Exception excep)
            {
                MessageBox.Show(excep.Message, "Error " + errorTracer);
            }
        }
        Process.Start(sMacropath_Tags); // Open new folder
    }// end of function

---

[Diese Nachricht wurde von TyDaLo am 15. Mai. 2023 editiert.]

[Diese Nachricht wurde von TyDaLo am 16. Mai. 2023 editiert.]

[Diese Nachricht wurde von TyDaLo am 22. Mai. 2023 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Zusammen,
Vielen Dank für Eure Vorschläge und dem vielversprechenden Code. Ich werde es demnächst ausprobieren und halte Euch auf dem Laufenden.
Viele Grüße
Jonas

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Sehr cool, im Prinzip möchtest Du, wahrscheinlich kennst Du das gar nicht mehr, EEC One nachbauen. Da bin ich schon gespannt, wie weit Du da mit Skripting kommst.

Ich hab die Geschichte mal anders angegangen und hab mit, natürlich mit/über die API ein MiniUI gebaut, wo ich aber auch Wertesätze und Strukturkennzeichen manipulieren kann; sicher auch auf ganz einfach, aber schon mit ein bißchen Funktionalität.

Video dazu

------------------
sind doch alles nur Nuller und Einser :-) !!!

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo TyDaLo

Zitat:

---

Original erstellt von TyDaLo:
...

Update 15/05/23:
- Fehler beseitigt und neue Funktion: Zusammenführung der Dateien eingefügt.
- Ist aber nur ein Snippet und braucht noch ein wenig Geschick um es zum laufen zu bringen. Deshalb im Thread kopiert.
- Typicals, CSV-Daten und Resultat im Anhang. (alles Text Format)
...

---

Ist damit der Kommentar am Anfang des Codes gemeint oder übersehe ich einen Download Link?

Gruß RednaxelW

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo apps4eplan,

Zitat:

---

Original erstellt von apps4eplan:
Sehr cool, im Prinzip möchtest Du, wahrscheinlich kennst Du das gar nicht mehr, EEC One nachbauen. Da bin ich schon gespannt, wie weit Du da mit Skripting kommst.

Ich hab die Geschichte mal anders angegangen und hab mit, natürlich mit/über die API ein MiniUI gebaut, wo ich aber auch Wertesätze und Strukturkennzeichen manipulieren kann; sicher auch auf ganz einfach, aber schon mit ein bißchen Funktionalität.

Video dazu

---

Ok, auch 

Jonas kann mit API doch in einem Skript nichts anfangen, oder doch?

Bietest Du dann "EEC One" made by apps4eplan an?

Gruß Alex

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

API und Skript sind ja zwei grundverschiedene Welten; natürlich hab ich die unterschiedlichsten API-Methoden in der Zwischenzeit bei uns im Einsatz, wie halt zB: das im Video gezeigte; daraus mehr zu machen ist ja grundsätzlich kein Problem, aber da geh ich halt dann sehr bald in Richtung EEC Prof, weil ich da halt ALLE Freiheiten habe und keinen API-Code entwickeln muss!

------------------
sind doch alles nur Nuller und Einser :-) !!!

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo, ich weiß nicht ob es noch hilfreich ist, aber wir haben das bei uns ohne API gelöst um eine Art Schaltplan-Generator umzusetzen.
Vorausschicken will ich gleich mal, dass es dabei um Standardmaschinen geht. Die Seiten werden unverändert eingefügt, es werden keine
Seitennamen, Projektstrukturen oder BMK's auf den Seiten angepasst.
Wir haben für unsere Serienmaschinen Makroprojekte, die Seitenmakros in die vorab definierte Ordnerstruktur ablegt.
Über das Skript öffnen wir eine Windows Form, in der über Drop-Downs, usw. die Optionen ausgewählt werden können.
Mit dem "Ok-Klick" werden dann die dazugehörigen Makros in den Ordnern gesucht.
Um zu vermeiden, den Einfüge-Dialog zig-fach zu durchlaufen, lesen wir aus den einzelnen Makros die Informationen aus und fügen sie
in ein "Gesamtmakro" zusammen, dieses wird dann in das leere Vorlagenprojekt importiert.
Das klappt für unsere Bedürfnisse sehr gut, wenn man jetzt noch die Seiten-Struktur vor ab verändern will, geht das auch, ist aber auf jeden Fall noch mal einiges zu Programmieren um die Makros dann wie vorhin schon beschrieben zu lesen und umzuschreiben.
Würde aber bestimmt funktionieren.

------------------
Eplan P8 2.9 SP1

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Servus Zusammen,
mittlerweile bin ich schon vorangekommen. Ich habe als Grundlage die Idee des eingestellten Codes verwendet. Mittlerweile ist meine Testmatrix CSV Datei 50 Spalten breit und 1700 Zeilen lang.
Wir machen gerade Tests wo wir die Seitenstruktur, Seitenname, Seitenbeschreibung, verschiedene BMKs, Artikelnummern und Funktionstexte reingenerieren. Bei SPS Seiten wie Übersichtsseiten zur ET200SP habe ich zum Test mal Startadressen, CPU Namen, Stationsnamen alles was dazugehört, reingeneriert.
Der angepasste Code fügt die Einzelnen Seitenmakros zu großen Mehrseitenmakros zusammen XML, damit man im EPLAN nicht jede einzelne Seite manuell einfügen und mit Ok bestätigen muss. Bei EPLAN V2.9 sind ca 600 Seiten in einem Mehrseitenmakro fast das Limit, weil es dann sehr unperformant wird. Bei EPLAN 2023 sind die 600 Seiten überhaupt kein Problem.
Die 1700 Seiten werden auf ca eine Viertel Stunde generiert, aber das kann noch varieren, je nach dem, wie viele Platzhalter später in einem Seitenmakro ersetzt werden.
Wir wollen dann in Zukunft mit Wertesätzem bzw Platzhaltern arbeiten.

Es gibt noch ein Problem mit den Wertesätzen. Ich hinterlege in dem Seitenmakro in dem zugehörigen Feld eine Vorauswahl für den Wertesatz. Beim Einfügen des Makros muss dann je nach EPLAN Einstellung der Wertesatz gleich bestätigt werden, oder man kann die Seite so einfügen und dann auf der jeweiligen Seite den Werttesatz setzen. Über den Platzhalternavigator kann man es schon noch bündelweise mit dem gleichen Wertesatzvorauswahl setzen aber ich muss noch schauen, dass man es evtl mit sendKeys lösen kann, aber bin noch zu keinem Erfolg gekommen, weil das Send Leys eigentlich erst aufgerufen wird, wenn die Funktion zum Einfügen des Mehrseitenmakros ausgeführt ist…

Wenn die nächsten Erfolge kommen, melde ich mich wieder.
Viele Grüße
Jonas

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Servus Zusammen,
mittlerweile bin ich schon vorangekommen. Ich habe als Grundlage die Idee des eingestellten Codes verwendet. Mittlerweile ist meine Testmatrix CSV Datei 50 Spalten breit und 1700 Zeilen lang.
Wir machen gerade Tests wo wir die Seitenstruktur, Seitenname, Seitenbeschreibung, verschiedene BMKs, Artikelnummern und Funktionstexte reingenerieren. Bei SPS Seiten wie Übersichtsseiten zur ET200SP habe ich zum Test mal Startadressen, CPU Namen, Stationsnamen alles was dazugehört, reingeneriert.
Der angepasste Code fügt die Einzelnen Seitenmakros zu großen Mehrseitenmakros zusammen XML, damit man im EPLAN nicht jede einzelne Seite manuell einfügen und mit Ok bestätigen muss. Bei EPLAN V2.9 sind ca 600 Seiten in einem Mehrseitenmakro fast das Limit, weil es dann sehr unperformant wird. Bei EPLAN 2023 sind die 600 Seiten überhaupt kein Problem.
Die 1700 Seiten werden auf ca eine Viertel Stunde generiert, aber das kann noch varieren, je nach dem, wie viele Platzhalter später in einem Seitenmakro ersetzt werden.
Wir wollen dann in Zukunft mit Wertesätzem bzw Platzhaltern arbeiten.

Es gibt noch ein Problem mit den Wertesätzen. Ich hinterlege in dem Seitenmakro in dem zugehörigen Feld eine Vorauswahl für den Wertesatz. Beim Einfügen des Makros muss dann je nach EPLAN Einstellung der Wertesatz gleich bestätigt werden, oder man kann die Seite so einfügen und dann auf der jeweiligen Seite den Werttesatz setzen. Über den Platzhalternavigator kann man es schon noch bündelweise mit dem gleichen Wertesatzvorauswahl setzen aber ich muss noch schauen, dass man es evtl mit sendKeys lösen kann, aber bin noch zu keinem Erfolg gekommen, weil das Send Leys eigentlich erst aufgerufen wird, wenn die Funktion zum Einfügen des Mehrseitenmakros ausgeführt ist…

Wenn die nächsten Erfolge kommen, melde ich mich wieder.
Viele Grüße
Jonas

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Zitat:

---

Original erstellt von fency:
Hallo, ich weiß nicht ob es noch hilfreich ist, aber wir haben das bei uns ohne API gelöst um eine Art Schaltplan-Generator umzusetzen.
Vorausschicken will ich gleich mal, dass es dabei um Standardmaschinen geht. Die Seiten werden unverändert eingefügt, es werden keine
Seitennamen, Projektstrukturen oder BMK's auf den Seiten angepasst.
Wir haben für unsere Serienmaschinen Makroprojekte, die Seitenmakros in die vorab definierte Ordnerstruktur ablegt.
Über das Skript öffnen wir eine Windows Form, in der über Drop-Downs, usw. die Optionen ausgewählt werden können.
Mit dem "Ok-Klick" werden dann die dazugehörigen Makros in den Ordnern gesucht.
Um zu vermeiden, den Einfüge-Dialog zig-fach zu durchlaufen, lesen wir aus den einzelnen Makros die Informationen aus und fügen sie
in ein "Gesamtmakro" zusammen, dieses wird dann in das leere Vorlagenprojekt importiert.
Das klappt für unsere Bedürfnisse sehr gut, wenn man jetzt noch die Seiten-Struktur vor ab verändern will, geht das auch, ist aber auf jeden Fall noch mal einiges zu Programmieren um die Makros dann wie vorhin schon beschrieben zu lesen und umzuschreiben.
Würde aber bestimmt funktionieren.

---

Hallo fency,

ich habe auch versucht ein Seitenmakro aus mehreren Seitenmakros zusammen zu kopieren...
Es funktioniert auch beim einfügen, nur gibts ein Problem mit gleichen Seitenmakros.

Beispiel: Seite "Netzteil" hab ich 3x reinkopiert. Die erste eingefügte Seite von den 3 ist genauso wie davor erstellt. Bei den folgenden Seiten verschieben sich plötzlich Texte, Formate, Positionen der Querverweise, Funktionstexte usw. Also es tritt nur bei den folgenden "gleichen" Seitenmakros auf.

Gibts da ein Trick beim zusammenkopieren?
Das Wichtigste ist wohl das 04-Element in der .emp Datei. Das kopiere ich mir auch raus.
Wenn alle Seiten unterschiedlich sind, dann gibts auch keine Probleme  

[Diese Nachricht wurde von Partyarti am 02. Aug. 2023 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Zitat:

---

Original erstellt von Partyarti:

Hallo fency,

ich habe auch versucht ein Seitenmakro aus mehreren Seitenmakros zusammen zu kopieren...
Es funktioniert auch beim einfügen, nur gibts ein Problem mit gleichen Seitenmakros.

Beispiel: Seite "Netzteil" hab ich 3x reinkopiert. Die erste eingefügte Seite von den 3 ist genauso wie davor erstellt. Bei den folgenden Seiten verschieben sich plötzlich Texte, Formate, Positionen der Querverweise, Funktionstexte usw. Also es tritt nur bei den folgenden "gleichen" Seitenmakros auf.

Gibts da ein Trick beim zusammenkopieren?
Das Wichtigste ist wohl das 04-Element in der .emp Datei. Das kopiere ich mir auch raus.
Wenn alle Seiten unterschiedlich sind, dann gibts auch keine Probleme   

[Diese Nachricht wurde von Partyarti am 02. Aug. 2023 editiert.]

---

Ach... nach 20x hin und her probieren funktioniert es mit "MacroVariant" statt dem "04"-Element

Falls es jemanden juckt wie ich die Seitenmakros zusammenführe:
Habe einen Konfigurator geschrieben der Pfade von Seitenmakros in eine "Seitenmakros.txt" Datei schreibt und dieser Code fasst mir alles zusammen. Alles ohne API

Beschreibung Code:

Copying Files: The code first copies a base macro file located at basePageMacroPath to the specified storage location (editedBasePageMacroPath). If there are any errors during the copy operation, an error message will be displayed using MessageBox.

Reading Paths: The code reads paths of page macros from a file named "SeitenMakros.txt" located in the specified storage location. If the file is not found, an error message will be displayed using MessageBox.

Adding MacroVariants: For each path read from "SeitenMakros.txt," the code creates copies of the macro, adding a suffix "_1", "_2", and so on, depending on how many copies are needed. The XML contents of each macro are then read, and the "MacroVariant" elements are extracted and stored in the listAllMacroVariantElements.

Updating Base Macro: The code loads the edited base macro file (editedBasePageMacroPath) as an XML document. It searches for the last occurrence of the "MacroVariant" element and inserts all the elements from listAllMacroVariantElements after it. If there are no "MacroVariant" elements in the base macro, the elements are appended to the end of the document. Additionally, it updates the attributes "NumMainObjects" and "NumProjectSteps" at the root level of the XML document with the total count of added "MacroVariant" elements.

Saving Changes: Finally, the updated XML content is saved back to the edited base macro file using baseMacroXmlDoc.Save. If any errors occur during the file saving process, they will be displayed using MessageBox.

The code essentially takes a base macro file and adds "MacroVariant" elements from multiple source macros (specified in "SeitenMakros.txt") to it. The result is saved in the edited base macro file. If any errors occur during the file operations, appropriate error messages are shown using MessageBox.

Code:

---

public static void InsertPageMacro(string pathEmpStorageLocation)
{
    int totalAddedMacroVariants = 0; // To track the total number of added "MacroVariant" elements

    // List to store all "MacroVariant" elements
    List<string> listAllMacroVariantElements = new List<string>();

    // Path to the base macro file
    string basePageMacroPath = @"YOUR EMPTY BASE PAGE MACRO.emp";

    // Destination path for the edited base macro file
    string editedBasePageMacroPath = Path.Combine(pathEmpStorageLocation, Path.GetFileName(basePageMacroPath));

    try
    {
        // Copy the base macro file to the specified storage location
        File.Copy(basePageMacroPath, editedBasePageMacroPath, true); // true overwrites the file if it already exists
    }
    catch (IOException ex)
    {
        // Show an error message in case of copy errors
        MessageBox.Show($"Error copying the file '{basePageMacroPath}': {ex.Message}");
        return;
    }

    // Read paths of page macros from the file "YOUR FILE.txt"
    string seitenMakrosFilePath = Path.Combine(pathEmpStorageLocation, "YOUR FILE.txt");
    if (File.Exists(seitenMakrosFilePath))
    {
        var lines = File.ReadAllLines(seitenMakrosFilePath);

        // Now iterate over the lines and add the "MacroVariant" elements accordingly
        foreach (var line in lines)
        {
            string sourceFilePath = line; // The path of the macro

            for (int i = 0; i < 1; i++) // Change 1 to create more copies of the macro
            {
                string copiedMacroPath = Path.Combine(pathEmpStorageLocation, string.Format("{0}_{1}.emp", Path.GetFileNameWithoutExtension(sourceFilePath), i + 1));

                try
                {
                    File.Copy(sourceFilePath, copiedMacroPath, true); // true overwrites the file if it already exists
                }
                catch (IOException ex)
                {
                    // Show an error message in case of copy errors
                    MessageBox.Show($"Error copying the file '{sourceFilePath}': {ex.Message}");
                    continue; // Continue to the next iteration if an error occurs
                }

                // Load the XML document
                XmlDocument xmlDoc = readXmlDoc(copiedMacroPath);

                // Extract "MacroVariant" elements from the XML and add them to listAllMacroVariantElements
                XmlNodeList macroVariantNodes = xmlDoc.GetElementsByTagName("MacroVariant");
                foreach (XmlNode macroVariantNode in macroVariantNodes)
                {
                    listAllMacroVariantElements.Add(macroVariantNode.OuterXml); // Add the entire "MacroVariant" element
                    totalAddedMacroVariants++; // Increment the counter for added "MacroVariant" elements
                }
            }
        }
    }
    else
    {
        // If the file is not found, display an error message
        MessageBox.Show("Error: The file was not found: " + seitenMakrosFilePath);
    }

    // Save the updated content to editedBasePageMacroPath
    XmlDocument baseMacroXmlDoc = new XmlDocument();
    baseMacroXmlDoc.Load(editedBasePageMacroPath);

    // Search for the last occurrence of "MacroVariant"
    XmlNodeList lastMacroVariantNodes = baseMacroXmlDoc.GetElementsByTagName("MacroVariant");
    if (lastMacroVariantNodes.Count > 0)
    {
        XmlNode lastMacroVariantNode = lastMacroVariantNodes[lastMacroVariantNodes.Count - 1];

        // Add the "MacroVariant" elements after the last "MacroVariant" element
        foreach (var macroVariantElement in listAllMacroVariantElements)
        {
            XmlNode newNode = baseMacroXmlDoc.ImportNode(XmlFromString(macroVariantElement), true);
            lastMacroVariantNode.ParentNode.InsertAfter(newNode, lastMacroVariantNode);
        }
    }
    else
    {
        // If no "MacroVariant" element is found, add the "MacroVariant" elements at the end
        XmlNode rootNode = baseMacroXmlDoc.DocumentElement;
        foreach (var macroVariantElement in listAllMacroVariantElements)
        {
            XmlNode newNode = baseMacroXmlDoc.ImportNode(XmlFromString(macroVariantElement), true);
            rootNode.AppendChild(newNode);
        }
    }

    // Now update the second line of baseMacroXmlDoc
    if (baseMacroXmlDoc.DocumentElement.ChildNodes.Count > 1)
    {
        // Find the root element of the XML document
        XmlElement rootElement = baseMacroXmlDoc.DocumentElement;

        // Update the attributes "NumMainObjects" and "NumProjectSteps" at the root level
        XmlAttribute numMainObjectsAttr = rootElement.Attributes["NumMainObjects"];
        XmlAttribute numProjectStepsAttr = rootElement.Attributes["NumProjectSteps"];

        if (numMainObjectsAttr != null && numProjectStepsAttr != null)
        {
            // Set the number of added "MacroVariant" elements to both attributes
            numMainObjectsAttr.Value = totalAddedMacroVariants.ToString();
            numProjectStepsAttr.Value = totalAddedMacroVariants.ToString();
        }
    }

    baseMacroXmlDoc.Save(editedBasePageMacroPath);
}

#region Helper methods
private static XmlNode XmlFromString(string xmlString)
{
    XmlDocument doc = new XmlDocument();
    doc.LoadXml(xmlString);
    return doc.DocumentElement;
}

private static XmlDocument readXmlDoc(string xml)
{
    if (!string.IsNullOrEmpty(xml))
    {
        StreamReader streamReader = new StreamReader(xml);
        XmlSerializer xmlSerializer = new XmlSerializer(typeof(XmlDocument));
        XmlDocument xmlDocument = (XmlDocument)xmlSerializer.Deserialize(streamReader);
        streamReader.Close();
        return xmlDocument;
    }
    else
        return null;
}
#endregion

---

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP