C:/Projekte/I2BPro/src/i2bpro/layer/Layer.java

package i2bpro.layer;

import i2bpro.Exceptions.LayerException;
import i2bpro.playlist.PlayList;
import i2bpro.player.Player;
import i2bpro.Exceptions.PlayListException;
import i2bpro.layer.Menus.MainMenu;
import i2bpro.layer.Panels.CenterPanel;
import i2bpro.layer.Panels.EastPanel;
import i2bpro.layer.Panels.SouthPanel;
import java.awt.BorderLayout;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.MalformedURLException;
import java.util.HashMap;
import java.util.Random;
import javax.media.NoPlayerException;
import javax.swing.JPanel;
import org.jaudiotagger.audio.exceptions.CannotReadException;
import org.jaudiotagger.audio.exceptions.InvalidAudioFrameException;
import org.jaudiotagger.audio.exceptions.ReadOnlyFileException;
import org.jaudiotagger.tag.TagException;



public final class Layer extends javax.swing.JFrame 
{
    //  einzigste Instanz der Klasse Layer im Audioplayer
    private static  Layer instance = new Layer();

    //  Hauptmenu
    private MainMenu mainmenu = new MainMenu();
    
    //  Hauptpanel und weitere Unterpanel
    private JPanel mainPanel = new JPanel();
    private EastPanel eastPanel = new EastPanel();
    private SouthPanel southPanel = new SouthPanel();
    private CenterPanel centerPanel = new CenterPanel();

    //  diverse Attribute welche zur Registrierung verschiedener Zustände
    //  verwendet werden
    private boolean isTableChanged = false;
    private boolean PositionUpdate = false;
    private boolean isPlayerStarting = false;
    private int old_pos = 0;
    private int old_id = -1;
    private int id = -1;
    private boolean isSave = false;     //  registriert Änderung in der PlayList
    private boolean isRandom = false;   //  registriert den Status Zufall
    private int random_id = -1;
    private int last_id, first_id;

    //  die HashMaps werden zur Speicherung der Abspielreihenfolge beim
    //  Abspielen nach dem Zufall verwendet.
    private HashMap<Integer, Integer> vorher = new HashMap<Integer, Integer>();
    private HashMap<Integer, Integer> nachher = new HashMap<Integer, Integer>();



    private Layer()
    {
        super("I2BPro");    //  Fenstertitel an JFrame übergeben

        //  Methode zum Beenden des Audioplayers festlegen
        addWindowListener(new WindowClosingAdapter(true));
        setJMenuBar(mainmenu);  // Hauptmenü an JFrame übergeben

        //  Panels initialisieren lassen und Hauptpanel dem Frame übergeben.
        add(createMainPanel());
    }



    private JPanel createMainPanel()
    {
        mainPanel.setLayout(new BorderLayout(5,5));
        mainPanel.add(eastPanel, BorderLayout.EAST);
        mainPanel.add(centerPanel, BorderLayout.CENTER);
        mainPanel.add(southPanel, BorderLayout.SOUTH);
        return mainPanel;
    }



    public static Layer getInstance() { return instance; }



    public void run() 
    {
        Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
        int hoehe = (int)(dim.getHeight() * 0.75);
        int breite = (int)(dim.getWidth() * 0.75);
        int y = (int)((dim.getHeight()/2)-(hoehe/2));
        int x = (int)((dim.getWidth()/2)-(breite/2));
        setBounds(x, y, breite, hoehe);
        setVisible(true);
    }



    public void run(String filename) throws PlayListException, 
            FileNotFoundException, IOException, CannotReadException,
            TagException, ReadOnlyFileException, InvalidAudioFrameException
    {
        PlayList.getInstance().setPlayList(filename);
        centerPanel.PlayListChange();
        run();
    }



    public void Reset()
    {
        isTableChanged = false;
        PositionUpdate = false;
        isPlayerStarting = false;
        setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
    }



    public void play() throws LayerException, MalformedURLException,
            IOException, NoPlayerException
    {
        if (Player.getInstance().getState() != 2)
            id = centerPanel.getSelectedRow();
        StartPlay();
    }



    public void play(int new_id) throws LayerException, MalformedURLException,
            IOException, NoPlayerException
    {
        id = new_id;
        StartPlay();
    }



    private void StartPlay() throws LayerException, MalformedURLException,
            IOException, NoPlayerException
    {
        if (isRandom)
        {
            id = random_id;
        } else {
            if (PlayList.getInstance().getFileName() == null)
                throw new LayerException(100);
            if (PlayList.getInstance().getPlayList().isEmpty())
                throw new LayerException(101);
            if (id < 0) throw new LayerException(102);
        }
        if (!isPlayerStarting && !isTableChanged)
        {
            if (Player.getInstance().getState() == 1) stop();
            if (Player.getInstance().getState() == 2)
                centerPanel.updateUI();
            isPlayerStarting = true;
            Player.getInstance().play(id);
        }
    }



    public void PlayerStarted()
    {
        eastPanel.PlayerStarted();
        southPanel.PlayerStarted();
        mainmenu.PlayerStarted();
        centerPanel.updateUI();
        old_id = id;
        isPlayerStarting = false;
    }


    
    public boolean isPositionUpdate() {return PositionUpdate; }



    public void setPositionUpdate(boolean val) { PositionUpdate = val; }



    public void PositionUpdate()
    {
        PositionUpdate = true;
        southPanel.setPositionLabel(Player.getInstance().getPosition().getString());
        southPanel.setPositionValue(Player.getInstance().getPosition().getSeconds());
    }



    public void pause()
    {
        if (Player.getInstance().getState() == 1) Player.getInstance().pause();
    }



    public void PlayerPaused()
    {
        southPanel.PlayerPaused();
        mainmenu.PlayerPause();
    }



    public void stop()
    {
        if (Player.getInstance().getState() > 0) Player.getInstance().stop();
    }



    public void PlayerStopped()
    {
        southPanel.PlayerStopped();
        mainmenu.PlayerStopped();
        centerPanel.updateUI();
    }



    public void PlayerEndOfMedia() throws LayerException, MalformedURLException,
            IOException, NoPlayerException
    {
        if (isRandom)
        {
            random_id = nachher.get(random_id);
            if (random_id != -1) play();
        } else  {
            int new_id = id + 1;
            if (new_id < PlayList.getInstance().getPlayList().size())
            {
                play(new_id);
            } else {
                id = -1;
                centerPanel.updateUI();
            }
        }
    }



    public void Prior() throws LayerException, MalformedURLException,
            IOException, NoPlayerException
    {
        if (PlayList.getInstance().getPlayList().size() > 0)
        {
            if (isRandom)
            {
                random_id = vorher.get(random_id);
                if (random_id == -1) random_id = last_id;
                play(random_id);
            } else {
                int new_id = id - 1;
                if (new_id < 0) new_id =
                        PlayList.getInstance().getPlayList().size() - 1;
                play(new_id);
            }
        }
    }



    public void Next() throws LayerException, MalformedURLException,
            IOException, NoPlayerException
    {
        if (isRandom)
        {
            random_id = nachher.get(random_id);
            if (random_id == -1) random_id = first_id;
            play(random_id);
        } else {
            int new_id  = id + 1;
            if (new_id > PlayList.getInstance().getPlayList().size() - 1)
                new_id = 0;
            play(new_id);
        }
    }



    public void toggleMute()
    {
        Player.getInstance().toggleMute();
    }



    public void toggledMute()
    {
        southPanel.toggledMute();
        mainmenu.toggledMute();
    }



    public void PlayListChange()
    {
        centerPanel.PlayListChange();
        if (PlayList.getInstance().getPlayList().isEmpty() != true)
        {
            id = -1;
            mainmenu.getMenu(0).getMenuComponent(5).setEnabled(true);
        } else {
            mainmenu.getMenu(0).getMenuComponent(5).setEnabled(false);
        }
    }



    public void setVolume(int volume)
    {
        eastPanel.setVolumeValue(volume);
    }



    public void setSave(boolean isSave)
    {
        this.isSave = isSave;
        mainmenu.getMenu(0).getMenuComponent(2).setEnabled(isSave);
    }



    public boolean isSave() { return isSave; }



    public Integer getID() { return id; }



    public void DeleteMedia() throws LayerException
    {
        DeleteMedia(centerPanel.getSelectedRow());
    }



    public void DeleteMedia(int del_id) throws LayerException
    {
        if (del_id < 0) throw new LayerException(103);
        if ((del_id == id) && (Player.getInstance().getState() > 0)) stop();
        PlayList.getInstance().DeleteMedia(del_id);
        if ((del_id < id) && (id > -1)) id--;
        if (id > -1) centerPanel.setRowSelection(del_id);
    }



    public boolean toggleRandom() throws LayerException, MalformedURLException,
            IOException, NoPlayerException
    {
        if (isRandom) isRandom = false; else StartRandom();
        return isRandom;
    }



    private void StartRandom() throws LayerException, MalformedURLException,
            IOException, NoPlayerException
    {
        isRandom = true;
        vorher.clear();
        nachher.clear();
        int size = PlayList.getInstance().getPlayList().size();
        Random r = new Random();
        int num = Math.abs(r.nextInt()) % size;
        vorher.put(num, -1);
        first_id = num;
        int now = num;
        for (int i=0; i<size-1; i++)
        {
            do { num = Math.abs(r.nextInt()) % size; }
            while (vorher.get(num) != null);
            vorher.put(num, now);
            nachher.put(now, num);
            now = num;
        }
        nachher.put(now, -1);
        random_id = first_id;
        last_id = now;
    }
}