source: tmcsimulator-scriptbuilder/trunk/src/scriptbuilder/structures/ScriptIncident.java @ 164

package scriptbuilder.structures;



import java.awt.Color;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.util.ArrayList;

import java.util.TreeMap;

import scriptbuilder.structures.events.I_ScriptEvent;

import scriptbuilder.structures.ScriptEvent.ScriptEventType;

import scriptbuilder.structures.events.I_AudioEvent;

import scriptbuilder.structures.events.AudioEvent;



/**

 * A script incident. It has an ID number, a name, and a description. It may

 * contain several script events. It also has a color in the GUI window, and is

 * collapsible. Incidents may start as soon as the script begins to run, or they

 * can be offset from the start of the script.

 *

 * @author Greg Eddington <geddingt@calpoly.edu>

 * @author Bryan McGuffin

 * @version 2017/06/29

 */

public class ScriptIncident implements I_XML_Writable

{



    /**

     * The moments in time which have associated events.

     */

    public TreeMap<Integer, TimeSlice> slices;



    /**

     * GUI display color of this slice.

     */

    public Color color;



    /**

     * ID number for this incident.

     */

    public int number;



    /**

     * Name of the incident.

     */

    public String name;



    /**

     * Description of the incident.

     */

    public String description;

    

    /**

     * Length, in seconds, of the incident.

     */

    public int length = 0;



    /**

     * If true, incident appears minimized.

     */

    public boolean collapsed = false;



    /**

     * Number of seconds between start of simulation and start of this incident.

     */

    public int offset = 0;



    /**

     * Start position of the latest timeslice.

     */

    private int latestStart = 0;



    /**

     * Number of events in this incident.

     */

    public int eventCount = 0;

    

    public int audioEventCount = 0;



    public SimulationScript script;



    /**

     * Basic constructor.

     *

     * @param number The incident ID number

     * @param name The name of the incident

     * @param description The description of the incident

     * @param script The script object holding this incident

     */

    public ScriptIncident(int number, String name, String description,

            SimulationScript script)

    {

        color = Color.BLACK;

        this.number = number;

        this.name = name;

        this.description = description;

        this.script = script;

        slices = new TreeMap<Integer, TimeSlice>();

    }



    /**

     * Constructor with color parameter.

     *

     * @param color The color to use in the GUI for this event

     * @param number The incident ID number

     * @param name The name of the incident

     * @param description The description of the incident

     * @param script The script object holding this incident

     */

    public ScriptIncident(Color color, int number, String name,

            String description, SimulationScript script)

    {

        this.color = color;

        this.number = number;

        this.name = name;

        this.description = description;

        this.script = script;

        slices = new TreeMap<Integer, TimeSlice>();

    }



    /**

     * Constructor with color and offset parameters.

     *

     * @param color The color to use in the GUI for this event

     * @param number The incident ID number

     * @param name The name of the incident

     * @param description The description of the incident

     * @param script The script object holding this incident

     * @param offset Number of seconds after 00:00:00 that this incident begins

     */

    public ScriptIncident(Color color, int number, String name,

            String description, SimulationScript script,

            int offset)

    {

        this.color = color;

        this.number = number;

        this.name = name;

        this.description = description;

        this.script = script;

        slices = new TreeMap<Integer, TimeSlice>();

        this.setOffset(offset);

    }

    

//    /**

//     * Constructor with type and location parameters.

//     * @param color

//     * @param number

//     * @param name

//     * @param description

//     * @param script

//     * @param offset

//     * @param type

//     * @param location 

//     */

//    public ScriptIncident(Color color, int number, String name,

//            String description, SimulationScript script,

//            int offset, String type, String location)

//    {

//        this.color = color;

//        this.number = number;

//        this.name = name;

//        this.description = description;

//        this.script = script;

//        slices = new TreeMap<Integer, TimeSlice>();

//        this.setOffset(offset);

//        this.location = location;

//        this.type = type;

//        insertCadData(offset, new CadData(type,location));

//    }



    /**

     * Set whether or not the incident is fully visible or in a compacted state.

     *

     * @param collapsed True if the event is compacted

     */

    public void setCollapsed(boolean collapsed)

    {

        this.collapsed = collapsed;

        script.update();

    }



    /**

     * Set the delay time between the start of the script and the start of this

     * incident.

     *

     * @param offset Number of seconds after 00:00:00 that this incident begins

     */

    public void setOffset(int offset)

    {

        int old = this.offset;

        this.offset = offset;

        TreeMap<Integer, TimeSlice> newSlices = new TreeMap<Integer, TimeSlice>();



        int latest = 0;



        for (Integer k : slices.keySet())

        {

            newSlices.put(k + (offset - old), slices.get(k));

            latest = k + (offset - old);

        }



        latestStart = latest;



        for (TimeSlice ts : newSlices.values())

        {

            ts.shift(offset - old);

        }



        slices = newSlices;

        updateLength();

        script.update();

    }

    /**

     * shifts all timeslices over by timeAdd amount starting at offset

     * @param offset amount of time preceding where we want to move all of the following events.

     * @param timeAdd amount of time added after offset 

     */

    public void moveAllFollowingEvents(int offset, int timeAdd)

    {

        //int old = this.offset;

        TreeMap<Integer, TimeSlice> newSlices = new TreeMap<Integer, TimeSlice>();



        



        for (Integer k : slices.keySet())

        {

            if(k<offset)

            {

                newSlices.put(k, slices.get(k));

            }else

            {

                if(k+timeAdd >0)

                {

                    newSlices.put(k+timeAdd, slices.get(k));

                }else

                {

                    newSlices.put(0, slices.get(k));

                }

                

            }

            

            

        }

        for (TimeSlice ts : newSlices.values())

        {

            if(ts.getTime()>offset )

            {

                if( ts.getTime()+timeAdd>=0)

                {

                    ts.shift(timeAdd);

                }

                else

                {

                    ts.shift(-ts.getTime());

                }

                

            }

            

        }

        latestStart = (latestStart + timeAdd>0) ? latestStart + timeAdd: 0;

        slices = newSlices;

        updateLength();

        script.update();

    }

    /**

     * Add a new script event to this incident.

     *

     * @param ev The new event

     * @param start Start time of this event, in seconds, from the beginning of

     * the simulation

     */

    public void addNewEvent(I_ScriptEvent ev, int start)

    {

        /*

        int leftoverSeconds = start % 60;

        

        //round start time to the nearest minute

        if(leftoverSeconds != 0)

        {

            if(leftoverSeconds > 30)

            {

                start += (60 - leftoverSeconds);

            }

            else

            {

                start -= leftoverSeconds;

            }

        }

        */

        

        //Check to see if there's already a timeslice here

        TimeSlice t = slices.get(start);

        //logic to check if the added event needs to also have an associated audio event.

        

        //If not, make one; then, add the event to it

        if (t == null)

        {

            t = new TimeSlice(start, this);

            //t.addEvent(ev);

            slices.put(start, t);

        }

        else

        {

            //t.addEvent(ev);

        }

        t.addEvent(ev);

        if(ev instanceof I_AudioEvent){

            //should make a path and a different filename fields for the file itself. Either that or deal with the string separation each time

            //needs a check for when we move I_AudioEvents in the incident, as to not make duplicate events.

            String fileName = number+"/"+number + "" + audioEventCount;

            AudioEvent audio = (AudioEvent) ScriptEvent.factoryByType(ScriptEventType.AUDIO_EVENT);

            ((I_AudioEvent) ev).setFileName(fileName);

            audio.setAudioFilePathRelative(fileName);

            

            t.addEvent(audio);

            audioEventCount++;

        }

        eventCount++;



        //If this is the latest start time in the incident, update that number

        if (start > latestStart)

        {

            latestStart = start;

        }

        //If this event is earlier than all previous events, or if there are 

        //no other events, the offset is equal to this event's start time

        if (start < offset || eventCount == 1)

        {

            offset = start;

            //System.out.println("Offset: " + offset);

        }

        updateLength();

    }



    /**

     * Get an array of all valid timeSlices.

     *

     * @return List of timeSlices which are not null

     */

    public ArrayList<TimeSlice> getSlices()

    {

        ArrayList<TimeSlice> arr = new ArrayList<TimeSlice>();

        for (int i = 0; i <= latestStart; i++)

        {

            TimeSlice ts = slices.get(i);

            if (ts != null)

            {

                arr.add(ts);

            }

        }

        return arr;

    }



    /**

     * Write this incident, in proper XML form, to the file in question.

     *

     * @param f the destination savefile

     */

    public void saveIncidentToFile(File f)

    {

        try

        {

            f.createNewFile();



            BufferedWriter bw = new BufferedWriter(new FileWriter(f));

            bw.write(this.toXML());

            bw.flush();

            bw.close();



        }

        catch (Exception ex)

        {

            System.out.println("ERROR SAVING SCRIPT");

            ex.printStackTrace();

        }

    }



    @Override

    public String toXML()

    {

        String output = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n";

        output += XMLWriter.internalDTD();

        output += XMLWriter.openTag(ELEMENT.TMC_SCRIPT.tag + " title=\"" + this.script.title + "\"");



        for (TimeSlice slice : slices.values())

        {

            output += slice.toXML();

        }

        output += XMLWriter.closeTag(ELEMENT.TMC_SCRIPT.tag);

        return output;

    }



    public void insertCadData(long currentEventTime, CadData cad)

    {

        int time = (int) currentEventTime;



        TimeSlice slice;



        if (slices.get(time) == null)

        {

            slices.put(time, new TimeSlice(time, this));

        }

        slice = slices.get(time);

        slice.cadData = cad;

    }

    

    public CadData getCadData(long currentEventTime)

    {

        int time = (int) currentEventTime;

        TimeSlice slice;

        

        slice = slices.get(time);

        return slice.cadData;

    }



    /**

     * Update the offset and apparent length of this incident. The offset is the

     * start time of the earliest event in the incident. The length is the time

     * that the latest, longest-lasting event ends, minus the offset.

     */

    public void updateLength()

    {

        int lengthSoFar = 0;

        for (int i = 0; i <= latestStart; i++)

        {

            TimeSlice ts = slices.get(i);

            if (ts != null)

            {

                int reach = ts.getTime() + ts.getEffectiveDuration() - offset;

                if (reach > lengthSoFar)

                {

                    lengthSoFar = reach;

                }

            }

        }

        length = lengthSoFar;

    }



    /**

     * An event which is fired if the focused slice changes.

     */

    public static class SliceChangedEvent

    {



        /**

         * The slice which has received focus in this event.

         */

        public TimeSlice slice;



        SliceChangedEvent(TimeSlice slice)

        {

            this.slice = slice;

        }

    }



    /**

     * Update and cause the system to focus on the given timeslice.

     *

     * @param i Index of the slice to focus on

     */

    public void setSliceActive(int i)

    {

        if (this.slices.get(i) != null)

        {

            script.broadcastEvent(new SliceChangedEvent(this.slices.get(i)));

        }

    }



    /**

     * An event which is fired if the focused incident changes.

     */

    public static class IncidentFocusedEvent

    {



        /**

         * The incident which has received focus in this event.

         */

        public ScriptIncident incident;



        IncidentFocusedEvent(ScriptIncident i)

        {

            incident = i;

        }

    }



    /**

     * Update and cause the system to focus on this incident.

     */

    public void setIncidentActive()

    {

        script.broadcastEvent(new IncidentFocusedEvent(this));

    }



    /**

     * String representation of this incident.

     *

     * @return String of the form "[Incident number] - [Incident name]"

     */

    @Override

    public String toString()

    {

        return this.number + " - " + this.name;

    }



    /**

     * Remove the timeslice at the given position.

     *

     * @param seconds absolute start time of the timeslice to remove.

     */

    public void removeTimeSlice(int seconds)

    {

        //remove the timeslice

        this.slices.remove(seconds);



        //offset is equivalent to start time of earliest slice

        if (seconds == offset)

        {

            if (slices.size() > 0)

            {

                offset = slices.firstKey();

            }

            else

            {

                offset = 0;

            }

        }

        this.updateLength();

        script.update();

    }



    /**

     * Shifts the start time of a given event in this incident. The first event

     * in the incident cannot be shifted.

     *

     * @param evt the event to be relocated

     * @param oldTime the current start time of the event

     * @param newTime the destination start time of the event

     * @return true if the event is shifted over properly

     * @pre the event in question exists

     * @pre oldTime != newTime

     */

    public boolean changeEventStart(I_ScriptEvent evt, int oldTime, int newTime)

    {

        if (!(oldTime == 0 && newTime > oldTime))

        {

            if(evt instanceof I_AudioEvent)

            {

                //todo: need to figure out how to remove the audioEvent tha corresponds with the 

                this.slices.get(oldTime).removeCorrespondingAudioEvent((I_AudioEvent)evt);

                //this.addNewEvent(evt,newTime)

            }

            this.slices.get(oldTime).events.remove(evt);

            this.addNewEvent(evt, newTime);

            return true;

        }

        return false;

    }

}