refactor of internal code for better loading of Lists if plugins dont want

full preprocess, also stripped some unneeded legacy-code

iZpl/src/main/java/de/nplusc/izc/iZpl/API/FeaturePlugin.java

@@ -30,4 +30,16 @@ public interface FeaturePlugin extends Plugin
      * Opens the UI if #hasConfigureScreen() returned true;
      */
     public void openUserInterface();
+    
+    
+    
+    /**
+     * Checks whether a file / statefile has to be loaded for this plugin to work
+     * @return true if needed
+     */
+    
+    public default boolean requiresLoadedPlayList()
+    {
+        return true;
+    }
 }

iZpl/src/main/java/de/nplusc/izc/iZpl/API/IZPLApi.java

@@ -7,11 +7,9 @@
 package de.nplusc.izc.iZpl.API;
 
 import de.nplusc.izc.iZpl.Main;
-import de.nplusc.izc.iZpl.Utils.PLReader;
+import de.nplusc.izc.iZpl.Utils.PLReader2;
 import java.awt.Image;
 import java.io.File;
-import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 
 /**
@@ -156,15 +154,9 @@ public class IZPLApi
         return System.console()!=null;
     }
    
-    public List<PlayListItem> readPlayList(String path)
-    {
-        List<PlayListItem> rv = new ArrayList<>();
-        HashMap<String,PlayListItem> temp = PLReader.readListAlternative(path, 1, 1, true);
-        for (String string : temp.keySet())
-        {
-            rv.add(temp.get(string));
-        }
-        return rv;
+    public List<SinglePlayListItem> readPlayList(String path) throws InvalidPlayListFileException
+    {
+        return PLReader2.readSingleList(path);
     }
     
 }

iZpl/src/main/java/de/nplusc/izc/iZpl/API/InvalidPlayListFileException.java

@@ -0,0 +1,16 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package de.nplusc.izc.iZpl.API;
+
+/**
+ *
+ * @author iZc <nplusc.de>
+ */
+public class InvalidPlayListFileException extends Exception
+{
+    
+}

iZpl/src/main/java/de/nplusc/izc/iZpl/API/MultiPlayListItem.java

@@ -15,17 +15,16 @@ import java.util.Objects;
  */
 public class MultiPlayListItem implements PlayListItem
 {
-    private List<PlayListItem> containedElements;
+    private List<PlayListItem> containedElements=new ArrayList<>();
     
     private int playcount,countPlayed;
-    private String src;
+    private String src="";
     
     public MultiPlayListItem(){};
     
     
     public MultiPlayListItem(String[] path, String[] Title, int playcount)
     {
-        
         for (int i = 0; i < Title.length; i++)
         {
             String t = Title[i];
@@ -41,10 +40,14 @@ public class MultiPlayListItem implements PlayListItem
         return containedElements;
     }
     
-    
-    public void addTitle(String ppath,String ptitle)
+    public void setItems(List<PlayListItem>p)
     {
-        containedElements.add(new SinglePlayListItem(ppath, ptitle, 1));
+        containedElements=p;
+    }
+
+    public void addItem(PlayListItem e)
+    {
+        containedElements.add(e);
     }
     
     public void removeElement(int i)
@@ -83,12 +86,12 @@ public class MultiPlayListItem implements PlayListItem
         }
         return "";
     }
-
-    /*public void setTitle(String Title, int i)
+        
+    
+    public void addTitle(String ppath,String ptitle)
     {
-        this.
-        this.Title.add(i,Title);
-    }*/
+        containedElements.add(new SinglePlayListItem(ppath, ptitle, 1));
+    }
 
     @Override
     public int getTargetPlaycount()
@@ -194,5 +197,11 @@ public class MultiPlayListItem implements PlayListItem
         }
         return (SinglePlayListItem[]) l.toArray(new SinglePlayListItem[]{});
     }
+
+    @Override
+    public int getGID()
+    {
+       return 0;
+    }
     
 }

iZpl/src/main/java/de/nplusc/izc/iZpl/API/PlayListItem.java

@@ -17,4 +17,6 @@ public interface PlayListItem
     public void setCountPlayed(int countPlayed);
     public boolean isIncludeElement(); //erweiterung um daten durchzuschleusen für die TreeView
     public boolean noexpandoninclude();
+    public int getGID();
+    
 }

iZpl/src/main/java/de/nplusc/izc/iZpl/API/SinglePlayListItem.java

@@ -15,8 +15,14 @@ public class SinglePlayListItem implements PlayListItem
     private String path,Title;
     private int targetplaycount,countPlayed;
     private boolean include,noexpandoninclude;
-    
-    public SinglePlayListItem(){};
+    private int gid=0;
+    public SinglePlayListItem()
+    {
+    targetplaycount=1;
+    Title="";
+    path="";
+    countPlayed=0;
+    };
     
     public SinglePlayListItem(String path, String Title, int playcount)
     {
@@ -75,6 +81,7 @@ public class SinglePlayListItem implements PlayListItem
         this.countPlayed = countPlayed;
     }
     
+    @Override
     public String getM3UElement()
     {
         return "\n"+Title+"\n"+path;
@@ -104,11 +111,7 @@ public class SinglePlayListItem implements PlayListItem
         {
             return false;
         }
-        if (!Objects.equals(this.Title, other.Title))
-        {
-            return false;
-        }
-        return true;
+        return Objects.equals(this.Title, other.Title);
     }
 
     @Override
@@ -122,4 +125,23 @@ public class SinglePlayListItem implements PlayListItem
     {
         return noexpandoninclude;
     }
+    
+    public void setIncludeElements(boolean isInclude,boolean noExpand)
+    {
+        include=isInclude;
+        noexpandoninclude=noExpand;
+    }
+    
+    
+    public void setGID(int pgid)
+    {
+        gid=pgid;
+    }
+    
+    
+    @Override
+    public int getGID()
+    {
+        return gid;
+    }
 }

iZpl/src/main/java/de/nplusc/izc/iZpl/Main.java

@@ -54,7 +54,6 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.core.LoggerContext;
 import org.apache.logging.log4j.core.config.LoggerConfig;
-import org.apache.logging.log4j.core.util.ShutdownCallbackRegistry;
 import org.apache.logging.log4j.io.IoBuilder;
 import org.yaml.snakeyaml.Yaml;
 
@@ -907,7 +906,7 @@ public class Main extends javax.swing.JFrame
             //http://localhost:9263/lst.m3u
             if (isShittyPlayer || forcePregen)
             {
-                PlProcessor ppp = new PlProcessor();
+                PlProcessorV2 ppp = new PlProcessorV2();
                 ppp.InitializeOnPath(file_path);
                 if (issueDetected)
                 {

iZpl/src/main/java/de/nplusc/izc/iZpl/PlProcessor.java

@@ -4,19 +4,7 @@
  */
 package de.nplusc.izc.iZpl;
 
-import de.nplusc.izc.iZpl.Utils.PLReader;
-import com.sun.net.httpserver.Headers;
-import com.sun.net.httpserver.HttpExchange;
-import com.sun.net.httpserver.HttpHandler;
-import de.nplusc.izc.iZpl.API.IZPLApi;
-import de.nplusc.izc.tools.IOtools.FileTK;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.net.InetSocketAddress;
 import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.prefs.Preferences;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.yaml.snakeyaml.Yaml;
@@ -25,16 +13,16 @@ import org.yaml.snakeyaml.Yaml;
  *
  * @author LH
  */
-public class PlProcessor implements HttpHandler 
+public class PlProcessor //implements HttpHandler 
 {
     private static final Logger l = LogManager.getLogger();
     private ArrayList<String[]> pool1=new ArrayList<>(),pool2=new ArrayList<>();//wird verschoben so dass jedes Element drankommt und dann erst von vorne begonnen wird
     private int poolSize=0;
     private int unusedElems=0;
     private String path;
-   /* public PlProcessor(String PlPath)
-    {
-    }*/
+    private static Yaml yp = new Yaml();
+    
+    public static String failRSP = "http://localhost:9263/lst.m3u";
       //<editor-fold defaultstate="collapsed" desc=" Serialisierunbgsscheissss ">
     public ArrayList<String[]> getPool1()
     {
@@ -105,16 +93,18 @@ public class PlProcessor implements HttpHandler
     {
         PlProcessor.failRSP = failRSP;
     }
-    //</editor-fold>
     
     
+    //</editor-fold>
+    
+    /*
     public void InitializeOnPath(String PlPath)
     {
         path=PlPath;
         reloadLists();
     }
     
-    private static Yaml yp = new Yaml();
+    
     public void reloadLists()
     {
         reloadLists(false);
@@ -212,7 +202,7 @@ public class PlProcessor implements HttpHandler
         }
     }
     
-    public static String failRSP = "http://localhost:9263/lst.m3u";
+    
     
     
     @Override
@@ -228,7 +218,7 @@ public class PlProcessor implements HttpHandler
         os.write(response.getBytes());
         os.close();
         return;
-        }*/
+        }* /
         response = "#EXTM3U";
                 //  \N am anfang jeder zeile....
         String tr = getBlock();
@@ -278,6 +268,6 @@ public class PlProcessor implements HttpHandler
         }
         response=response.replaceAll("\\\n\\\n", "\\\n");
         return response;
-    }
+    }*/
 }
 

iZpl/src/main/java/de/nplusc/izc/iZpl/PlProcessorV2.java

@@ -5,10 +5,10 @@
 package de.nplusc.izc.iZpl;
 
 import de.nplusc.izc.iZpl.API.PlayListItem;
-import de.nplusc.izc.iZpl.Utils.PLReader;
 import com.sun.net.httpserver.Headers;
 import com.sun.net.httpserver.HttpExchange;
 import com.sun.net.httpserver.HttpHandler;
+import de.nplusc.izc.iZpl.Utils.PLReader2;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.ArrayList;
@@ -31,7 +31,6 @@ public class PlProcessorV2 implements HttpHandler
     private String path;
     private List<String> availEtrs;
     private PlayListItem forced=null;
-
     /* public PlProcessor(String PlPath)
     {
     }*/
@@ -84,7 +83,7 @@ public class PlProcessorV2 implements HttpHandler
 
     public static void setFailRSP(String failRSP)
     {
-        PlProcessor.failRSP = failRSP;
+        PlProcessorV2.failRSP = failRSP;
     }
     //</editor-fold>
     
@@ -109,13 +108,40 @@ public class PlProcessorV2 implements HttpHandler
     public void reloadLists(boolean reload)
     {
         availEtrs = new ArrayList<>();//cache flush and reinit...
+        List<PlayListItem> inp = PLReader2.parseFullList(path);
         if(!reload)
         {
-            pool=PLReader.readListAlternative(path, 40, 1);
+            pool=new HashMap<>();
+            for (PlayListItem item : inp)
+            {
+                String itemID=item+"";
+                if(!pool.containsKey(itemID))
+                {
+                    pool.put(itemID, item);
+                }
+                else
+                {
+                    PlayListItem u2d=pool.get(itemID);
+                    u2d.setTargetPlaycount(u2d.getTargetPlaycount()+item.getTargetPlaycount());
+                }
+            }
         }
         else
         {
-            HashMap<String,PlayListItem> poolTemp = PLReader.readListAlternative(path, 40, 1);
+            HashMap<String,PlayListItem> poolTemp=new HashMap<>();
+            for (PlayListItem item : inp)
+            {
+                String itemID=item+"";
+                if(!poolTemp.containsKey(itemID))
+                {
+                    poolTemp.put(itemID, item);
+                }
+                else
+                {
+                    PlayListItem u2d=poolTemp.get(itemID);
+                    u2d.setTargetPlaycount(u2d.getTargetPlaycount()+item.getTargetPlaycount());
+                }
+            }
             Set<String> keys = pool.keySet();
             for (String key : keys)
             {
@@ -238,5 +264,13 @@ public class PlProcessorV2 implements HttpHandler
         response=response.replaceAll("\\\n\\\n", "\\\n");
         return response;
     }
+    
+    
+    
+    
+    public int getPoolSize()
+    {
+        return availEtrs.size();
+    }
 }
 

iZpl/src/main/java/de/nplusc/izc/iZpl/Utils/BurnMe.java

@@ -4,27 +4,14 @@
  */
 package de.nplusc.izc.iZpl.Utils;
 
-import de.nplusc.izc.iZpl.Utils.PLReader;
-import com.coremedia.iso.IsoFile;
-import de.nplusc.izc.iZpl.extensions.BurnLiistManager;
 import de.nplusc.izc.iZpl.extensions.BurnProgressGUI;
 import de.nplusc.izc.tools.IOtools.FileTK;
 import de.nplusc.izc.tools.baseTools.Messagers;
 import de.nplusc.izc.tools.baseTools.Tools;
 import de.nplusc.izc.tools.baseTools.arraytools;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.nio.channels.ReadableByteChannel;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 import java.util.prefs.Preferences;
-import javax.sound.sampled.AudioFileFormat;
-import javax.sound.sampled.AudioFormat;
-import javax.sound.sampled.AudioInputStream;
-import javax.sound.sampled.AudioSystem;
-import javax.sound.sampled.UnsupportedAudioFileException;
 import javax.swing.JFrame;
 import javax.swing.JProgressBar;
 import javax.swing.JTextArea;
@@ -99,6 +86,8 @@ public class BurnMe
     
     public static void InitializeBurnDisc(String srcpath)
     {
+        //TODO REMAKE
+        /*
         Configure();
         List<String[]> data = PLReader.readList(srcpath, true);
         List<String[]> rawList = new ArrayList<>();//2. element gint GruppenID an//3. die TrackLänge //in tabelle spalte 4 = disk#
@@ -175,8 +164,10 @@ public class BurnMe
         if(rawList.size()==0)
             return; //nicht weitermachen bei leerer liste
         //handing over to stage 2 aka the Ordering
-        new BurnLiistManager(rawList).setVisible(true);   
+        new BurnLiistManager(rawList).setVisible(true);    
+        */
     }
+   
     private static BurnProgressGUI bpg;
     private static List<List<String[]>> disks;
     public static void burnDisk(List<String[]> tracks)
@@ -203,55 +194,44 @@ public class BurnMe
         bpg = new BurnProgressGUI();
         bpg.setVisible(true);
         
-        new Thread(
-            new Runnable()
+        new Thread(() ->
+        {
+            int disksToDo = disks.size();
+            int done =0;
+            JProgressBar status = bpg.getDiskProgress();
+            status.setMaximum(disksToDo);
+            JTextArea logg = bpg.getLogPane();
+            for (List<String[]> list : disks)
             {
-
-                @Override
-                public void run()
+                //Tools.runSingleCmd(true, true, true, true, logg, new String[]{"ping","google.de"});
+                FileTK.ensuredirExistence(Tools.processEnvVarsinLine("%temp%\\izpl\\burncache\\cache.map"));
+                String[] filesForCmd = new String[list.size()];
+                for (int i = 0; i < list.size(); i++)
                 {
-                    //manage Burrn itself
-                    int disksToDo = disks.size();
-                    int done =0;
-                    JProgressBar status = bpg.getDiskProgress();
-                    status.setMaximum(disksToDo);
-                    JTextArea logg = bpg.getLogPane();
-                    for (List<String[]> list : disks)
-                    {
-                        //Tools.runSingleCmd(true, true, true, true, logg, new String[]{"ping","google.de"});
-                        FileTK.ensuredirExistence(Tools.processEnvVarsinLine("%temp%\\izpl\\burncache\\cache.map"));
-                        String[] filesForCmd = new String[list.size()];
-                        for (int i = 0; i < list.size(); i++)
-                        {
-                            String[] set = list.get(i);
-                            String fn = FileTK.getFileName(set[0]);
-                            filesForCmd[i] = Tools.processEnvVarsinLine("%temp%\\izpl\\burncache")+"\\"+fn+".wav";
-                            //ffmpeg -i input.xxx -acodec pcm_s16le -ac 2 -f wav output.wav
-                            Tools.runSingleCmd(true, true, true, true, logg, new String[]{ffmpegpath+"\\ffmpeg","-i",set[0],"-acodec","pcm_s16le","-ar","44100","-ac", "2",/* "-f", "wav ",*/ filesForCmd[i]});
-                        }
-                        done++;
-                        status.setValue(done);
-                        //Toasten cdrecord -v dev=ATAPI:0,0,0 -audio -pad *.wav
-                        String[] temp = arraytools.concatAll( new String[]{burnprogP+"\\cdrecord","-v","dev="+devideID,"-audio","-pad"},filesForCmd);
-                        
-                        //System.out.println(arraytools.ArrayKleben(temp, " "));
-                        String t2 = "";
-                        for (String string : temp)
-                        {
-                            t2+=" "+string;
-                        }
-                        
-                        l.trace(t2);
-                        //Tools.runSingleCmd(true, true, true, true, logg,temp);
-                        //FileTK.verzeichnisKillen(new File(Tools.processEnvVarsinLine("%temp%\\izpl\\burncache\\")));
-                    }
-                    
-                    
-                    
-                    //Builder.quickQuit();
+                    String[] set = list.get(i);
+                    String fn = FileTK.getFileName(set[0]);
+                    filesForCmd[i] = Tools.processEnvVarsinLine("%temp%\\izpl\\burncache")+"\\"+fn+".wav";
+                    //ffmpeg -i input.xxx -acodec pcm_s16le -ac 2 -f wav output.wav
+                    Tools.runSingleCmd(true, true, true, true, logg, new String[]{ffmpegpath+"\\ffmpeg","-i",set[0],"-acodec","pcm_s16le","-ar","44100","-ac", "2",/* "-f", "wav ",*/
+                        filesForCmd[i]});
+                }
+                done++;
+                status.setValue(done);
+                //Toasten cdrecord -v dev=ATAPI:0,0,0 -audio -pad *.wav
+                String[] temp = arraytools.concatAll( new String[]{burnprogP+"\\cdrecord","-v","dev="+devideID,"-audio","-pad"},filesForCmd);
+                
+                //System.out.println(arraytools.ArrayKleben(temp, " "));
+                String t2 = "";
+                for (String string : temp)
+                {
+                    t2+=" "+string;
                 }
+                
+                l.trace(t2);
+                //Tools.runSingleCmd(true, true, true, true, logg,temp);
+                //FileTK.verzeichnisKillen(new File(Tools.processEnvVarsinLine("%temp%\\izpl\\burncache\\")));
             }
-        ).start();
+        }).start();
         
         //ffmpeg -i input.xxx -acodec pcm_s16le -ac 2 -f wav output.wav
         

iZpl/src/main/java/de/nplusc/izc/iZpl/Utils/PLReader.java

@@ -1,550 +0,0 @@
-/*
- * To change this template, choose Tools | Templates
- * and open the template in the editor.
- */
-package de.nplusc.izc.iZpl.Utils;
-
-import de.nplusc.izc.iZpl.API.MultiPlayListItem;
-import de.nplusc.izc.iZpl.API.PlayListItem;
-import de.nplusc.izc.iZpl.API.SinglePlayListItem;
-import de.nplusc.izc.iZpl.Main;
-import de.nplusc.izc.tools.IOtools.FileTK;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Set;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.yaml.snakeyaml.Yaml;
-
-/**
- *
- * @author LH
- */
-public class PLReader
-{
-    
-    private static final Logger l = LogManager.getLogger();
-    
-    //Formatdefinition //basiert aufne verpackte #extm3u
-    /*
-    * #EXTM3U
-    * #iZPl
-    * #EXTINFO.......//Die VLC-Daten
-    * #IZPL:PrioMultiplier|GroupID (IDS !=0 sind Verbunden. 0er immer einzeln)
-    * /Pfad/zu/File1.mp3
-    * //Defaultet zu 1,0 falls nicht gefunden
-    * #IZPL:INCLUDE|PrioMultiplier|Expand//INCLUDE sagt dass hier ne referenzierte IZPL liegt Expand sagt Liste kann aufgeteilt werden
-    * /Pfad/zu/andererListe.iZpl //prioMultiplier bei include mutipliziert Multiopliers des Includes
-    * #IZPL:INCLUDE|PrioMultiplier|NoExpand //NoExpand sagt dass File Als ein Block behandelt werden muss (Includes innerhalb werden auch beachtet aber keine multiplizierungen eingebaut
-    * /Pfad/zu/UnsplittbarerListe.iZpl
-    */
-    private static Yaml yp = new Yaml();
-    public static List<String[]> readList(String path)
-    {
-        return (readList(path,0));
-    }
-    
-    public static List<String[]> readList(String path,boolean priorityLess)
-    {
-        return readList(path, 0, priorityLess);
-    }
-    
-    public static List<String[]> readList(String path,int rd)
-    {
-        return readList(path, rd, false);
-    }
-    
-    
-    public static List<String[]> readList(String path,int rd,boolean priorityLess)
-    {
-    
-        HashMap<Integer,List<String>> GroupStorage = new LinkedHashMap<>();
-        List<String[]> BloxBuffr = new ArrayList<>();
-        List<String[]> mergedLists = new ArrayList<>();
-        String[] playListRaw = FileTK.fileload(path);//temporär ne bestimmte hardcoden
-        GroupStorage.put(0,new ArrayList<>());//MUSS_EXISTIEREN!!!
-        if(playListRaw.length<2)
-        {
-            Main.gotAIssue();
-            return null;
-        }
-        if(playListRaw[0].equals("#EXTM3U"))//&&playListRaw[1].equals("#IZPL"))//HEaderValidate
-        {
-            if(!playListRaw[1].equals("#IZPL"))
-            {
-                String[] block = new String[]{"","",""};
-                l.trace(">>EnterPlainPL");
-                for (int i = 1; i < playListRaw.length-1; i++)
-                {
-                    String line = playListRaw[i];
-                                        //@blox: 0 ist die extinf;1 die #IZPL-Zone 2 der filename
-                    if(line.startsWith("EXTINF:"))
-                    {
-                        block[0]=line;
-                        block[1]="#IZPL:1|0";
-                        i++;
-                        line = playListRaw[i];
-                        block[2]=line;
-                        BloxBuffr.add(block);
-                        block=new String[3];
-                    }
-                    else
-                    {
-                        block[0]="";
-                        block[1]="#IZPL:1|0";
-                        block[2]=line;
-                        BloxBuffr.add(block);
-                        block=new String[3];
-                    }
-                }
-            }
-            else
-            {
-                l.trace(">>EnteriIZinkedPL");
-                int bstart=0;
-                int bl=0;
-                String[] block  = new String[3];
-                for (int i = 2; i < playListRaw.length-1; i++)
-                {
-
-                    String line = playListRaw[i];
-                    if(line.startsWith("#EXTINF:"))
-                    {
-                        bl=3;
-                        bstart=i;
-                        block[0]=line;//EXTINF wird durchgepipe'd
-                    }
-                    else
-                    {
-
-                        if(bl>0)//IN_BLOCK
-                        {
-                            int it=i-bstart;
-                            l.trace(it+"");
-
-                            block[it]=line;
-                            if(bstart+bl-1==i)
-                            {
-                                BloxBuffr.add(block);
-                                block=new String[3];
-                                bl=0;
-                                bstart=0;
-                            }
-                        }
-                        else//START_BLOCK
-                        {
-                            bl=0;
-                            block[0]="";
-                            if(playListRaw[i+1].startsWith("#EXTINF")||playListRaw[i+1].startsWith("#IZPL"))//erkennen von undefineds
-                            {
-                                block[2]=line;
-                                block[1]="#IZPL:1|0";
-                            }
-                            else
-                            {
-                            block[1]=line;
-                            i++;
-                            block[2]=playListRaw[i];
-                            }
-                            BloxBuffr.add(block);
-                            block=new String[3];
-                        }
-                    }
-                }
-            }
-        }
-        int sublistsFound = 0;
-        for (String[] blox : BloxBuffr)//0 ist die extinf;1 die #IZPL-Zone 2 der filename
-                {
-            l.trace("|>"+blox[0]+"\n"+blox[1]+"\n"+blox[2]+"\n");
-            String[] metadata = blox[1].substring(6).split("\\|");
-            if(metadata[0].equalsIgnoreCase("INCLUDE"))//muss noch nen Detektor für NoExpand einbauen|erledigt
-            {
-                l.trace("<<< Include");
-                if(metadata[2].equalsIgnoreCase("NOEXPAND"))
-                {
-                    l.trace("<°())))<Include");
-                    int priomult=Integer.valueOf(metadata[1].trim());
-                    if(priorityLess)
-                        priomult=1;
-                    int runs = 0;
-                    while(runs<priomult)
-                    {
-                        sublistsFound++;
-                        String lfid = blox[2];
-                        if(!lfid.substring(1,2).equals(":"))//absoluterPfad
-                        {
-                            lfid=FileTK.getFilePath(path)+"\\"+lfid;
-                        }
-                        l.trace(lfid);
-                        List<String[]> subList = readList(lfid,rd+1,priorityLess);
-                        Main.gotAIssue(false);//überdeckt Sublisten-Errors bei Rekursion, da dann ja etwas zurückkommt
-                        List<String> target = new ArrayList<>();
-                        String[] group0 = subList.get(0);
-                        target.addAll(Arrays.asList(group0));//merged die Gruppe 0 die einzeleinträge enthält
-                        for (int i = 1; i < subList.size(); i++)
-                        {
-                            target.addAll(Arrays.asList(subList.get(i)));
-                        }
-                        GroupStorage.put((10000*sublistsFound)+1,target);
-                        runs++;
-                    }
-                    
-                }
-                else
-                {
-                    l.trace(">(((()°> Include");
-                    int priomult=Integer.valueOf(metadata[1].trim());
-                    if(priorityLess)
-                        priomult=1;
-                    int runs = 0;
-                    while(runs<priomult)
-                    {
-                        sublistsFound++;
-                        String lfid = blox[2];
-                        if(!lfid.substring(1,2).equals(":"))//absoluterPfad
-                        {
-                            lfid=FileTK.getFilePath(path)+"\\"+lfid;
-                        }
-                        l.trace(lfid);
-                        List<String[]> subList = readList(lfid,rd+1,priorityLess);
-                        Main.gotAIssue(false);//überdeckt Sublisten-Errors bei Rekursion, da dann ja etwas zurückkommt
-                        String[] group0 = subList.get(0);
-                        GroupStorage.get(0).addAll(Arrays.asList(group0));//merged die Gruppe 0 die einzeleinträge enthält
-                        for (int i = 1; i < subList.size(); i++)
-                        {
-                           List<String> target = Arrays.asList(subList.get(i));
-                           GroupStorage.put((10000*sublistsFound)+i,target);
-                        }
-                        runs++;
-                    }
-                    
-                }
-
-            }
-            else
-            {
-                int priomult=Integer.valueOf(metadata[0].trim());
-                if(priorityLess)
-                    priomult=1;
-                int gid=Integer.valueOf(metadata[1].trim());
-                if(!GroupStorage.containsKey(gid))
-                {
-                    GroupStorage.put(gid,new ArrayList<String>());
-                }
-                List<String> ge = GroupStorage.get(gid);
-                String entry = blox[0]+"\n"+blox[2];
-                for (int i = 0; i < priomult; i++)//setzt die Priorität um durch mehrfacheintragung.....
-                {
-                    l.trace(">>>"+entry);
-                    ge.add(entry);
-                }
-            }
-        }
-        List<String> gid0 = GroupStorage.get(0);
-        GroupStorage.remove(0);
-        String[] gtmp = new String[gid0.size()];
-        for (int i = 0; i < gid0.size(); i++)
-        {
-            gtmp[i]= gid0.get(i);
-            
-        }
-        mergedLists.add(gtmp);
-        Set<Integer> s = GroupStorage.keySet();
-        for (Integer k : s)
-        {
-           List<String> temp = GroupStorage.get(k); 
-           gtmp = new String[temp.size()];
-            for (int i = 0; i < gtmp.length; i++)
-            {
-                gtmp[i]=temp.get(i);
-            }
-            mergedLists.add(gtmp);
-        }
-        l.trace("NOP");
-        l.trace("ArrayResult of reading in:"+path);
-        l.trace("Depth:"+rd);
-        l.trace("\n"+yp.dump(mergedLists));//macht das log leichter parsbar in NPP mit Ansicht=yaml
-        l.trace("ENd of Block:"+path);
-        l.trace("###########################################################################");
-        l.trace("---------------------------------------------------------------------------");
-        l.trace("###########################################################################");
-
-        return mergedLists;
-    }
-   
-    
-    private static List<String[]> readListAlternativeNoexpandAux(String path,int rd)
-    {
-        List<String[]> retval = new ArrayList<>();
-        if(rd<0)//zählt runter um beliebigen startwert z erlauben :P
-        {
-            return retval;//leere hashmap :P
-        }
-        List<String[]> tempo = readListAlternativeAuxPrepare(path);
-        if(tempo!=null)
-        {
-            for (String[] elements : tempo)
-            {
-                String lfid=elements[0];
-                if(lfid==null||lfid.equals("null"))
-                {
-                   continue;
-                }
-                if(!lfid.substring(1,2).equals(":"))//absoluterPfad
-                {
-                    lfid=FileTK.getFilePath(path)+"\\"+lfid;
-                }
-                elements[0]=lfid;
-                
-                
-                String[] metadata=elements[2].substring(6).split("\\|");
-                if(metadata[0].equalsIgnoreCase("include"))
-                {
-                    l.trace("incl;"+elements[0]);
-                    retval.addAll(readListAlternativeNoexpandAux(elements[0], rd-1));
-                }
-                else
-                {
-                    retval.add(elements);
-                }
-            }
-        }
-         l.trace("ArrayResult of reading in as NoExpa:"+path);
-         l.trace("Depth:"+rd);
-         l.trace("\n"+yp.dump(retval));//macht das log leichter parsbar in NPP mit Ansicht=yaml
-         l.trace("ENd of Block:"+path);
-         l.trace("###########################################################################");
-         l.trace("---------------------------------------------------------------------------");
-         l.trace("###########################################################################");
-        
-        return retval;
-    }
-    
-    
-    
-    
-    
-    private static List<String[]> readListAlternativeAuxPrepare(String path)
-    {
-        String[] playListRaw = FileTK.fileload(path);//temporär ne bestimmte hardcoden
-        ArrayList<String> cleanup=new ArrayList<>();
-        for (String line : playListRaw)
-        {
-            if(line!=null&&!line.equals("")&&line.length()>4)
-            {
-                cleanup.add(line);
-            }
-        }
-        playListRaw=cleanup.toArray(playListRaw);
-        
-        ArrayList<String[]> tempo=new ArrayList<>();
-        if(playListRaw.length>=2 && playListRaw[0].equalsIgnoreCase("#EXTM3U")&&playListRaw[1].equalsIgnoreCase("#IZPL"))
-        {
-            String[] buffer = new String[3]; //0 path; 1=extm3u,2=izpl-data
-            int cntr=0;
-            // erste zwo zeilen überspringen...
-            // dann datei ummodeln...
-            for (int i = 2; i < playListRaw.length; i++)
-            {
-                l.trace(i);
-                String line = playListRaw[i];
-                if(line!=null)
-                {
-                    if(cntr==0&&line.startsWith("#EXTINF:"))
-                    {
-                        buffer[1]=line;
-                        cntr++;
-                    }
-                    else
-                    {
-                        if((cntr==1||cntr==0)&&line.startsWith("#IZPL:"))
-                        {
-                            buffer[2]=line;cntr++;
-                        }
-                        else
-                        {
-                            cntr=0;
-                            buffer[0]=line;               
-                            tempo.add(buffer);
-                            buffer = new String[3];//<<ARSCHLOCH hatte dich vergessen ...
-                            buffer[0]="";
-                            buffer[1]="";
-                            buffer[2]="#IZPL:1|0";
-                        }
-                    }
-                }
-            }
-        }
-        else
-        {
-            tempo=null;
-        }
-        return tempo;
-    }
-    public static HashMap<String,PlayListItem> readListAlternative(String path, int rd,int prioritybase)
-    {
-        return readListAlternative(path, rd, prioritybase, false);
-    }
-    
-    public static HashMap<String,PlayListItem> readListAlternative(String path, int rd,int prioritybase,boolean unexpandedIncludes)
-    {
-        HashMap<String,PlayListItem> retval = new LinkedHashMap<>();
-        if(rd<0)//zählt runter um beliebigen startwert z erlauben :P
-        {
-            return retval;//leere hashmap :P
-        }
-        
-        List<String[]> tempo = readListAlternativeAuxPrepare(path);
-        l.trace("##########################Raw List input##############################################");
-        l.trace(yp.dump(tempo));
-        l.trace("#####################End Raw List input###############################################");
-        
-        if(tempo!=null)
-        {
-            //\\//\\//
-            //0 pfad; 1=extinf;2=izpl;
-            //verarbeiten.....
-            HashMap<Integer,ArrayList<String[]>> groupprep = new LinkedHashMap<>();
-            //groupprep.put(0,new ArrayList<String[]>());
-            for (String[] elements : tempo)
-            {      
-                String lfid=elements[0];
-                if(lfid==null||lfid.equals("null"))
-                {
-                   continue;
-                }
-                if(!lfid.substring(1,2).equals(":"))//absoluterPfad
-                {
-                    lfid=FileTK.getFilePath(path)+"\\"+lfid;
-                }
-                elements[0]=lfid;
-                String[] metadata=elements[2].substring(6).split("\\|");
-                if(metadata[0].equalsIgnoreCase("include"))
-                {
-                    l.trace("Includebranch");                    
-                    if(metadata[2].equalsIgnoreCase("EXPAND"))
-                    {
-                        if(!unexpandedIncludes)
-                        {
-                            HashMap<String,PlayListItem> recurseret = readListAlternative(elements[0], rd-1, Integer.valueOf(metadata[1].trim()));//nätig in beiden fällen
-                            Set<String> keys= recurseret.keySet();
-                            for (String itemkey : keys)
-                            {
-                                PlayListItem pli = recurseret.get(itemkey);
-                                if(pli instanceof SinglePlayListItem)//multiitems instapasthru
-                                {
-                                    if(retval.containsKey(pli+""))
-                                    {
-                                        PlayListItem tpli = retval.get(pli+"");
-                                        tpli.setTargetPlaycount(tpli.getTargetPlaycount()+prioritybase*pli.getTargetPlaycount());
-                                    }
-                                    else
-                                    {
-                                        retval.put(pli+"",pli);
-                                    }
-                                }
-                                else
-                                {
-                                    retval.put(pli+"",pli);
-                                }    
-                            }
-                        }
-                        else
-                        {
-                            SinglePlayListItem includeList = new SinglePlayListItem(elements[0], FileTK.getFileName(elements[0]), Integer.valueOf(metadata[1].trim()), true,false);
-                            retval.put(includeList+"",includeList);
-                        }
-                    }
-                    else
-                    {
-                        if(!unexpandedIncludes)
-                        {
-                        MultiPlayListItem pli = new MultiPlayListItem(new String[]{}, new String[]{}, Integer.valueOf(metadata[1].trim())*prioritybase);
-                        //target der liste :P
-                        List<String[]> listraw = readListAlternativeNoexpandAux(elements[0], rd-1);
-                        for (String[] item : listraw)
-                        {
-                            pli.addTitle(item[0], item[1]);
-                        }
-                        pli.setSrc("Block from: "+elements[0]);
-                         retval.put(pli+"", pli);//multiItems sind nicht mit pfad referenziert...
-                        }
-                        else
-                        {
-                            SinglePlayListItem includeList = new SinglePlayListItem(elements[0], FileTK.getFileName(elements[0]), Integer.valueOf(metadata[1].trim()), true,true);
-                            retval.put(includeList+"",includeList);
-                        }
-                    }
-                    
-                }
-                else
-                {
-                    //1,0=fefault :P
-                    int gid = Integer.valueOf(metadata[1].trim());
-                    if(gid>0)
-                    {
-                        if(unexpandedIncludes)
-                            throw new UnsupportedOperationException("Anordnungsrelevante daten, kann nicht pasrsen fpür editor");
-                        if(!groupprep.containsKey(gid))
-                        {
-                            groupprep.put(gid,new ArrayList<String[]>());
-                        }
-                        List<String[]> groupcontent = groupprep.get(gid);
-                        groupcontent.add(elements);//kein dupecheck da liste auch widerholungen enthalten kann; dupecheck nur bei einzel da dort aufsummiert wird :P
-                    }
-                    else
-                    {
-                        PlayListItem it = new SinglePlayListItem(elements[0], elements[1], Integer.valueOf(metadata[0].trim())*prioritybase);
-                        if(retval.containsKey(it+""))//summieren...
-                        {
-                            it = retval.get(it+"");
-                            int cpc = it.getTargetPlaycount();
-                            it.setTargetPlaycount(cpc+(prioritybase*Integer.valueOf(metadata[0].trim())));//zusammenaddieren da unter dem =en path nur das selbe lied liegen kann also de-dupe
-                        }
-                        else
-                        {
-                            
-                            retval.put(it+"",it);
-                        }
-                    }
-                }
-            }
-            Set<Integer> keys = groupprep.keySet();
-            for (Integer i:keys)
-            {     
-                tempo=groupprep.get(i);                                                                         //HAXX
-                MultiPlayListItem pli = new MultiPlayListItem(new String[]{}, new String[]{}, prioritybase*Integer.valueOf(tempo.get(0)[2].substring(6).split("\\|")[1].trim()));
-                
-                for (String[] elem : tempo)
-                {
-                    String lfid=elem[0];
-                    if(!lfid.substring(1,2).equals(":"))//absoluterPfad
-                    {
-                        lfid=FileTK.getFilePath(path)+"\\"+lfid;
-                    }
-                    elem[0]=lfid;
-                    pli.addTitle(elem[0], elem[1]);
-                }
-                pli.setSrc("Group No "+i+" from file:"+path);
-                retval.put(pli+"", pli);//multiItems sind nicht mit pfad referenziert... außer NoexpandIncludes
-                
-            }
-        }
-        
-        l.trace("ArrayResult of reading in:"+path);
-        l.trace("Depth:"+rd);
-        l.trace("\n"+yp.dump(retval));//macht das log leichter parsbar in NPP mit Ansicht=yaml
-        l.trace("ENd of Block:"+path);
-        l.trace("###########################################################################");
-        l.trace("---------------------------------------------------------------------------");
-        l.trace("###########################################################################");
-        
-        return retval;
-    }
-    
-    
-}

iZpl/src/main/java/de/nplusc/izc/iZpl/Utils/PLReader2.java

@@ -0,0 +1,291 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package de.nplusc.izc.iZpl.Utils;
+
+import de.nplusc.izc.iZpl.API.InvalidPlayListFileException;
+import de.nplusc.izc.iZpl.API.MultiPlayListItem;
+import de.nplusc.izc.iZpl.API.PlayListItem;
+import de.nplusc.izc.iZpl.API.SinglePlayListItem;
+import de.nplusc.izc.iZpl.Main;
+import de.nplusc.izc.tools.IOtools.FileTK;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.yaml.snakeyaml.Yaml;
+
+/**
+ *
+ * @author iZc <nplusc.de>
+ */
+public class PLReader2
+{
+    //Formatdefinition //basiert aufne verpackte #extm3u
+    /*
+    * #EXTM3U
+    * #iZPl
+    * #EXTINFO.......//Die VLC-Daten
+    * #IZPL:PrioMultiplier|GroupID (IDS !=0 sind Verbunden. 0er immer einzeln)
+    * /Pfad/zu/File1.mp3
+    * //Defaultet zu 1,0 falls nicht gefunden
+    * #IZPL:INCLUDE|PrioMultiplier|Expand//INCLUDE sagt dass hier ne referenzierte IZPL liegt Expand sagt Liste kann aufgeteilt werden
+    * /Pfad/zu/andererListe.iZpl //prioMultiplier bei include mutipliziert Multiopliers des Includes
+    * #IZPL:INCLUDE|PrioMultiplier|NoExpand //NoExpand sagt dass File Als ein Block behandelt werden muss (Includes innerhalb werden auch beachtet aber keine multiplizierungen eingebaut
+    * /Pfad/zu/UnsplittbarerListe.iZpl
+    */
+    
+    
+    private static Yaml y = new Yaml();
+    private static final Logger l = LogManager.getLogger();
+    public static List<SinglePlayListItem> readSingleList(String path) throws InvalidPlayListFileException
+    {
+        l.trace("Location:{}",new File(path).getAbsolutePath());
+        try
+        {
+            boolean syntaxError=false;
+            BufferedReader fr = new BufferedReader(new FileReader(path));
+
+            if(!(fr.readLine().equalsIgnoreCase("#EXTM3U")))
+            {
+                l.error("Not a valid izpl or M3u-file");
+                return new ArrayList<>();
+            }
+            if(!fr.readLine().startsWith("#IZPL"))
+            {
+                l.info("plain M3u detected");
+            }
+            int lne=3;
+            ArrayList<SinglePlayListItem> returndata = new ArrayList<>();
+            String ln = fr.readLine();
+            boolean extinf=false;
+            SinglePlayListItem itm = new SinglePlayListItem();
+            while(ln!=null)
+            {
+                l.trace(ln);
+                if(ln.startsWith("#IZPL"))
+                {
+                    String[] meta = ln.split(":")[1].split("\\|");
+                    if(meta[0].equalsIgnoreCase("include"))
+                    {
+                        if(meta.length==3)
+                        {
+                            if(meta[2].equalsIgnoreCase("expand"))
+                            {
+                                itm.setIncludeElements(true, false);
+                            }
+                            else
+                            {
+                                if(meta[2].equalsIgnoreCase("noexpand"))
+                                {
+                                     itm.setIncludeElements(true, true);
+                                }
+                                else
+                                {
+                                    syntaxError=true;
+                                    l.error("Syntax error on line {} of file {}: {}",lne,path,"Include-Block haben nur Expand oder NoExpand als dritten block");
+                                    continue;
+                                }
+                            }
+                            try
+                            {
+                                int pr = Integer.valueOf(meta[1]);
+                                if(pr<1)
+                                {
+                                    throw new NumberFormatException();
+                                }
+                                itm.setTargetPlaycount(pr);
+                            }
+                            catch(NumberFormatException x)
+                            {
+                                syntaxError=true;
+                                l.error("Syntax error on line {} of file {}: {}",lne,path,"der 2. block bei Include muss eine positive Ganzzahl sein");
+                                itm.setTargetPlaycount(1);
+                            }
+                        }
+                        else
+                        {
+                            syntaxError=true;
+                            l.error("Syntax error on line {} of file {}: {}",lne,path,"Include-Block braucht 2 weitere blöcke um korrekt zu sein");
+                        }
+                    }
+                    else
+                    {
+                        if(meta.length==2)
+                        {
+                            try
+                            {
+                                int pr = Integer.valueOf(meta[0]);
+                                if (pr < 1)
+                                {
+                                    throw new NumberFormatException();
+                                }
+                                itm.setTargetPlaycount(pr);
+                            }
+                            catch (NumberFormatException x)
+                            {
+                                syntaxError = true;
+                                l.error("Syntax error on line {} of file {}: {}", lne, path, "Block1 muss eine Ganzzahl > 0 sein");
+                                itm.setTargetPlaycount(1);
+                            }
+                            try
+                            {
+                                l.trace(meta[1]);
+                                int gid = Integer.valueOf(meta[1].trim());
+                                if (gid < 0)
+                                {
+                                    l.trace("NULL0");
+                                    throw new NumberFormatException();
+                                }
+                                itm.setGID(gid); 
+                            }
+                            catch (NumberFormatException x)
+                            {
+                                syntaxError = true;
+                                l.error("Syntax error on line {} of file {}: {}", lne, path, "Block2 muss eine Ganzzahl >=0 sein");
+                                itm.setGID(0);
+                            }
+                        }
+                        else
+                        {
+                            syntaxError=true;
+                            l.error("Syntax error on line {} of file {}: {}",lne,path,"Could not determine Metadata block type");
+                        }
+                    }
+                }
+                else
+                {
+                    if(ln.startsWith("#EXTINF"))
+                    {
+                        extinf=true;
+                        itm.setTitle(ln);
+                    }
+                    else
+                    {
+                        if(!ln.startsWith("#"))
+                        {
+                            if(!extinf)
+                            {
+                                itm.setTitle("#EXTINF,0,"+FileTK.getFileName(ln));
+                            }
+                            itm.setPath(ln);
+                            returndata.add(itm);
+                            itm=new SinglePlayListItem();
+                            extinf=false;
+                        }
+                    }
+                }
+                lne++;
+                ln=fr.readLine();
+            }
+            if(syntaxError)
+            {
+                throw new InvalidPlayListFileException();
+            }
+            return returndata;
+        }
+        catch (IOException ex)
+        {
+            return new ArrayList<>();
+        }
+    }
+    
+    public static List<PlayListItem> parseFullList(String path)
+    {
+        return parseFullList(path, 40);
+    }
+    
+    
+    public static List<PlayListItem> parseFullList(String path,int rd)
+    {
+        String plbd = FileTK.getFilePath(path);
+        HashMap<Integer,MultiPlayListItem> groups = new HashMap<>();
+        List<PlayListItem> result = new ArrayList<>();
+        try
+        {
+            List<SinglePlayListItem> rootList = readSingleList(path);
+            l.trace(y.dump(rootList));
+            for (SinglePlayListItem re : rootList)
+            {
+                if(re.isIncludeElement())
+                {
+                    if(re.noexpandoninclude())
+                    {
+                        MultiPlayListItem m = processNoExpandInclude(plbd+File.separator+re.getPath(),rd);
+                        if(m!=null)
+                        {
+                            m.setTargetPlaycount(re.getTargetPlaycount());
+                            result.add(m);
+                        }
+                    }
+                    else
+                    {
+                        List<PlayListItem> temp = parseFullList(plbd+File.separator+re.getPath(),rd-1);
+                        temp.forEach((ple)->ple.setTargetPlaycount(ple.getTargetPlaycount()*re.getTargetPlaycount()));
+                        result.addAll(temp);
+                    }
+                }
+                else
+                {
+                    int gid=re.getGID();
+                    if(gid==0)
+                    {
+                        result.add(re);
+                    }
+                    else
+                    {
+                        if(!groups.containsKey(gid))
+                        {
+                            groups.put(gid,new MultiPlayListItem());
+                        }
+                        MultiPlayListItem gt = groups.get(gid);
+                        gt.addItem(re);
+                    }
+                }
+            }
+        }
+        catch(InvalidPlayListFileException x)
+        {
+            l.error("Malformed file: stopping parsing");
+            Main.quickQuit();
+        }
+        return result;
+    }
+    
+    private static MultiPlayListItem processNoExpandInclude(String path,int rd) throws InvalidPlayListFileException
+    {
+        MultiPlayListItem mi = new MultiPlayListItem();
+        if(rd<0)
+        {
+            return null;
+        }
+        rd--;
+        List<SinglePlayListItem> raw = readSingleList(path);
+        for (SinglePlayListItem spi : raw)
+        {
+            if(spi.isIncludeElement())
+            {
+                mi.addItem(processNoExpandInclude(spi.getPath(), rd));
+            }
+            else
+            {
+                mi.addItem(spi);
+            }
+        }
+        return mi;
+    }
+
+    private PLReader2()
+    {
+    }
+    
+    
+}

iZplPlugins/Editor/src/main/java/de/nplusc/izc/izpl/plugins/editor/Editor.java

@@ -7,6 +7,9 @@
 package de.nplusc.izc.izpl.plugins.editor;
 
 import de.nplusc.izc.iZpl.API.FeaturePlugin;
+import de.schlichtherle.truezip.file.TFile;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 /**
  *
@@ -14,11 +17,26 @@ import de.nplusc.izc.iZpl.API.FeaturePlugin;
  */
 public class Editor implements FeaturePlugin
 {
-
+    private static final Logger l = LogManager.getLogger();
     @Override
     public void parseParameter(String param)
     {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        if(param==null||param.equals(""))
+        {
+            //newfilehandling
+        }
+        else
+        {
+            if(new TFile(param).exists())
+            {
+                loadPlayListIntoGraph(param);
+            }
+            else
+            {
+                l.error("Keine gültige r00tPlayList");
+            }
+                
+        }
     }
 
     @Override
@@ -50,5 +68,15 @@ public class Editor implements FeaturePlugin
     {
         
     }
+
+    @Override
+    public boolean requiresLoadedPlayList()
+    {
+       return false;
+    }
     
+    private void loadPlayListIntoGraph(String path)
+    {
+        
+    }
 }

iZplPlugins/Editor/src/main/java/de/nplusc/izc/izpl/plugins/editor/PlayListFile.java

@@ -6,11 +6,40 @@
 
 package de.nplusc.izc.izpl.plugins.editor;
 
+import de.nplusc.izc.iZpl.API.PlayListItem;
+import java.util.List;
+
 /**
  *
  * @author iZc <nplusc.de>
  */
 public class PlayListFile
 {
+    private List<PlayListItem> entries;
+
+    public List<PlayListItem> getEntries()
+    {
+        return entries;
+    }
+
+    public void setEntries(List<PlayListItem> entries)
+    {
+        this.entries = entries;
+    }
+
+    public String getPath()
+    {
+        return path;
+    }
+
+    public void setPath(String path)
+    {
+        this.path = path;
+    }
+    private String path;
+    
+    
+    
+    
     
 }