/*
 * TileMemoryLoadCanvas.java
 *
 * Created on June 9, 2006, 5:24 PM
 */

package Current.popups.Memory;

import Current.gui.*;
import Current.manage.*;
import Current.plot.Plotters.XPlotter;
import Current.canvases.Plot.PlotCanvas;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.io.*;

import org.pat.graphics.boxed.ListenString;
/**
 *
 * @author  pat
 */
public class TileMemoryLoadCanvas extends StringListCanvas {
    
    public static class TileMemoryLoadOptions extends Container
    implements MouseListener, ComponentListener {
        TileMemoryContainer cont;
        String filename;
        LinkedList tiles;
        
        int mode;
        ListenString[] LS=new ListenString[2];
        ListenString[] OPT=new ListenString[5];
        private double y=4;
        
        PlotCanvas plot;
        
        public TileMemoryLoadOptions(TileMemoryContainer cont,
        String filename, LinkedList tiles) {
            this.cont=cont;
            this.filename=filename;
            this.tiles=tiles;
            
            setBackground(cont.getBackground());
            setFont(new Font("sanserif", Font.PLAIN, 12));
            
            LS[0]=new ListenString("file: "+filename, this);
            LS[0].showBorder=false;
            LS[1]=new ListenString("Loaded "+tiles.size()+" tiles.", this);
            LS[1].showBorder=false;
            
            for (int i=0; i<LS.length; i++) {
                LS[i].setColors(Color.black, getBackground());
                LS[i].setLeft(4);
                LS[i].setTop(y);
                y=LS[i].getBottom()+4;
            }
            
            int wo=0;
            for (ListIterator it=tiles.listIterator(); it.hasNext();) {
                if (((Tile)(it.next())).getPlotter()==null) {
                    wo++;
                }
            }
            if (wo==0) {
                mode=0;
                OPT[0]=new ListenString("All tiles have a plotter", this);
                OPT[0].showBorder=false;
                OPT[0].setColors(Color.black, getBackground());
                OPT[0].setLeft(4);
                OPT[0].setTop(y);
                y=OPT[0].getBottom()+4;
                
                OPT[1]=new ListenString("plot all as is", this);
                OPT[1].setColors(Color.black, cont.buttonBg);
                OPT[1].setLeft(4);
                OPT[1].setTop(y);
                
                OPT[2]=new ListenString(" or", this);
                OPT[2].showBorder=false;
                OPT[2].setColors(Color.black, getBackground());
                OPT[2].setLeft(OPT[1].getRight()+4);
                OPT[2].setTop(y);
                y=OPT[2].getBottom()+4;
                
                OPT[3]=new ListenString("plot with another plotter", this);
                OPT[3].setColors(Color.black, cont.buttonBg);
                OPT[3].setLeft(4);
                OPT[3].setTop(y);
                y=OPT[3].getBottom()+4;
            } else {
                mode=1;
                OPT[0]=new ListenString(""+wo+" tiles need a default plotter", this);
                OPT[0].showBorder=false;
                OPT[0].setColors(Color.black, getBackground());
                OPT[1]=new ListenString("default plotter:", this);
                OPT[1].showBorder=false;
                OPT[1].setColors(Color.black, getBackground());
                
                for (int i=0; i<OPT.length; i++) {
                    if (OPT[i]!=null) {
                        OPT[i].setLeft(4);
                        OPT[i].setTop(y);
                        y=OPT[i].getBottom()+4;
                    }
                }
                
                plot=new PlotCanvas(cont.M);
                plot.plot_enabled=false;
                plot.setLocation((getWidth()-plot.getWidth())/2, (int)y);
                add(plot);
                y+=4+plot.getHeight();
                
                OPT[2]=new ListenString("plot all as is", this);
                OPT[2].setColors(Color.black, cont.buttonBg);
                OPT[2].setLeft(4);
                OPT[2].setTop(y);
                
                OPT[3]=new ListenString(" or", this);
                OPT[3].showBorder=false;
                OPT[3].setColors(Color.black, getBackground());
                OPT[3].setLeft(OPT[2].getRight()+4);
                OPT[3].setTop(y);
                y=OPT[3].getBottom()+4;
                
                OPT[4]=new ListenString("plot all with default", this);
                OPT[4].setColors(Color.black, cont.buttonBg);
                OPT[4].setLeft(4);
                OPT[4].setTop(y);
                y=OPT[4].getBottom()+4;
                
                
            }
            
            addComponentListener(this);
            addMouseListener(this);
        }
        
        public void paint(Graphics gfx) {
            super.paint(gfx);
            Graphics2D g=(Graphics2D) gfx;
            
            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
            
            for (int i=0; i<LS.length; i++) {
                LS[i].render(g);
            }
            for (int i=0; i<OPT.length; i++) {
                if (OPT[i]!=null) {
                    OPT[i].render(g);
                }
            }
        }
        
        public void mouseClicked(MouseEvent e) {
            if (mode==0) {
                if (OPT[1].contains(e)) {
                    cont.queue.add(tiles,(XPlotter)(null),false);
                    cont.setCenter(new TilePlotQueueCanvas(cont));
                }
                if (OPT[3].contains(e)) {
                    mode=2;
                    
                    OPT[0].str="set plotter:";
                    OPT[0].setColors(Color.black, getBackground());
                    OPT[0].size();
                    OPT[0].showBorder=false;
                    
                    plot=new PlotCanvas(cont.M);
                    plot.plot_enabled=false;
                    plot.setLocation((getWidth()-plot.getWidth())/2,
                    (int)(OPT[0].getBottom()+4));
                    add(plot);
                    
                    OPT[1].str="plot all with default";
                    OPT[1].setColors(Color.black, cont.buttonBg);
                    OPT[1].size();
                    OPT[1].showBorder=true;
                    OPT[1].setTop(8+OPT[0].getBottom()+plot.getHeight());
                    
                    OPT[2]=OPT[3]=null;
                    
                    repaint();
                }
            }
            if (mode==1) {
                if (OPT[2].contains(e)) {
                    cont.queue.add(tiles,plot.getPlotter(),false);
                    cont.setCenter(new TilePlotQueueCanvas(cont));
                }
                if (OPT[4].contains(e)) {
                    cont.queue.add(tiles,plot.getPlotter(),true);
                    cont.setCenter(new TilePlotQueueCanvas(cont));
                }
            }
            if (mode==2) {
                if (OPT[1].contains(e)) {
                    cont.queue.add(tiles,plot.getPlotter(),true);
                    cont.setCenter(new TilePlotQueueCanvas(cont));
                }
            }
        }
        
        public void mouseEntered(MouseEvent e) {
        }
        
        public void mouseExited(MouseEvent e) {
        }
        
        public void mousePressed(MouseEvent e) {
        }
        
        public void mouseReleased(MouseEvent e) {
        }
        
        public void componentHidden(java.awt.event.ComponentEvent componentEvent) {
        }
        
        public void componentMoved(java.awt.event.ComponentEvent componentEvent) {
        }
        
        public void componentResized(java.awt.event.ComponentEvent componentEvent) {
            if (plot!=null) {
                Point p=plot.getLocation();
                plot.setLocation((getWidth()-plot.getWidth())/2, p.y);
            }
        }
        
        public void componentShown(java.awt.event.ComponentEvent componentEvent) {
        }
        
    }
    
    
    TileMemoryContainer cont;
    
    /** Creates a new instance of TileMemoryLoadCanvas */
    public TileMemoryLoadCanvas(TileMemoryContainer cont) {
        this.cont=cont;
        
        setBackground(new Color(222,144,60));
        
        setColors(getBackground(), new Color(100,100,255), Color.yellow, Color.black);
        
        LinkedList ll=new LinkedList();
        try {
            String thisLine;
            InputStream is = cont.M.getInputStream("Files/tile_files");
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            thisLine = br.readLine();
            if (thisLine!=null)
                do {
                    //System.out.println(thisLine);
                    ll.add(thisLine);
                } while ((thisLine = br.readLine()) != null);
            else
                System.out.println("No tile files found.");
        }
        catch (Exception e) {
            System.out.println("Error reading tile files...");
            e.printStackTrace();
        }
        String[] file_names=new String[ll.size()];
        int i=0;
        for (ListIterator it=ll.listIterator(); it.hasNext();i++){
            file_names[i]=(String)it.next();
        }
        setNames(file_names);
    }
    
    public Dimension getPreferredSize() {
        return new Dimension(200,200);
    }
    
    public void deselect() {
    }
    
    public void select(String str) {
        TileMemory memory=new TileMemory(cont.M,str);
        LinkedList tiles=memory.load();
        cont.setCenter(new TileMemoryLoadOptions(
        cont, str, tiles));
    }
    
}